other: merge 3.0

cmake/taostools_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taos-tools
 ExternalProject_Add(taos-tools
         GIT_REPOSITORY https://github.com/taosdata/taos-tools.git
-        GIT_TAG 0fb640b
+        GIT_TAG a921bd4
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taos-tools"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

include/common/tmsg.h

@@ -1805,7 +1805,7 @@ int32_t tDeserializeSCMCreateTopicRsp(void* buf, int32_t bufLen, SCMCreateTopicR
 
 typedef struct {
   int64_t consumerId;
-} SMqConsumerLostMsg, SMqConsumerRecoverMsg;
+} SMqConsumerLostMsg, SMqConsumerRecoverMsg, SMqConsumerClearMsg;
 
 typedef struct {
   int64_t consumerId;

include/common/tmsgdef.h

@@ -149,7 +149,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_TMQ_DO_REBALANCE, "do-rebalance", SMqDoRebalanceMsg, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_TMQ_DROP_CGROUP, "drop-cgroup", SMqDropCGroupReq, SMqDropCGroupRsp)
   TD_DEF_MSG_TYPE(TDMT_MND_UNUSED2, "unused2", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_TMQ_TIMER, "mq-tmr", SMTimerReq, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_TMQ_TIMER, "tmq-tmr", SMTimerReq, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_TELEM_TIMER, "telem-tmr", SMTimerReq, SMTimerReq)
   TD_DEF_MSG_TYPE(TDMT_MND_TRANS_TIMER, "trans-tmr", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_TTL_TIMER, "ttl-tmr", NULL, NULL)
@@ -171,6 +171,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_SHOW_VARIABLES, "show-variables", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_SERVER_VERSION, "server-version", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_UPTIME_TIMER, "uptime-timer", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, "lost-consumer-clear", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_MAX_MSG, "mnd-max", NULL, NULL)
 
   TD_NEW_MSG_SEG(TDMT_VND_MSG)

include/libs/stream/streamState.h

@@ -60,19 +60,19 @@ int32_t streamStateDel(SStreamState* pState, const SWinKey* key);
 int32_t streamStateClear(SStreamState* pState);
 void    streamStateSetNumber(SStreamState* pState, int32_t number);
 
-int32_t streamStateSessionAddIfNotExist(SStreamState* pState, SSessionKey* key, void** pVal, int32_t* pVLen);
+int32_t streamStateSessionAddIfNotExist(SStreamState* pState, SSessionKey* key, TSKEY gap, void** pVal, int32_t* pVLen);
 int32_t streamStateSessionPut(SStreamState* pState, const SSessionKey* key, const void* value, int32_t vLen);
 int32_t streamStateSessionGet(SStreamState* pState, SSessionKey* key, void** pVal, int32_t* pVLen);
 int32_t streamStateSessionDel(SStreamState* pState, const SSessionKey* key);
 int32_t streamStateSessionClear(SStreamState* pState);
-int32_t streamStateSessionGetKVByCur(SStreamStateCur* pCur, SSessionKey* pKey, const void** pVal, int32_t* pVLen);
+int32_t streamStateSessionGetKVByCur(SStreamStateCur* pCur, SSessionKey* pKey, void** pVal, int32_t* pVLen);
 int32_t streamStateStateAddIfNotExist(SStreamState* pState, SSessionKey* key, char* pKeyData, int32_t keyDataLen,
                                       state_key_cmpr_fn fn, void** pVal, int32_t* pVLen);
-int32_t streamStateSessionGetKey(SStreamState* pState, const SSessionKey* key, SSessionKey* curKey);
+int32_t streamStateSessionGetKeyByRange(SStreamState* pState, const SSessionKey* range, SSessionKey* curKey);
 
 SStreamStateCur* streamStateSessionSeekKeyNext(SStreamState* pState, const SSessionKey* key);
 SStreamStateCur* streamStateSessionSeekKeyCurrentPrev(SStreamState* pState, const SSessionKey* key);
-SStreamStateCur* streamStateSessionGetCur(SStreamState* pState, const SSessionKey* key);
+SStreamStateCur* streamStateSessionSeekKeyCurrentNext(SStreamState* pState, const SSessionKey* key);
 
 int32_t streamStateFillPut(SStreamState* pState, const SWinKey* key, const void* value, int32_t vLen);
 int32_t streamStateFillGet(SStreamState* pState, const SWinKey* key, void** pVal, int32_t* pVLen);
@@ -99,7 +99,9 @@ int32_t streamStateSeekLast(SStreamState* pState, SStreamStateCur* pCur);
 int32_t streamStateCurNext(SStreamState* pState, SStreamStateCur* pCur);
 int32_t streamStateCurPrev(SStreamState* pState, SStreamStateCur* pCur);
 
-// char* streamStateSessionDump(SStreamState* pState);
+#if 0
+char* streamStateSessionDump(SStreamState* pState);
+#endif
 
 #ifdef __cplusplus
 }

include/libs/sync/sync.h

@@ -139,6 +139,7 @@ typedef struct SSyncFSM {
   void (*FpReConfigCb)(const struct SSyncFSM* pFsm, const SRpcMsg* pMsg, const SReConfigCbMeta* pMeta);
   void (*FpLeaderTransferCb)(const struct SSyncFSM* pFsm, const SRpcMsg* pMsg, const SFsmCbMeta* pMeta);
   bool (*FpApplyQueueEmptyCb)(const struct SSyncFSM* pFsm);
+  int32_t (*FpApplyQueueItems)(const struct SSyncFSM* pFsm);
 
   void (*FpBecomeLeaderCb)(const struct SSyncFSM* pFsm);
   void (*FpBecomeFollowerCb)(const struct SSyncFSM* pFsm);

source/client/src/clientMain.c

@@ -990,7 +990,7 @@ void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
   // all data has returned to App already, no need to try again
   if (pResultInfo->completed) {
     // it is a local executed query, no need to do async fetch
-    if (QUERY_EXEC_MODE_LOCAL == pRequest->body.execMode) {
+    if (QUERY_EXEC_MODE_SCHEDULE != pRequest->body.execMode) {
       if (pResultInfo->localResultFetched) {
         pResultInfo->numOfRows = 0;
         pResultInfo->current = 0;

source/dnode/mnode/impl/inc/mndConsumer.h

@@ -44,6 +44,7 @@ SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer);
 SSdbRow *mndConsumerActionDecode(SSdbRaw *pRaw);
 
 int32_t mndSetConsumerCommitLogs(SMnode *pMnode, STrans *pTrans, SMqConsumerObj *pConsumer);
+int32_t mndSetConsumerDropLogs(SMnode *pMnode, STrans *pTrans, SMqConsumerObj *pConsumer);
 
 bool mndRebTryStart();
 void mndRebEnd();

source/dnode/mnode/impl/src/mndConsumer.c

@@ -32,7 +32,8 @@
 #define MND_CONSUMER_VER_NUMBER   1
 #define MND_CONSUMER_RESERVE_SIZE 64
 
-#define MND_CONSUMER_LOST_HB_CNT 3
+#define MND_CONSUMER_LOST_HB_CNT          3
+#define MND_CONSUMER_LOST_CLEAR_THRESHOLD 43200
 
 static int8_t mqRebInExecCnt = 0;
 
@@ -50,6 +51,7 @@ static int32_t mndProcessAskEpReq(SRpcMsg *pMsg);
 static int32_t mndProcessMqHbReq(SRpcMsg *pMsg);
 static int32_t mndProcessMqTimerMsg(SRpcMsg *pMsg);
 static int32_t mndProcessConsumerLostMsg(SRpcMsg *pMsg);
+static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg);
 static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg);
 
 int32_t mndInitConsumer(SMnode *pMnode) {
@@ -69,6 +71,7 @@ int32_t mndInitConsumer(SMnode *pMnode) {
   mndSetMsgHandle(pMnode, TDMT_MND_TMQ_TIMER, mndProcessMqTimerMsg);
   mndSetMsgHandle(pMnode, TDMT_MND_TMQ_CONSUMER_LOST, mndProcessConsumerLostMsg);
   mndSetMsgHandle(pMnode, TDMT_MND_TMQ_CONSUMER_RECOVER, mndProcessConsumerRecoverMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, mndProcessConsumerClearMsg);
 
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_CONSUMERS, mndRetrieveConsumer);
   mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_CONSUMERS, mndCancelGetNextConsumer);
@@ -162,6 +165,43 @@ FAIL:
   return -1;
 }
 
+static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg) {
+  SMnode              *pMnode = pMsg->info.node;
+  SMqConsumerClearMsg *pClearMsg = pMsg->pCont;
+  SMqConsumerObj      *pConsumer = mndAcquireConsumer(pMnode, pClearMsg->consumerId);
+  if (pConsumer == NULL) {
+    return 0;
+  }
+
+  mInfo("receive consumer clear msg, consumer id %" PRId64 ", status %s", pClearMsg->consumerId,
+        mndConsumerStatusName(pConsumer->status));
+
+  if (pConsumer->status != MQ_CONSUMER_STATUS__LOST_REBD) {
+    mndReleaseConsumer(pMnode, pConsumer);
+    return -1;
+  }
+
+  SMqConsumerObj *pConsumerNew = tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup);
+  pConsumerNew->updateType = CONSUMER_UPDATE__LOST;
+
+  mndReleaseConsumer(pMnode, pConsumer);
+
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pMsg, "clear-csm");
+  if (pTrans == NULL) goto FAIL;
+  if (mndSetConsumerDropLogs(pMnode, pTrans, pConsumerNew) != 0) goto FAIL;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto FAIL;
+
+  tDeleteSMqConsumerObj(pConsumerNew);
+  taosMemoryFree(pConsumerNew);
+  mndTransDrop(pTrans);
+  return 0;
+FAIL:
+  tDeleteSMqConsumerObj(pConsumerNew);
+  taosMemoryFree(pConsumerNew);
+  mndTransDrop(pTrans);
+  return -1;
+}
+
 static SMqRebInfo *mndGetOrCreateRebSub(SHashObj *pHash, const char *key) {
   SMqRebInfo *pRebInfo = taosHashGet(pHash, key, strlen(key) + 1);
   if (pRebInfo == NULL) {
@@ -206,15 +246,28 @@ static int32_t mndProcessMqTimerMsg(SRpcMsg *pMsg) {
       SMqConsumerLostMsg *pLostMsg = rpcMallocCont(sizeof(SMqConsumerLostMsg));
 
       pLostMsg->consumerId = pConsumer->consumerId;
-      SRpcMsg pRpcMsg = {
+      SRpcMsg rpcMsg = {
           .msgType = TDMT_MND_TMQ_CONSUMER_LOST,
           .pCont = pLostMsg,
           .contLen = sizeof(SMqConsumerLostMsg),
       };
-      tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &pRpcMsg);
+      tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
     }
-    if (status == MQ_CONSUMER_STATUS__LOST_REBD || status == MQ_CONSUMER_STATUS__READY) {
+
+    if (status == MQ_CONSUMER_STATUS__READY) {
       // do nothing
+    } else if (status == MQ_CONSUMER_STATUS__LOST_REBD) {
+      if (hbStatus > MND_CONSUMER_LOST_CLEAR_THRESHOLD) {
+        SMqConsumerClearMsg *pClearMsg = rpcMallocCont(sizeof(SMqConsumerClearMsg));
+
+        pClearMsg->consumerId = pConsumer->consumerId;
+        SRpcMsg rpcMsg = {
+            .msgType = TDMT_MND_TMQ_LOST_CONSUMER_CLEAR,
+            .pCont = pClearMsg,
+            .contLen = sizeof(SMqConsumerClearMsg),
+        };
+        tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
+      }
     } else if (status == MQ_CONSUMER_STATUS__LOST) {
       taosRLockLatch(&pConsumer->lock);
       int32_t topicNum = taosArrayGetSize(pConsumer->currentTopics);
@@ -444,6 +497,14 @@ FAIL:
   return -1;
 }
 
+int32_t mndSetConsumerDropLogs(SMnode *pMnode, STrans *pTrans, SMqConsumerObj *pConsumer) {
+  SSdbRaw *pCommitRaw = mndConsumerActionEncode(pConsumer);
+  if (pCommitRaw == NULL) return -1;
+  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
+  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1;
+  return 0;
+}
+
 int32_t mndSetConsumerCommitLogs(SMnode *pMnode, STrans *pTrans, SMqConsumerObj *pConsumer) {
   SSdbRaw *pCommitRaw = mndConsumerActionEncode(pConsumer);
   if (pCommitRaw == NULL) return -1;

source/dnode/mnode/impl/src/mndSync.c

@@ -205,8 +205,23 @@ static void mndBecomeLeader(const SSyncFSM *pFsm) {
 static bool mndApplyQueueEmpty(const SSyncFSM *pFsm) {
   SMnode *pMnode = pFsm->data;
 
-  int32_t itemSize = tmsgGetQueueSize(&pMnode->msgCb, 1, APPLY_QUEUE);
-  return (itemSize == 0);
+  if (pMnode != NULL && pMnode->msgCb.qsizeFp != NULL) {
+    int32_t itemSize = tmsgGetQueueSize(&pMnode->msgCb, 1, APPLY_QUEUE);
+    return (itemSize == 0);
+  } else {
+    return true;
+  }
+}
+
+static int32_t mndApplyQueueItems(const SSyncFSM *pFsm) {
+  SMnode *pMnode = pFsm->data;
+
+  if (pMnode != NULL && pMnode->msgCb.qsizeFp != NULL) {
+    int32_t itemSize = tmsgGetQueueSize(&pMnode->msgCb, 1, APPLY_QUEUE);
+    return itemSize;
+  } else {
+    return -1;
+  }
 }
 
 SSyncFSM *mndSyncMakeFsm(SMnode *pMnode) {
@@ -218,6 +233,7 @@ SSyncFSM *mndSyncMakeFsm(SMnode *pMnode) {
   pFsm->FpRestoreFinishCb = mndRestoreFinish;
   pFsm->FpLeaderTransferCb = NULL;
   pFsm->FpApplyQueueEmptyCb = mndApplyQueueEmpty;
+  pFsm->FpApplyQueueItems = mndApplyQueueItems;
   pFsm->FpReConfigCb = NULL;
   pFsm->FpBecomeLeaderCb = mndBecomeLeader;
   pFsm->FpBecomeFollowerCb = mndBecomeFollower;
@@ -291,7 +307,7 @@ int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw, int32_t transId) {
 
   SRpcMsg req = {.msgType = TDMT_MND_APPLY_MSG, .contLen = sdbGetRawTotalSize(pRaw)};
   if (req.contLen <= 0) return -1;
-  
+
   req.pCont = rpcMallocCont(req.contLen);
   if (req.pCont == NULL) return -1;
   memcpy(req.pCont, pRaw, req.contLen);

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

@@ -438,8 +438,24 @@ static void vnodeBecomeLeader(const SSyncFSM *pFsm) {
 
 static bool vnodeApplyQueueEmpty(const SSyncFSM *pFsm) {
   SVnode *pVnode = pFsm->data;
-  int32_t itemSize = tmsgGetQueueSize(&pVnode->msgCb, pVnode->config.vgId, APPLY_QUEUE);
-  return (itemSize == 0);
+
+  if (pVnode != NULL && pVnode->msgCb.qsizeFp != NULL) {
+    int32_t itemSize = tmsgGetQueueSize(&pVnode->msgCb, pVnode->config.vgId, APPLY_QUEUE);
+    return (itemSize == 0);
+  } else {
+    return true;
+  }
+}
+
+static int32_t vnodeApplyQueueItems(const SSyncFSM *pFsm) {
+  SVnode *pVnode = pFsm->data;
+
+  if (pVnode != NULL && pVnode->msgCb.qsizeFp != NULL) {
+    int32_t itemSize = tmsgGetQueueSize(&pVnode->msgCb, pVnode->config.vgId, APPLY_QUEUE);
+    return itemSize;
+  } else {
+    return -1;
+  }
 }
 
 static SSyncFSM *vnodeSyncMakeFsm(SVnode *pVnode) {
@@ -452,6 +468,7 @@ static SSyncFSM *vnodeSyncMakeFsm(SVnode *pVnode) {
   pFsm->FpRestoreFinishCb = vnodeRestoreFinish;
   pFsm->FpLeaderTransferCb = NULL;
   pFsm->FpApplyQueueEmptyCb = vnodeApplyQueueEmpty;
+  pFsm->FpApplyQueueItems = vnodeApplyQueueItems;
   pFsm->FpBecomeLeaderCb = vnodeBecomeLeader;
   pFsm->FpBecomeFollowerCb = vnodeBecomeFollower;
   pFsm->FpReConfigCb = NULL;

source/libs/executor/src/groupoperator.c

@@ -908,6 +908,8 @@ static SSDataBlock* buildStreamPartitionResult(SOperatorInfo* pOperator) {
       blockDataDestroy(pResBlock);
     }
   }
+  taosArrayDestroy(pParInfo->rowIds);
+  pParInfo->rowIds = NULL;
   blockDataUpdateTsWindow(pDest, pInfo->tsColIndex);
   pDest->info.groupId = pParInfo->groupId;
   pOperator->resultInfo.totalRows += pDest->info.rows;
@@ -1006,6 +1008,7 @@ static void destroyStreamPartitionOperatorInfo(void* param) {
   cleanupExprSupp(&pInfo->tbnameCalSup);
   cleanupExprSupp(&pInfo->tagCalSup);
   blockDataDestroy(pInfo->pDelRes);
+  taosHashCleanup(pInfo->pPartitions);
   taosMemoryFreeClear(param);
 }
 

source/libs/executor/src/scanoperator.c

@@ -1420,7 +1420,7 @@ static int32_t generateSessionScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSr
     uint64_t groupId = getGroupIdByData(pInfo, uidCol[i], startData[i], version);
     // gap must be 0.
     SSessionKey startWin = {0};
-    getCurSessionWindow(pInfo->windowSup.pStreamAggSup, startData[i], endData[i], groupId, &startWin);
+    getCurSessionWindow(pInfo->windowSup.pStreamAggSup, startData[i], startData[i], groupId, &startWin);
     if (IS_INVALID_SESSION_WIN_KEY(startWin)) {
       // window has been closed.
       continue;

source/libs/executor/src/timewindowoperator.c

@@ -3528,7 +3528,7 @@ void getCurSessionWindow(SStreamAggSupporter* pAggSup, TSKEY startTs, TSKEY endT
   pKey->win.skey = startTs;
   pKey->win.ekey = endTs;
   pKey->groupId = groupId;
-  int32_t code = streamStateSessionGetKey(pAggSup->pState, pKey, pKey);
+  int32_t code = streamStateSessionGetKeyByRange(pAggSup->pState, pKey, pKey);
   if (code != TSDB_CODE_SUCCESS) {
     SET_SESSION_WIN_KEY_INVALID(pKey);
   }
@@ -3539,10 +3539,11 @@ bool isInvalidSessionWin(SResultWindowInfo* pWinInfo) { return pWinInfo->session
 void setSessionOutputBuf(SStreamAggSupporter* pAggSup, TSKEY startTs, TSKEY endTs, uint64_t groupId,
                          SResultWindowInfo* pCurWin) {
   pCurWin->sessionWin.groupId = groupId;
-  pCurWin->sessionWin.win.skey = startTs - pAggSup->gap;
-  pCurWin->sessionWin.win.ekey = endTs + pAggSup->gap;
+  pCurWin->sessionWin.win.skey = startTs;
+  pCurWin->sessionWin.win.ekey = endTs;
   int32_t size = pAggSup->resultRowSize;
-  int32_t code = streamStateSessionAddIfNotExist(pAggSup->pState, &pCurWin->sessionWin, &pCurWin->pOutputBuf, &size);
+  int32_t code =
+      streamStateSessionAddIfNotExist(pAggSup->pState, &pCurWin->sessionWin, pAggSup->gap, &pCurWin->pOutputBuf, &size);
   if (code == TSDB_CODE_SUCCESS) {
     pCurWin->isOutput = true;
   } else {
@@ -3553,7 +3554,7 @@ void setSessionOutputBuf(SStreamAggSupporter* pAggSup, TSKEY startTs, TSKEY endT
 
 int32_t getSessionWinBuf(SStreamAggSupporter* pAggSup, SStreamStateCur* pCur, SResultWindowInfo* pWinInfo) {
   int32_t size = 0;
-  int32_t code = streamStateSessionGetKVByCur(pCur, &pWinInfo->sessionWin, (const void**)&pWinInfo->pOutputBuf, &size);
+  int32_t code = streamStateSessionGetKVByCur(pCur, &pWinInfo->sessionWin, &pWinInfo->pOutputBuf, &size);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -3658,7 +3659,7 @@ SStreamStateCur* getNextSessionWinInfo(SStreamAggSupporter* pAggSup, SSHashObj*
   setSessionWinOutputInfo(pStUpdated, pNextWin);
   int32_t size = 0;
   pNextWin->sessionWin = pCurWin->sessionWin;
-  int32_t code = streamStateSessionGetKVByCur(pCur, &pNextWin->sessionWin, (const void**)&pNextWin->pOutputBuf, &size);
+  int32_t code = streamStateSessionGetKVByCur(pCur, &pNextWin->sessionWin, &pNextWin->pOutputBuf, &size);
   if (code != TSDB_CODE_SUCCESS) {
     SET_SESSION_WIN_INVALID(*pNextWin);
   }
@@ -3872,9 +3873,11 @@ static void rebuildSessionWindow(SOperatorInfo* pOperator, SArray* pWinArray, SS
       SOperatorInfo*                 pChild = taosArrayGetP(pInfo->pChildren, j);
       SStreamSessionAggOperatorInfo* pChInfo = pChild->info;
       SStreamAggSupporter*           pChAggSup = &pChInfo->streamAggSup;
-      SStreamStateCur*               pCur = streamStateSessionGetCur(pChAggSup->pState, pWinKey);
-      SResultRow*                    pResult = NULL;
-      SResultRow*                    pChResult = NULL;
+      SSessionKey                    chWinKey = *pWinKey;
+      chWinKey.win.ekey = chWinKey.win.skey;
+      SStreamStateCur* pCur = streamStateSessionSeekKeyCurrentNext(pChAggSup->pState, &chWinKey);
+      SResultRow*      pResult = NULL;
+      SResultRow*      pChResult = NULL;
       while (1) {
         SResultWindowInfo childWin = {0};
         childWin.sessionWin = *pWinKey;
@@ -4090,6 +4093,12 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) {
   initGroupResInfoFromArrayList(&pInfo->groupResInfo, pUpdated);
   blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
 
+#if 0
+  char* pBuf = streamStateSessionDump(pAggSup->pState);
+  qDebug("===stream===final session%s", pBuf);
+  taosMemoryFree(pBuf);
+#endif
+
   doBuildDeleteDataBlock(pInfo->pStDeleted, pInfo->pDelRes, &pInfo->pDelIterator);
   if (pInfo->pDelRes->info.rows > 0) {
     printDataBlock(pInfo->pDelRes, IS_FINAL_OP(pInfo) ? "final session" : "single session");
@@ -4282,6 +4291,12 @@ static SSDataBlock* doStreamSessionSemiAgg(SOperatorInfo* pOperator) {
   initGroupResInfoFromArrayList(&pInfo->groupResInfo, pUpdated);
   blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
 
+#if 0
+  char* pBuf = streamStateSessionDump(pAggSup->pState);
+  qDebug("===stream===semi session%s", pBuf);
+  taosMemoryFree(pBuf);
+#endif
+
   doBuildSessionResult(pOperator, pAggSup->pState, &pInfo->groupResInfo, pBInfo->pRes);
   if (pBInfo->pRes->info.rows > 0) {
     printDataBlock(pBInfo->pRes, "semi session");

source/libs/parser/src/parTranslater.c

@@ -2393,6 +2393,9 @@ static int32_t translateTable(STranslateContext* pCxt, SNode* pTable) {
         if (TSDB_SUPER_TABLE == pRealTable->pMeta->tableType) {
           pCxt->stableQuery = true;
         }
+        if (TSDB_SYSTEM_TABLE == pRealTable->pMeta->tableType && isSelectStmt(pCxt->pCurrStmt)) {
+          ((SSelectStmt*)pCxt->pCurrStmt)->isTimeLineResult = false;
+        }
         code = addNamespace(pCxt, pRealTable);
       }
       break;
@@ -3428,6 +3431,19 @@ static SNode* createSetOperProject(const char* pTableAlias, SNode* pNode) {
   return (SNode*)pCol;
 }
 
+// 0 means equal, 1 means the left shall prevail, -1 means the right shall prevail
+static int32_t dataTypeComp(const SDataType* l, const SDataType* r) {
+  if (l->type != r->type) {
+    return 1;
+  }
+
+  if (l->bytes != r->bytes) {
+    return l->bytes > r->bytes ? 1 : -1;
+  }
+
+  return (l->precision == r->precision && l->scale == r->scale) ? 0 : 1;
+}
+
 static int32_t translateSetOperProject(STranslateContext* pCxt, SSetOperator* pSetOperator) {
   SNodeList* pLeftProjections = getProjectList(pSetOperator->pLeft);
   SNodeList* pRightProjections = getProjectList(pSetOperator->pRight);
@@ -3440,7 +3456,8 @@ static int32_t translateSetOperProject(STranslateContext* pCxt, SSetOperator* pS
   FORBOTH(pLeft, pLeftProjections, pRight, pRightProjections) {
     SExprNode* pLeftExpr = (SExprNode*)pLeft;
     SExprNode* pRightExpr = (SExprNode*)pRight;
-    if (!dataTypeEqual(&pLeftExpr->resType, &pRightExpr->resType)) {
+    int32_t    comp = dataTypeComp(&pLeftExpr->resType, &pRightExpr->resType);
+    if (comp > 0) {
       SNode*  pRightFunc = NULL;
       int32_t code = createCastFunc(pCxt, pRight, pLeftExpr->resType, &pRightFunc);
       if (TSDB_CODE_SUCCESS != code) {
@@ -3448,9 +3465,20 @@ static int32_t translateSetOperProject(STranslateContext* pCxt, SSetOperator* pS
       }
       REPLACE_LIST2_NODE(pRightFunc);
       pRightExpr = (SExprNode*)pRightFunc;
-    }
-    strcpy(pRightExpr->aliasName, pLeftExpr->aliasName);
-    pRightExpr->aliasName[strlen(pLeftExpr->aliasName)] = '\0';
+    } else if (comp < 0) {
+      SNode*  pLeftFunc = NULL;
+      int32_t code = createCastFunc(pCxt, pLeft, pRightExpr->resType, &pLeftFunc);
+      if (TSDB_CODE_SUCCESS != code) {
+        return code;
+      }
+      REPLACE_LIST1_NODE(pLeftFunc);
+      SExprNode* pLeftFuncExpr = (SExprNode*)pLeftFunc;
+      snprintf(pLeftFuncExpr->aliasName, sizeof(pLeftFuncExpr->aliasName), "%s", pLeftExpr->aliasName);
+      snprintf(pLeftFuncExpr->userAlias, sizeof(pLeftFuncExpr->userAlias), "%s", pLeftExpr->userAlias);
+      pLeft = pLeftFunc;
+      pLeftExpr = pLeftFuncExpr;
+    }
+    snprintf(pRightExpr->aliasName, sizeof(pRightExpr->aliasName), "%s", pLeftExpr->aliasName);
     if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pSetOperator->pProjectionList,
                                                        createSetOperProject(pSetOperator->stmtName, pLeft))) {
       return TSDB_CODE_OUT_OF_MEMORY;

source/libs/parser/test/parSelectTest.cpp

@@ -425,6 +425,8 @@ TEST_F(ParserSelectTest, informationSchema) {
   run("SELECT * FROM ins_databases WHERE name = 'information_schema'");
 
   run("SELECT * FROM ins_tags WHERE db_name = 'test' and table_name = 'st1'");
+
+  run("SELECT * FROM (SELECT table_name FROM ins_tables) t WHERE table_name = 'a'");
 }
 
 TEST_F(ParserSelectTest, withoutFrom) {

source/libs/scalar/src/sclfunc.c

@@ -1028,11 +1028,11 @@ int32_t toISO8601Function(SScalarParam *pInput, int32_t inputNum, SScalarParam *
   int32_t type = GET_PARAM_TYPE(pInput);
 
   bool    tzPresent = (inputNum == 2) ? true : false;
-  char   *tz;
-  int32_t tzLen;
+  char    tz[20] = {0};
+  int32_t tzLen = 0;
   if (tzPresent) {
-    tz = varDataVal(pInput[1].columnData->pData);
     tzLen = varDataLen(pInput[1].columnData->pData);
+    memcpy(tz, varDataVal(pInput[1].columnData->pData), tzLen);
   }
 
   for (int32_t i = 0; i < pInput[0].numOfRows; ++i) {
@@ -1071,8 +1071,10 @@ int32_t toISO8601Function(SScalarParam *pInput, int32_t inputNum, SScalarParam *
     int32_t len = (int32_t)strlen(buf);
 
     // add timezone string
-    snprintf(buf + len, tzLen + 1, "%s", tz);
-    len += tzLen;
+    if (tzLen > 0) {
+      snprintf(buf + len, tzLen + 1, "%s", tz);
+      len += tzLen;
+    }
 
     if (hasFraction) {
       int32_t fracLen = (int32_t)strlen(fraction) + 1;

source/libs/stream/src/streamState.c

@@ -29,7 +29,7 @@ typedef struct SStateSessionKey {
   int64_t     opNum;
 } SStateSessionKey;
 
-static inline int sessionKeyCmpr(const SSessionKey* pWin1, const SSessionKey* pWin2) {
+static inline int sessionRangeKeyCmpr(const SSessionKey* pWin1, const SSessionKey* pWin2) {
   if (pWin1->groupId > pWin2->groupId) {
     return 1;
   } else if (pWin1->groupId < pWin2->groupId) {
@@ -45,6 +45,28 @@ static inline int sessionKeyCmpr(const SSessionKey* pWin1, const SSessionKey* pW
   return 0;
 }
 
+static inline int sessionWinKeyCmpr(const SSessionKey* pWin1, const SSessionKey* pWin2) {
+  if (pWin1->groupId > pWin2->groupId) {
+    return 1;
+  } else if (pWin1->groupId < pWin2->groupId) {
+    return -1;
+  }
+
+  if (pWin1->win.skey > pWin2->win.skey) {
+    return 1;
+  } else if (pWin1->win.skey < pWin2->win.skey) {
+    return -1;
+  }
+
+  if (pWin1->win.ekey > pWin2->win.ekey) {
+    return 1;
+  } else if (pWin1->win.ekey < pWin2->win.ekey) {
+    return -1;
+  }
+
+  return 0;
+}
+
 static inline int stateSessionKeyCmpr(const void* pKey1, int kLen1, const void* pKey2, int kLen2) {
   SStateSessionKey* pWin1 = (SStateSessionKey*)pKey1;
   SStateSessionKey* pWin2 = (SStateSessionKey*)pKey2;
@@ -55,7 +77,7 @@ static inline int stateSessionKeyCmpr(const void* pKey1, int kLen1, const void*
     return -1;
   }
 
-  return sessionKeyCmpr(&pWin1->key, &pWin2->key);
+  return sessionWinKeyCmpr(&pWin1->key, &pWin2->key);
 }
 
 static inline int stateKeyCmpr(const void* pKey1, int kLen1, const void* pKey2, int kLen2) {
@@ -400,7 +422,6 @@ SStreamStateCur* streamStateSeekKeyNext(SStreamState* pState, const SWinKey* key
   SStateKey sKey = {.key = *key, .opNum = pState->number};
   int32_t   c = 0;
   if (tdbTbcMoveTo(pCur->pCur, &sKey, sizeof(SStateKey), &c) < 0) {
-    tdbTbcClose(pCur->pCur);
     streamStateFreeCur(pCur);
     return NULL;
   }
@@ -426,7 +447,6 @@ SStreamStateCur* streamStateFillSeekKeyNext(SStreamState* pState, const SWinKey*
 
   int32_t c = 0;
   if (tdbTbcMoveTo(pCur->pCur, key, sizeof(SWinKey), &c) < 0) {
-    tdbTbcClose(pCur->pCur);
     streamStateFreeCur(pCur);
     return NULL;
   }
@@ -452,7 +472,6 @@ SStreamStateCur* streamStateFillSeekKeyPrev(SStreamState* pState, const SWinKey*
 
   int32_t c = 0;
   if (tdbTbcMoveTo(pCur->pCur, key, sizeof(SWinKey), &c) < 0) {
-    tdbTbcClose(pCur->pCur);
     streamStateFreeCur(pCur);
     return NULL;
   }
@@ -496,33 +515,18 @@ int32_t streamStateSessionPut(SStreamState* pState, const SSessionKey* key, cons
   return tdbTbUpsert(pState->pSessionStateDb, &sKey, sizeof(SStateSessionKey), value, vLen, &pState->txn);
 }
 
-SStreamStateCur* streamStateSessionGetRanomCur(SStreamState* pState, const SSessionKey* key) {
-  SStreamStateCur* pCur = taosMemoryCalloc(1, sizeof(SStreamStateCur));
-  if (pCur == NULL) return NULL;
-  tdbTbcOpen(pState->pSessionStateDb, &pCur->pCur, NULL);
-
-  int32_t          c = -2;
-  SStateSessionKey sKey = {.key = *key, .opNum = pState->number};
-  tdbTbcMoveTo(pCur->pCur, &sKey, sizeof(SStateSessionKey), &c);
-  if (c != 0) {
-    streamStateFreeCur(pCur);
-    return NULL;
-  }
-  pCur->number = pState->number;
-  return pCur;
-}
-
 int32_t streamStateSessionGet(SStreamState* pState, SSessionKey* key, void** pVal, int32_t* pVLen) {
-  SStreamStateCur* pCur = streamStateSessionGetRanomCur(pState, key);
+  SStreamStateCur* pCur = streamStateSessionSeekKeyCurrentNext(pState, key);
+  SSessionKey      resKey = *key;
   void*            tmp = NULL;
-  if (streamStateSessionGetKVByCur(pCur, key, (const void**)&tmp, pVLen) == 0) {
+  int32_t          code = streamStateSessionGetKVByCur(pCur, &resKey, &tmp, pVLen);
+  if (code == 0) {
+    *key = resKey;
     *pVal = tdbRealloc(NULL, *pVLen);
     memcpy(*pVal, tmp, *pVLen);
-    streamStateFreeCur(pCur);
-    return 0;
   }
   streamStateFreeCur(pCur);
-  return -1;
+  return code;
 }
 
 int32_t streamStateSessionDel(SStreamState* pState, const SSessionKey* key) {
@@ -544,7 +548,6 @@ SStreamStateCur* streamStateSessionSeekKeyCurrentPrev(SStreamState* pState, cons
   SStateSessionKey sKey = {.key = *key, .opNum = pState->number};
   int32_t          c = 0;
   if (tdbTbcMoveTo(pCur->pCur, &sKey, sizeof(SStateSessionKey), &c) < 0) {
-    tdbTbcClose(pCur->pCur);
     streamStateFreeCur(pCur);
     return NULL;
   }
@@ -558,6 +561,34 @@ SStreamStateCur* streamStateSessionSeekKeyCurrentPrev(SStreamState* pState, cons
   return pCur;
 }
 
+SStreamStateCur* streamStateSessionSeekKeyCurrentNext(SStreamState* pState, const SSessionKey* key) {
+  SStreamStateCur* pCur = taosMemoryCalloc(1, sizeof(SStreamStateCur));
+  if (pCur == NULL) {
+    return NULL;
+  }
+  pCur->number = pState->number;
+  if (tdbTbcOpen(pState->pSessionStateDb, &pCur->pCur, NULL) < 0) {
+    streamStateFreeCur(pCur);
+    return NULL;
+  }
+
+  SStateSessionKey sKey = {.key = *key, .opNum = pState->number};
+  int32_t          c = 0;
+  if (tdbTbcMoveTo(pCur->pCur, &sKey, sizeof(SStateSessionKey), &c) < 0) {
+    streamStateFreeCur(pCur);
+    return NULL;
+  }
+
+  if (c <= 0) return pCur;
+
+  if (tdbTbcMoveToNext(pCur->pCur) < 0) {
+    streamStateFreeCur(pCur);
+    return NULL;
+  }
+
+  return pCur;
+}
+
 SStreamStateCur* streamStateSessionSeekKeyNext(SStreamState* pState, const SSessionKey* key) {
   SStreamStateCur* pCur = taosMemoryCalloc(1, sizeof(SStreamStateCur));
   if (pCur == NULL) {
@@ -572,7 +603,6 @@ SStreamStateCur* streamStateSessionSeekKeyNext(SStreamState* pState, const SSess
   SStateSessionKey sKey = {.key = *key, .opNum = pState->number};
   int32_t          c = 0;
   if (tdbTbcMoveTo(pCur->pCur, &sKey, sizeof(SStateSessionKey), &c) < 0) {
-    tdbTbcClose(pCur->pCur);
     streamStateFreeCur(pCur);
     return NULL;
   }
@@ -586,13 +616,13 @@ SStreamStateCur* streamStateSessionSeekKeyNext(SStreamState* pState, const SSess
   return pCur;
 }
 
-int32_t streamStateSessionGetKVByCur(SStreamStateCur* pCur, SSessionKey* pKey, const void** pVal, int32_t* pVLen) {
+int32_t streamStateSessionGetKVByCur(SStreamStateCur* pCur, SSessionKey* pKey, void** pVal, int32_t* pVLen) {
   if (!pCur) {
     return -1;
   }
-  const SStateSessionKey* pKTmp = NULL;
-  int32_t                 kLen;
-  if (tdbTbcGet(pCur->pCur, (const void**)&pKTmp, &kLen, pVal, pVLen) < 0) {
+  SStateSessionKey* pKTmp = NULL;
+  int32_t           kLen;
+  if (tdbTbcGet(pCur->pCur, (const void**)&pKTmp, &kLen, (const void**)pVal, pVLen) < 0) {
     return -1;
   }
   if (pKTmp->opNum != pCur->number) {
@@ -606,15 +636,15 @@ int32_t streamStateSessionGetKVByCur(SStreamStateCur* pCur, SSessionKey* pKey, c
 }
 
 int32_t streamStateSessionClear(SStreamState* pState) {
-  SSessionKey key = {.win.skey = 0, .win.ekey = 0, .groupId = 0};
-  streamStateSessionPut(pState, &key, NULL, 0);
-  SStreamStateCur* pCur = streamStateSessionSeekKeyNext(pState, &key);
+  SSessionKey      key = {.win.skey = 0, .win.ekey = 0, .groupId = 0};
+  SStreamStateCur* pCur = streamStateSessionSeekKeyCurrentNext(pState, &key);
   while (1) {
     SSessionKey delKey = {0};
     void*       buf = NULL;
     int32_t     size = 0;
-    int32_t     code = streamStateSessionGetKVByCur(pCur, &delKey, buf, &size);
+    int32_t     code = streamStateSessionGetKVByCur(pCur, &delKey, &buf, &size);
     if (code == 0) {
+      ASSERT(size > 0);
       memset(buf, 0, size);
       streamStateSessionPut(pState, &delKey, buf, size);
     } else {
@@ -623,61 +653,104 @@ int32_t streamStateSessionClear(SStreamState* pState) {
     streamStateCurNext(pState, pCur);
   }
   streamStateFreeCur(pCur);
-  streamStateSessionDel(pState, &key);
   return 0;
 }
 
-SStreamStateCur* streamStateSessionGetCur(SStreamState* pState, const SSessionKey* key) {
-  SStreamStateCur* pCur = streamStateSessionGetRanomCur(pState, key);
-  SSessionKey      resKey = *key;
-  while (1) {
-    streamStateCurPrev(pState, pCur);
-    SSessionKey tmpKey = *key;
-    int32_t     code = streamStateSessionGetKVByCur(pCur, &tmpKey, NULL, 0);
-    if (code == 0 && sessionKeyCmpr(key, &tmpKey) == 0) {
-      resKey = tmpKey;
-    } else {
-      break;
-    }
+int32_t streamStateSessionGetKeyByRange(SStreamState* pState, const SSessionKey* key, SSessionKey* curKey) {
+  SStreamStateCur* pCur = taosMemoryCalloc(1, sizeof(SStreamStateCur));
+  if (pCur == NULL) {
+    return -1;
+  }
+  pCur->number = pState->number;
+  if (tdbTbcOpen(pState->pSessionStateDb, &pCur->pCur, NULL) < 0) {
+    streamStateFreeCur(pCur);
+    return -1;
   }
-  streamStateFreeCur(pCur);
-  return streamStateSessionGetRanomCur(pState, &resKey);
-}
 
-int32_t streamStateSessionGetKey(SStreamState* pState, const SSessionKey* key, SSessionKey* curKey) {
-  SStreamStateCur* pCur = streamStateSessionGetRanomCur(pState, key);
-  SSessionKey      resKey = *key;
-  int32_t          res = -1;
-  while (1) {
-    SSessionKey tmpKey = *key;
-    int32_t     code = streamStateSessionGetKVByCur(pCur, &tmpKey, NULL, 0);
-    if (code == 0 && sessionKeyCmpr(key, &tmpKey) == 0) {
-      res = 0;
-      resKey = tmpKey;
-      streamStateCurPrev(pState, pCur);
-    } else {
-      break;
+  SStateSessionKey sKey = {.key = *key, .opNum = pState->number};
+  int32_t          c = 0;
+  if (tdbTbcMoveTo(pCur->pCur, &sKey, sizeof(SStateSessionKey), &c) < 0) {
+    streamStateFreeCur(pCur);
+    return -1;
+  }
+
+  SSessionKey resKey = *key;
+  int32_t     code = streamStateSessionGetKVByCur(pCur, &resKey, NULL, 0);
+  if (code == 0 && sessionRangeKeyCmpr(key, &resKey) == 0) {
+    *curKey = resKey;
+    streamStateFreeCur(pCur);
+    return code;
+  }
+
+  if (c > 0) {
+    streamStateCurNext(pState, pCur);
+    code = streamStateSessionGetKVByCur(pCur, &resKey, NULL, 0);
+    if (code == 0 && sessionRangeKeyCmpr(key, &resKey) == 0) {
+      *curKey = resKey;
+      streamStateFreeCur(pCur);
+      return code;
+    }
+  } else if (c < 0) {
+    streamStateCurPrev(pState, pCur);
+    code = streamStateSessionGetKVByCur(pCur, &resKey, NULL, 0);
+    if (code == 0 && sessionRangeKeyCmpr(key, &resKey) == 0) {
+      *curKey = resKey;
+      streamStateFreeCur(pCur);
+      return code;
     }
   }
-  *curKey = resKey;
+
   streamStateFreeCur(pCur);
-  return res;
+  return -1;
 }
 
-int32_t streamStateSessionAddIfNotExist(SStreamState* pState, SSessionKey* key, void** pVal, int32_t* pVLen) {
+int32_t streamStateSessionAddIfNotExist(SStreamState* pState, SSessionKey* key, TSKEY gap, void** pVal,
+                                        int32_t* pVLen) {
   // todo refactor
-  SStreamStateCur* pCur = streamStateSessionGetRanomCur(pState, key);
-  int32_t          size = *pVLen;
-  void*            tmp = NULL;
-  *pVal = tdbRealloc(NULL, size);
-  memset(*pVal, 0, size);
-  if (streamStateSessionGetKVByCur(pCur, key, (const void**)&tmp, pVLen) == 0) {
-    memcpy(*pVal, tmp, *pVLen);
+  int32_t     res = 0;
+  SSessionKey originKey = *key;
+  SSessionKey searchKey = *key;
+  searchKey.win.skey = key->win.skey - gap;
+  searchKey.win.ekey = key->win.ekey + gap;
+  int32_t valSize = *pVLen;
+  void*   tmp = tdbRealloc(NULL, valSize);
+  if (!tmp) {
+    return -1;
+  }
+
+  SStreamStateCur* pCur = streamStateSessionSeekKeyCurrentPrev(pState, key);
+  int32_t          code = streamStateSessionGetKVByCur(pCur, key, pVal, pVLen);
+  if (code == 0) {
+    if (sessionRangeKeyCmpr(&searchKey, key) == 0) {
+      memcpy(tmp, *pVal, valSize);
+      streamStateSessionDel(pState, key);
+      goto _end;
+    }
+    streamStateCurNext(pState, pCur);
+  } else {
+    *key = originKey;
     streamStateFreeCur(pCur);
-    return 0;
+    pCur = streamStateSessionSeekKeyNext(pState, key);
   }
+
+  code = streamStateSessionGetKVByCur(pCur, key, pVal, pVLen);
+  if (code == 0) {
+    if (sessionRangeKeyCmpr(&searchKey, key) == 0) {
+      memcpy(tmp, *pVal, valSize);
+      streamStateSessionDel(pState, key);
+      goto _end;
+    }
+  }
+
+  *key = originKey;
+  res = 1;
+  memset(tmp, 0, valSize);
+
+_end:
+
+  *pVal = tmp;
   streamStateFreeCur(pCur);
-  return 1;
+  return res;
 }
 
 int32_t streamStateStateAddIfNotExist(SStreamState* pState, SSessionKey* key, char* pKeyData, int32_t keyDataLen,
@@ -692,16 +765,18 @@ int32_t streamStateStateAddIfNotExist(SStreamState* pState, SSessionKey* key, ch
   }
 
   SStreamStateCur* pCur = streamStateSessionSeekKeyCurrentPrev(pState, key);
-  int32_t          code = streamStateSessionGetKVByCur(pCur, key, (const void**)pVal, pVLen);
+  int32_t          code = streamStateSessionGetKVByCur(pCur, key, pVal, pVLen);
   if (code == 0) {
     if (key->win.skey <= tmpKey.win.skey && tmpKey.win.ekey <= key->win.ekey) {
       memcpy(tmp, *pVal, valSize);
+      streamStateSessionDel(pState, key);
       goto _end;
     }
 
     void* stateKey = (char*)(*pVal) + (valSize - keyDataLen);
     if (fn(pKeyData, stateKey) == true) {
       memcpy(tmp, *pVal, valSize);
+      streamStateSessionDel(pState, key);
       goto _end;
     }
 
@@ -712,11 +787,12 @@ int32_t streamStateStateAddIfNotExist(SStreamState* pState, SSessionKey* key, ch
     pCur = streamStateSessionSeekKeyNext(pState, key);
   }
 
-  code = streamStateSessionGetKVByCur(pCur, key, (const void**)pVal, pVLen);
+  code = streamStateSessionGetKVByCur(pCur, key, pVal, pVLen);
   if (code == 0) {
     void* stateKey = (char*)(*pVal) + (valSize - keyDataLen);
     if (fn(pKeyData, stateKey) == true) {
       memcpy(tmp, *pVal, valSize);
+      streamStateSessionDel(pState, key);
       goto _end;
     }
   }
@@ -746,8 +822,11 @@ char* streamStateSessionDump(SStreamState* pState) {
   tdbTbcMoveToFirst(pCur->pCur);
 
   SSessionKey key = {0};
-  int32_t     code = streamStateSessionGetKVByCur(pCur, &key, NULL, 0);
+  void*       buf = NULL;
+  int32_t     bufSize = 0;
+  int32_t     code = streamStateSessionGetKVByCur(pCur, &key, &buf, &bufSize);
   if (code != 0) {
+    streamStateFreeCur(pCur);
     return NULL;
   }
 
@@ -762,12 +841,14 @@ char* streamStateSessionDump(SStreamState* pState) {
     key = (SSessionKey){0};
     code = streamStateSessionGetKVByCur(pCur, &key, NULL, 0);
     if (code != 0) {
+      streamStateFreeCur(pCur);
       return dumpBuf;
     }
     len += snprintf(dumpBuf + len, size - len, "||s:%15" PRId64 ",", key.win.skey);
     len += snprintf(dumpBuf + len, size - len, "e:%15" PRId64 ",", key.win.ekey);
     len += snprintf(dumpBuf + len, size - len, "g:%15" PRId64 "||", key.groupId);
   }
+  streamStateFreeCur(pCur);
   return dumpBuf;
 }
 #endif

source/libs/sync/inc/syncInt.h

@@ -268,8 +268,6 @@ int32_t syncNodeRestartHeartbeatTimer(SSyncNode* pSyncNode);
 // utils --------------
 int32_t   syncNodeSendMsgById(const SRaftId* destRaftId, SSyncNode* pSyncNode, SRpcMsg* pMsg);
 int32_t   syncNodeSendMsgByInfo(const SNodeInfo* nodeInfo, SSyncNode* pSyncNode, SRpcMsg* pMsg);
-cJSON*    syncNode2Json(const SSyncNode* pSyncNode);
-char*     syncNode2Str(const SSyncNode* pSyncNode);
 char*     syncNode2SimpleStr(const SSyncNode* pSyncNode);
 bool      syncNodeInConfig(SSyncNode* pSyncNode, const SSyncCfg* config);
 void      syncNodeDoConfigChange(SSyncNode* pSyncNode, SSyncCfg* newConfig, SyncIndex lastConfigChangeIndex);

source/libs/sync/inc/syncRaftEntry.h

@@ -42,25 +42,14 @@ typedef struct SSyncRaftEntry {
   char      data[];   // origin RpcMsg.pCont
 } SSyncRaftEntry;
 
-SSyncRaftEntry* syncEntryBuild(uint32_t dataLen);
-SSyncRaftEntry* syncEntryBuild2(SyncClientRequest* pMsg, SyncTerm term, SyncIndex index);  // step 4
-SSyncRaftEntry* syncEntryBuild3(SyncClientRequest* pMsg, SyncTerm term, SyncIndex index);
-SSyncRaftEntry* syncEntryBuild4(SRpcMsg* pOriginalMsg, SyncTerm term, SyncIndex index);
+SSyncRaftEntry* syncEntryBuild(int32_t dataLen);
+SSyncRaftEntry* syncEntryBuildFromClientRequest(const SyncClientRequest* pMsg, SyncTerm term, SyncIndex index);
+SSyncRaftEntry* syncEntryBuildFromRpcMsg(const SRpcMsg* pMsg, SyncTerm term, SyncIndex index);
+SSyncRaftEntry* syncEntryBuildFromAppendEntries(const SyncAppendEntries* pMsg);
 SSyncRaftEntry* syncEntryBuildNoop(SyncTerm term, SyncIndex index, int32_t vgId);
 void            syncEntryDestory(SSyncRaftEntry* pEntry);
-char*           syncEntrySerialize(const SSyncRaftEntry* pEntry, uint32_t* len);  // step 5
-SSyncRaftEntry* syncEntryDeserialize(const char* buf, uint32_t len);              // step 6
-cJSON*          syncEntry2Json(const SSyncRaftEntry* pEntry);
-char*           syncEntry2Str(const SSyncRaftEntry* pEntry);
 void            syncEntry2OriginalRpc(const SSyncRaftEntry* pEntry, SRpcMsg* pRpcMsg);  // step 7
 
-// for debug ----------------------
-void syncEntryPrint(const SSyncRaftEntry* pObj);
-void syncEntryPrint2(char* s, const SSyncRaftEntry* pObj);
-void syncEntryLog(const SSyncRaftEntry* pObj);
-void syncEntryLog2(char* s, const SSyncRaftEntry* pObj);
-
-//-----------------------------------
 typedef struct SRaftEntryHashCache {
   SHashObj*     pEntryHash;
   int32_t       maxCount;
@@ -78,14 +67,6 @@ int32_t              raftCacheDelEntry(struct SRaftEntryHashCache* pCache, SyncI
 int32_t              raftCacheGetAndDel(struct SRaftEntryHashCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry);
 int32_t              raftCacheClear(struct SRaftEntryHashCache* pCache);
 
-cJSON* raftCache2Json(SRaftEntryHashCache* pObj);
-char*  raftCache2Str(SRaftEntryHashCache* pObj);
-void   raftCachePrint(SRaftEntryHashCache* pObj);
-void   raftCachePrint2(char* s, SRaftEntryHashCache* pObj);
-void   raftCacheLog(SRaftEntryHashCache* pObj);
-void   raftCacheLog2(char* s, SRaftEntryHashCache* pObj);
-
-//-----------------------------------
 typedef struct SRaftEntryCache {
   SSkipList*    pSkipList;
   int32_t       maxCount;
@@ -102,13 +83,6 @@ int32_t          raftEntryCacheGetEntry(struct SRaftEntryCache* pCache, SyncInde
 int32_t          raftEntryCacheGetEntryP(struct SRaftEntryCache* pCache, SyncIndex index, SSyncRaftEntry** ppEntry);
 int32_t          raftEntryCacheClear(struct SRaftEntryCache* pCache, int32_t count);
 
-cJSON* raftEntryCache2Json(SRaftEntryCache* pObj);
-char*  raftEntryCache2Str(SRaftEntryCache* pObj);
-void   raftEntryCachePrint(SRaftEntryCache* pObj);
-void   raftEntryCachePrint2(char* s, SRaftEntryCache* pObj);
-void   raftEntryCacheLog(SRaftEntryCache* pObj);
-void   raftEntryCacheLog2(char* s, SRaftEntryCache* pObj);
-
 #ifdef __cplusplus
 }
 #endif

source/libs/sync/inc/syncRaftLog.h

@@ -40,25 +40,19 @@ typedef struct SSyncLogStoreData {
 
 SSyncLogStore* logStoreCreate(SSyncNode* pSyncNode);
 void           logStoreDestory(SSyncLogStore* pLogStore);
-cJSON*         logStore2Json(SSyncLogStore* pLogStore);
-char*          logStore2Str(SSyncLogStore* pLogStore);
-cJSON*         logStoreSimple2Json(SSyncLogStore* pLogStore);
-char*          logStoreSimple2Str(SSyncLogStore* pLogStore);
 
 SyncIndex logStoreFirstIndex(SSyncLogStore* pLogStore);
 
 SyncIndex logStoreWalCommitVer(SSyncLogStore* pLogStore);
 
-// for debug
-void logStorePrint(SSyncLogStore* pLogStore);
-void logStorePrint2(char* s, SSyncLogStore* pLogStore);
-void logStoreLog(SSyncLogStore* pLogStore);
-void logStoreLog2(char* s, SSyncLogStore* pLogStore);
-
-void logStoreSimplePrint(SSyncLogStore* pLogStore);
-void logStoreSimplePrint2(char* s, SSyncLogStore* pLogStore);
-void logStoreSimpleLog(SSyncLogStore* pLogStore);
-void logStoreSimpleLog2(char* s, SSyncLogStore* pLogStore);
+SyncIndex raftLogWriteIndex(struct SSyncLogStore* pLogStore);
+bool      raftLogIsEmpty(struct SSyncLogStore* pLogStore);
+SyncIndex raftLogBeginIndex(struct SSyncLogStore* pLogStore);
+SyncIndex raftLogEndIndex(struct SSyncLogStore* pLogStore);
+int32_t   raftLogEntryCount(struct SSyncLogStore* pLogStore);
+SyncIndex raftLogLastIndex(struct SSyncLogStore* pLogStore);
+SyncTerm  raftLogLastTerm(struct SSyncLogStore* pLogStore);
+int32_t   raftLogGetEntry(struct SSyncLogStore* pLogStore, SyncIndex index, SSyncRaftEntry** ppEntry);
 
 #ifdef __cplusplus
 }

source/libs/sync/inc/syncRespMgr.h

@@ -41,13 +41,12 @@ typedef struct SSyncRespMgr {
 
 SSyncRespMgr *syncRespMgrCreate(void *data, int64_t ttl);
 void          syncRespMgrDestroy(SSyncRespMgr *pObj);
-int64_t       syncRespMgrAdd(SSyncRespMgr *pObj, SRespStub *pStub);
-int32_t       syncRespMgrDel(SSyncRespMgr *pObj, uint64_t index);
-int32_t       syncRespMgrGet(SSyncRespMgr *pObj, uint64_t index, SRespStub *pStub);
-int32_t       syncRespMgrGetAndDel(SSyncRespMgr *pObj, uint64_t index, SRespStub *pStub);
+uint64_t      syncRespMgrAdd(SSyncRespMgr *pObj, const SRespStub *pStub);
+int32_t       syncRespMgrDel(SSyncRespMgr *pObj, uint64_t seq);
+int32_t       syncRespMgrGet(SSyncRespMgr *pObj, uint64_t seq, SRespStub *pStub);
+int32_t       syncRespMgrGetAndDel(SSyncRespMgr *pObj, uint64_t seq, SRpcHandleInfo *pInfo);
 void          syncRespClean(SSyncRespMgr *pObj);
 void          syncRespCleanRsp(SSyncRespMgr *pObj);
-void          syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl, bool rsp);
 
 #ifdef __cplusplus
 }

source/libs/sync/inc/syncTools.h

@@ -26,9 +26,6 @@ typedef struct SRaftId {
   SyncGroupId vgId;
 } SRaftId;
 
-// for compatibility, the same as syncPropose
-int32_t syncForwardToPeer(int64_t rid, SRpcMsg* pMsg, bool isWeak);
-
 // ------------------ for debug -------------------
 void syncRpcMsgPrint(SRpcMsg* pMsg);
 void syncRpcMsgPrint2(char* s, SRpcMsg* pMsg);
@@ -183,17 +180,13 @@ typedef struct SyncClientRequest {
 } SyncClientRequest;
 
 SyncClientRequest* syncClientRequestAlloc(uint32_t dataLen);
-SyncClientRequest* syncClientRequestBuild(const SRpcMsg* pMsg, uint64_t seqNum, bool isWeak, int32_t vgId);  // step 1
-void               syncClientRequestDestroy(SyncClientRequest* pMsg);
-void               syncClientRequestSerialize(const SyncClientRequest* pMsg, char* buf, uint32_t bufLen);
-void               syncClientRequestDeserialize(const char* buf, uint32_t len, SyncClientRequest* pMsg);
-char*              syncClientRequestSerialize2(const SyncClientRequest* pMsg, uint32_t* len);
-SyncClientRequest* syncClientRequestDeserialize2(const char* buf, uint32_t len);
-void               syncClientRequest2RpcMsg(const SyncClientRequest* pMsg, SRpcMsg* pRpcMsg);  // step 2
-void               syncClientRequestFromRpcMsg(const SRpcMsg* pRpcMsg, SyncClientRequest* pMsg);
-SyncClientRequest* syncClientRequestFromRpcMsg2(const SRpcMsg* pRpcMsg);  // step 3
-cJSON*             syncClientRequest2Json(const SyncClientRequest* pMsg);
-char*              syncClientRequest2Str(const SyncClientRequest* pMsg);
+int32_t syncClientRequestBuildFromRpcMsg(SRpcMsg* pClientRequestRpcMsg, const SRpcMsg* pOriginalRpcMsg, uint64_t seqNum,
+                                         bool isWeak, int32_t vgId);
+int32_t syncClientRequestBuildFromNoopEntry(SRpcMsg* pClientRequestRpcMsg, const SSyncRaftEntry* pEntry, int32_t vgId);
+void    syncClientRequest2RpcMsg(const SyncClientRequest* pMsg, SRpcMsg* pRpcMsg);  // step 2
+void    syncClientRequestFromRpcMsg(const SRpcMsg* pRpcMsg, SyncClientRequest* pMsg);
+cJSON*  syncClientRequest2Json(const SyncClientRequest* pMsg);
+char*   syncClientRequest2Str(const SyncClientRequest* pMsg);
 
 // for debug ----------------------
 void syncClientRequestPrint(const SyncClientRequest* pMsg);
@@ -384,14 +377,6 @@ SyncAppendEntriesBatch* syncAppendEntriesBatchDeserialize2(const char* buf, uint
 void                    syncAppendEntriesBatch2RpcMsg(const SyncAppendEntriesBatch* pMsg, SRpcMsg* pRpcMsg);
 void                    syncAppendEntriesBatchFromRpcMsg(const SRpcMsg* pRpcMsg, SyncAppendEntriesBatch* pMsg);
 SyncAppendEntriesBatch* syncAppendEntriesBatchFromRpcMsg2(const SRpcMsg* pRpcMsg);
-cJSON*                  syncAppendEntriesBatch2Json(const SyncAppendEntriesBatch* pMsg);
-char*                   syncAppendEntriesBatch2Str(const SyncAppendEntriesBatch* pMsg);
-
-// for debug ----------------------
-void syncAppendEntriesBatchPrint(const SyncAppendEntriesBatch* pMsg);
-void syncAppendEntriesBatchPrint2(char* s, const SyncAppendEntriesBatch* pMsg);
-void syncAppendEntriesBatchLog(const SyncAppendEntriesBatch* pMsg);
-void syncAppendEntriesBatchLog2(char* s, const SyncAppendEntriesBatch* pMsg);
 
 // ---------------------------------------------
 typedef struct SyncAppendEntriesReply {
@@ -742,14 +727,14 @@ int32_t syncNodeOnSnapshotReply(SSyncNode* ths, SyncSnapshotRsp* pMsg);
 int32_t syncNodeOnHeartbeat(SSyncNode* ths, SyncHeartbeat* pMsg);
 int32_t syncNodeOnHeartbeatReply(SSyncNode* ths, SyncHeartbeatReply* pMsg);
 
-int32_t syncNodeOnClientRequest(SSyncNode* ths, SyncClientRequest* pMsg, SyncIndex* pRetIndex);
+int32_t syncNodeOnClientRequest(SSyncNode* ths, SRpcMsg* pMsg, SyncIndex* pRetIndex);
 int32_t syncNodeOnTimer(SSyncNode* ths, SyncTimeout* pMsg);
 int32_t syncNodeOnLocalCmd(SSyncNode* ths, SyncLocalCmd* pMsg);
 
 // -----------------------------------------
 typedef int32_t (*FpOnPingCb)(SSyncNode* ths, SyncPing* pMsg);
 typedef int32_t (*FpOnPingReplyCb)(SSyncNode* ths, SyncPingReply* pMsg);
-typedef int32_t (*FpOnClientRequestCb)(SSyncNode* ths, SyncClientRequest* pMsg, SyncIndex* pRetIndex);
+typedef int32_t (*FpOnClientRequestCb)(SSyncNode* ths, SRpcMsg* pMsg, SyncIndex* pRetIndex);
 typedef int32_t (*FpOnRequestVoteCb)(SSyncNode* ths, SyncRequestVote* pMsg);
 typedef int32_t (*FpOnRequestVoteReplyCb)(SSyncNode* ths, SyncRequestVoteReply* pMsg);
 typedef int32_t (*FpOnAppendEntriesCb)(SSyncNode* ths, SyncAppendEntries* pMsg);

source/libs/sync/src/syncAppendEntries.c

@@ -179,7 +179,7 @@ int32_t syncNodeOnAppendEntries(SSyncNode* ths, SyncAppendEntries* pMsg) {
   pReply->success = true;
   bool hasAppendEntries = pMsg->dataLen > 0;
   if (hasAppendEntries) {
-    SSyncRaftEntry* pAppendEntry = syncEntryDeserialize(pMsg->data, pMsg->dataLen);
+    SSyncRaftEntry* pAppendEntry = syncEntryBuildFromAppendEntries(pMsg);
     ASSERT(pAppendEntry != NULL);
 
     SyncIndex       appendIndex = pMsg->prevLogIndex + 1;
@@ -246,7 +246,8 @@ int32_t syncNodeOnAppendEntries(SSyncNode* ths, SyncAppendEntries* pMsg) {
       } else {
         // error
         char logBuf[128];
-        snprintf(logBuf, sizeof(logBuf), "ignore, get local entry error, append-index:%" PRId64, appendIndex);
+        snprintf(logBuf, sizeof(logBuf), "ignore, get local entry error, append-index:%" PRId64 " err:%d", appendIndex,
+                 terrno);
         syncLogRecvAppendEntries(ths, pMsg, logBuf);
 
         syncEntryDestory(pLocalEntry);

source/libs/sync/src/syncRaftEntry.c

@@ -13,31 +13,28 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#define _DEFAULT_SOURCE
 #include "syncRaftEntry.h"
 #include "syncUtil.h"
 
-SSyncRaftEntry* syncEntryBuild(uint32_t dataLen) {
-  uint32_t        bytes = sizeof(SSyncRaftEntry) + dataLen;
+SSyncRaftEntry* syncEntryBuild(int32_t dataLen) {
+  int32_t         bytes = sizeof(SSyncRaftEntry) + dataLen;
   SSyncRaftEntry* pEntry = taosMemoryMalloc(bytes);
-  ASSERT(pEntry != NULL);
-  memset(pEntry, 0, bytes);
+  if (pEntry == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
   pEntry->bytes = bytes;
   pEntry->dataLen = dataLen;
   pEntry->rid = -1;
-  return pEntry;
-}
-
-// step 4. SyncClientRequest => SSyncRaftEntry, add term, index
-SSyncRaftEntry* syncEntryBuild2(SyncClientRequest* pMsg, SyncTerm term, SyncIndex index) {
-  SSyncRaftEntry* pEntry = syncEntryBuild3(pMsg, term, index);
-  ASSERT(pEntry != NULL);
 
   return pEntry;
 }
 
-SSyncRaftEntry* syncEntryBuild3(SyncClientRequest* pMsg, SyncTerm term, SyncIndex index) {
+SSyncRaftEntry* syncEntryBuildFromClientRequest(const SyncClientRequest* pMsg, SyncTerm term, SyncIndex index) {
   SSyncRaftEntry* pEntry = syncEntryBuild(pMsg->dataLen);
-  ASSERT(pEntry != NULL);
+  if (pEntry == NULL) return NULL;
 
   pEntry->msgType = pMsg->msgType;
   pEntry->originalRpcType = pMsg->originalRpcType;
@@ -45,42 +42,37 @@ SSyncRaftEntry* syncEntryBuild3(SyncClientRequest* pMsg, SyncTerm term, SyncInde
   pEntry->isWeak = pMsg->isWeak;
   pEntry->term = term;
   pEntry->index = index;
-  pEntry->dataLen = pMsg->dataLen;
   memcpy(pEntry->data, pMsg->data, pMsg->dataLen);
 
   return pEntry;
 }
 
-SSyncRaftEntry* syncEntryBuild4(SRpcMsg* pOriginalMsg, SyncTerm term, SyncIndex index) {
-  SSyncRaftEntry* pEntry = syncEntryBuild(pOriginalMsg->contLen);
-  ASSERT(pEntry != NULL);
+SSyncRaftEntry* syncEntryBuildFromRpcMsg(const SRpcMsg* pMsg, SyncTerm term, SyncIndex index) {
+  SSyncRaftEntry* pEntry = syncEntryBuild(pMsg->contLen);
+  if (pEntry == NULL) return NULL;
 
   pEntry->msgType = TDMT_SYNC_CLIENT_REQUEST;
-  pEntry->originalRpcType = pOriginalMsg->msgType;
+  pEntry->originalRpcType = pMsg->msgType;
   pEntry->seqNum = 0;
   pEntry->isWeak = 0;
   pEntry->term = term;
   pEntry->index = index;
-  pEntry->dataLen = pOriginalMsg->contLen;
-  memcpy(pEntry->data, pOriginalMsg->pCont, pOriginalMsg->contLen);
+  memcpy(pEntry->data, pMsg->pCont, pMsg->contLen);
+
+  return pEntry;
+}
+
+SSyncRaftEntry* syncEntryBuildFromAppendEntries(const SyncAppendEntries* pMsg) {
+  SSyncRaftEntry* pEntry = syncEntryBuild(pMsg->dataLen);
+  if (pEntry == NULL) return NULL;
 
+  memcpy(pEntry, pMsg->data, pMsg->dataLen);
   return pEntry;
 }
 
 SSyncRaftEntry* syncEntryBuildNoop(SyncTerm term, SyncIndex index, int32_t vgId) {
-  // init rpcMsg
-  SMsgHead head;
-  head.vgId = vgId;
-  head.contLen = sizeof(SMsgHead);
-  SRpcMsg rpcMsg;
-  memset(&rpcMsg, 0, sizeof(SRpcMsg));
-  rpcMsg.contLen = head.contLen;
-  rpcMsg.pCont = rpcMallocCont(rpcMsg.contLen);
-  rpcMsg.msgType = TDMT_SYNC_NOOP;
-  memcpy(rpcMsg.pCont, &head, sizeof(head));
-
-  SSyncRaftEntry* pEntry = syncEntryBuild(rpcMsg.contLen);
-  ASSERT(pEntry != NULL);
+  SSyncRaftEntry* pEntry = syncEntryBuild(sizeof(SMsgHead));
+  if (pEntry == NULL) return NULL;
 
   pEntry->msgType = TDMT_SYNC_CLIENT_REQUEST;
   pEntry->originalRpcType = TDMT_SYNC_NOOP;
@@ -89,9 +81,9 @@ SSyncRaftEntry* syncEntryBuildNoop(SyncTerm term, SyncIndex index, int32_t vgId)
   pEntry->term = term;
   pEntry->index = index;
 
-  ASSERT(pEntry->dataLen == rpcMsg.contLen);
-  memcpy(pEntry->data, rpcMsg.pCont, rpcMsg.contLen);
-  rpcFreeCont(rpcMsg.pCont);
+  SMsgHead* pHead = (SMsgHead*)pEntry->data;
+  pHead->vgId = vgId;
+  pHead->contLen = sizeof(SMsgHead);
 
   return pEntry;
 }
@@ -102,104 +94,13 @@ void syncEntryDestory(SSyncRaftEntry* pEntry) {
   }
 }
 
-// step 5. SSyncRaftEntry => bin, to raft log
-char* syncEntrySerialize(const SSyncRaftEntry* pEntry, uint32_t* len) {
-  char* buf = taosMemoryMalloc(pEntry->bytes);
-  ASSERT(buf != NULL);
-  memcpy(buf, pEntry, pEntry->bytes);
-  if (len != NULL) {
-    *len = pEntry->bytes;
-  }
-  return buf;
-}
-
-// step 6. bin => SSyncRaftEntry, from raft log
-SSyncRaftEntry* syncEntryDeserialize(const char* buf, uint32_t len) {
-  uint32_t        bytes = *((uint32_t*)buf);
-  SSyncRaftEntry* pEntry = taosMemoryMalloc(bytes);
-  ASSERT(pEntry != NULL);
-  memcpy(pEntry, buf, len);
-  ASSERT(len == pEntry->bytes);
-  return pEntry;
-}
-
-cJSON* syncEntry2Json(const SSyncRaftEntry* pEntry) {
-  char   u64buf[128] = {0};
-  cJSON* pRoot = cJSON_CreateObject();
-
-  if (pEntry != NULL) {
-    cJSON_AddNumberToObject(pRoot, "bytes", pEntry->bytes);
-    cJSON_AddNumberToObject(pRoot, "msgType", pEntry->msgType);
-    cJSON_AddNumberToObject(pRoot, "originalRpcType", pEntry->originalRpcType);
-    snprintf(u64buf, sizeof(u64buf), "%" PRIu64, pEntry->seqNum);
-    cJSON_AddStringToObject(pRoot, "seqNum", u64buf);
-    cJSON_AddNumberToObject(pRoot, "isWeak", pEntry->isWeak);
-    snprintf(u64buf, sizeof(u64buf), "%" PRIu64, pEntry->term);
-    cJSON_AddStringToObject(pRoot, "term", u64buf);
-    snprintf(u64buf, sizeof(u64buf), "%" PRIu64, pEntry->index);
-    cJSON_AddStringToObject(pRoot, "index", u64buf);
-    snprintf(u64buf, sizeof(u64buf), "%" PRIu64, pEntry->rid);
-    cJSON_AddStringToObject(pRoot, "rid", u64buf);
-    cJSON_AddNumberToObject(pRoot, "dataLen", pEntry->dataLen);
-
-    char* s;
-    s = syncUtilPrintBin((char*)(pEntry->data), pEntry->dataLen);
-    cJSON_AddStringToObject(pRoot, "data", s);
-    taosMemoryFree(s);
-
-    s = syncUtilPrintBin2((char*)(pEntry->data), pEntry->dataLen);
-    cJSON_AddStringToObject(pRoot, "data2", s);
-    taosMemoryFree(s);
-  }
-
-  cJSON* pJson = cJSON_CreateObject();
-  cJSON_AddItemToObject(pJson, "SSyncRaftEntry", pRoot);
-  return pJson;
-}
-
-char* syncEntry2Str(const SSyncRaftEntry* pEntry) {
-  cJSON* pJson = syncEntry2Json(pEntry);
-  char*  serialized = cJSON_Print(pJson);
-  cJSON_Delete(pJson);
-  return serialized;
-}
-
-// step 7. SSyncRaftEntry => original SRpcMsg, commit to user, delete seqNum, isWeak, term, index
 void syncEntry2OriginalRpc(const SSyncRaftEntry* pEntry, SRpcMsg* pRpcMsg) {
-  memset(pRpcMsg, 0, sizeof(*pRpcMsg));
   pRpcMsg->msgType = pEntry->originalRpcType;
   pRpcMsg->contLen = pEntry->dataLen;
   pRpcMsg->pCont = rpcMallocCont(pRpcMsg->contLen);
   memcpy(pRpcMsg->pCont, pEntry->data, pRpcMsg->contLen);
 }
 
-// for debug ----------------------
-void syncEntryPrint(const SSyncRaftEntry* pObj) {
-  char* serialized = syncEntry2Str(pObj);
-  printf("syncEntryPrint | len:%zu | %s \n", strlen(serialized), serialized);
-  fflush(NULL);
-  taosMemoryFree(serialized);
-}
-
-void syncEntryPrint2(char* s, const SSyncRaftEntry* pObj) {
-  char* serialized = syncEntry2Str(pObj);
-  printf("syncEntryPrint2 | len:%zu | %s | %s \n", strlen(serialized), s, serialized);
-  fflush(NULL);
-  taosMemoryFree(serialized);
-}
-
-void syncEntryLog(const SSyncRaftEntry* pObj) {
-  char* serialized = syncEntry2Str(pObj);
-  sTrace("syncEntryLog | len:%zu | %s", strlen(serialized), serialized);
-  taosMemoryFree(serialized);
-}
-
-void syncEntryLog2(char* s, const SSyncRaftEntry* pObj) {
-  char* serialized = syncEntry2Str(pObj);
-  sTrace("syncEntryLog2 | len:%zu | %s | %s", strlen(serialized), s, serialized);
-  taosMemoryFree(serialized);
-}
-
 //-----------------------------------
 SRaftEntryHashCache* raftCacheCreate(SSyncNode* pSyncNode, int32_t maxCount) {
   SRaftEntryHashCache* pCache = taosMemoryMalloc(sizeof(SRaftEntryHashCache));
@@ -354,76 +255,6 @@ int32_t raftCacheClear(struct SRaftEntryHashCache* pCache) {
   return 0;
 }
 
-//-----------------------------------
-cJSON* raftCache2Json(SRaftEntryHashCache* pCache) {
-  char   u64buf[128] = {0};
-  cJSON* pRoot = cJSON_CreateObject();
-
-  if (pCache != NULL) {
-    taosThreadMutexLock(&pCache->mutex);
-
-    snprintf(u64buf, sizeof(u64buf), "%p", pCache->pSyncNode);
-    cJSON_AddStringToObject(pRoot, "pSyncNode", u64buf);
-    cJSON_AddNumberToObject(pRoot, "currentCount", pCache->currentCount);
-    cJSON_AddNumberToObject(pRoot, "maxCount", pCache->maxCount);
-    cJSON* pEntries = cJSON_CreateArray();
-    cJSON_AddItemToObject(pRoot, "entries", pEntries);
-
-    SSyncRaftEntry* pIter = (SSyncRaftEntry*)taosHashIterate(pCache->pEntryHash, NULL);
-    if (pIter != NULL) {
-      SSyncRaftEntry* pEntry = (SSyncRaftEntry*)pIter;
-      cJSON_AddItemToArray(pEntries, syncEntry2Json(pEntry));
-    }
-    while (pIter) {
-      pIter = taosHashIterate(pCache->pEntryHash, pIter);
-      if (pIter != NULL) {
-        SSyncRaftEntry* pEntry = (SSyncRaftEntry*)pIter;
-        cJSON_AddItemToArray(pEntries, syncEntry2Json(pEntry));
-      }
-    }
-
-    taosThreadMutexUnlock(&pCache->mutex);
-  }
-
-  cJSON* pJson = cJSON_CreateObject();
-  cJSON_AddItemToObject(pJson, "SRaftEntryHashCache", pRoot);
-  return pJson;
-}
-
-char* raftCache2Str(SRaftEntryHashCache* pCache) {
-  cJSON* pJson = raftCache2Json(pCache);
-  char*  serialized = cJSON_Print(pJson);
-  cJSON_Delete(pJson);
-  return serialized;
-}
-
-void raftCachePrint(SRaftEntryHashCache* pCache) {
-  char* serialized = raftCache2Str(pCache);
-  printf("raftCachePrint | len:%d | %s \n", (int32_t)strlen(serialized), serialized);
-  fflush(NULL);
-  taosMemoryFree(serialized);
-}
-
-void raftCachePrint2(char* s, SRaftEntryHashCache* pCache) {
-  char* serialized = raftCache2Str(pCache);
-  printf("raftCachePrint2 | len:%d | %s | %s \n", (int32_t)strlen(serialized), s, serialized);
-  fflush(NULL);
-  taosMemoryFree(serialized);
-}
-
-void raftCacheLog(SRaftEntryHashCache* pCache) {
-  char* serialized = raftCache2Str(pCache);
-  sTrace("raftCacheLog | len:%d | %s", (int32_t)strlen(serialized), serialized);
-  taosMemoryFree(serialized);
-}
-
-void raftCacheLog2(char* s, SRaftEntryHashCache* pCache) {
-  if (gRaftDetailLog) {
-    char* serialized = raftCache2Str(pCache);
-    sLTrace("raftCacheLog2 | len:%d | %s | %s", (int32_t)strlen(serialized), s, serialized);
-    taosMemoryFree(serialized);
-  }
-}
 
 //-----------------------------------
 static char* keyFn(const void* pData) {
@@ -612,69 +443,3 @@ int32_t raftEntryCacheClear(struct SRaftEntryCache* pCache, int32_t count) {
   taosThreadMutexUnlock(&pCache->mutex);
   return returnCnt;
 }
-
-cJSON* raftEntryCache2Json(SRaftEntryCache* pCache) {
-  char   u64buf[128] = {0};
-  cJSON* pRoot = cJSON_CreateObject();
-
-  if (pCache != NULL) {
-    taosThreadMutexLock(&pCache->mutex);
-
-    snprintf(u64buf, sizeof(u64buf), "%p", pCache->pSyncNode);
-    cJSON_AddStringToObject(pRoot, "pSyncNode", u64buf);
-    cJSON_AddNumberToObject(pRoot, "currentCount", pCache->currentCount);
-    cJSON_AddNumberToObject(pRoot, "maxCount", pCache->maxCount);
-    cJSON* pEntries = cJSON_CreateArray();
-    cJSON_AddItemToObject(pRoot, "entries", pEntries);
-
-    SSkipListIterator* pIter = tSkipListCreateIter(pCache->pSkipList);
-    while (tSkipListIterNext(pIter)) {
-      SSkipListNode* pNode = tSkipListIterGet(pIter);
-      ASSERT(pNode != NULL);
-      SSyncRaftEntry* pEntry = (SSyncRaftEntry*)SL_GET_NODE_DATA(pNode);
-      cJSON_AddItemToArray(pEntries, syncEntry2Json(pEntry));
-    }
-    tSkipListDestroyIter(pIter);
-
-    taosThreadMutexUnlock(&pCache->mutex);
-  }
-
-  cJSON* pJson = cJSON_CreateObject();
-  cJSON_AddItemToObject(pJson, "SRaftEntryCache", pRoot);
-  return pJson;
-}
-
-char* raftEntryCache2Str(SRaftEntryCache* pObj) {
-  cJSON* pJson = raftEntryCache2Json(pObj);
-  char*  serialized = cJSON_Print(pJson);
-  cJSON_Delete(pJson);
-  return serialized;
-}
-
-void raftEntryCachePrint(SRaftEntryCache* pObj) {
-  char* serialized = raftEntryCache2Str(pObj);
-  printf("raftEntryCachePrint | len:%d | %s \n", (int32_t)strlen(serialized), serialized);
-  fflush(NULL);
-  taosMemoryFree(serialized);
-}
-
-void raftEntryCachePrint2(char* s, SRaftEntryCache* pObj) {
-  char* serialized = raftEntryCache2Str(pObj);
-  printf("raftEntryCachePrint2 | len:%d | %s | %s \n", (int32_t)strlen(serialized), s, serialized);
-  fflush(NULL);
-  taosMemoryFree(serialized);
-}
-
-void raftEntryCacheLog(SRaftEntryCache* pObj) {
-  char* serialized = raftEntryCache2Str(pObj);
-  sTrace("raftEntryCacheLog | len:%d | %s", (int32_t)strlen(serialized), serialized);
-  taosMemoryFree(serialized);
-}
-
-void raftEntryCacheLog2(char* s, SRaftEntryCache* pObj) {
-  if (gRaftDetailLog) {
-    char* serialized = raftEntryCache2Str(pObj);
-    sLTrace("raftEntryCacheLog2 | len:%d | %s | %s", (int32_t)strlen(serialized), s, serialized);
-    taosMemoryFree(serialized);
-  }
-}

source/libs/sync/src/syncRaftLog.c

@@ -22,15 +22,8 @@
 
 // public function
 static int32_t   raftLogRestoreFromSnapshot(struct SSyncLogStore* pLogStore, SyncIndex snapshotIndex);
-static SyncIndex raftLogBeginIndex(struct SSyncLogStore* pLogStore);
-static SyncIndex raftLogEndIndex(struct SSyncLogStore* pLogStore);
-static SyncIndex raftLogWriteIndex(struct SSyncLogStore* pLogStore);
-static bool      raftLogIsEmpty(struct SSyncLogStore* pLogStore);
-static int32_t   raftLogEntryCount(struct SSyncLogStore* pLogStore);
-static SyncIndex raftLogLastIndex(struct SSyncLogStore* pLogStore);
-static SyncTerm  raftLogLastTerm(struct SSyncLogStore* pLogStore);
+
 static int32_t   raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntry* pEntry);
-static int32_t   raftLogGetEntry(struct SSyncLogStore* pLogStore, SyncIndex index, SSyncRaftEntry** ppEntry);
 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);
@@ -126,29 +119,29 @@ static int32_t raftLogRestoreFromSnapshot(struct SSyncLogStore* pLogStore, SyncI
   return 0;
 }
 
-static SyncIndex raftLogBeginIndex(struct SSyncLogStore* pLogStore) {
+SyncIndex raftLogBeginIndex(struct SSyncLogStore* pLogStore) {
   SSyncLogStoreData* pData = pLogStore->data;
   SWal*              pWal = pData->pWal;
   SyncIndex          firstVer = walGetFirstVer(pWal);
   return firstVer;
 }
 
-static SyncIndex raftLogEndIndex(struct SSyncLogStore* pLogStore) { return raftLogLastIndex(pLogStore); }
+SyncIndex raftLogEndIndex(struct SSyncLogStore* pLogStore) { return raftLogLastIndex(pLogStore); }
 
-static bool raftLogIsEmpty(struct SSyncLogStore* pLogStore) {
+bool raftLogIsEmpty(struct SSyncLogStore* pLogStore) {
   SSyncLogStoreData* pData = pLogStore->data;
   SWal*              pWal = pData->pWal;
   return walIsEmpty(pWal);
 }
 
-static int32_t raftLogEntryCount(struct SSyncLogStore* pLogStore) {
+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;
 }
 
-static SyncIndex raftLogLastIndex(struct SSyncLogStore* pLogStore) {
+SyncIndex raftLogLastIndex(struct SSyncLogStore* pLogStore) {
   SyncIndex          lastIndex;
   SSyncLogStoreData* pData = pLogStore->data;
   SWal*              pWal = pData->pWal;
@@ -157,7 +150,7 @@ static SyncIndex raftLogLastIndex(struct SSyncLogStore* pLogStore) {
   return lastVer;
 }
 
-static SyncIndex raftLogWriteIndex(struct SSyncLogStore* pLogStore) {
+SyncIndex raftLogWriteIndex(struct SSyncLogStore* pLogStore) {
   SSyncLogStoreData* pData = pLogStore->data;
   SWal*              pWal = pData->pWal;
   SyncIndex          lastVer = walGetLastVer(pWal);
@@ -174,7 +167,7 @@ static bool raftLogExist(struct SSyncLogStore* pLogStore, SyncIndex index) {
 // if success, return last term
 // if not log, return 0
 // if error, return SYNC_TERM_INVALID
-static SyncTerm raftLogLastTerm(struct SSyncLogStore* pLogStore) {
+SyncTerm raftLogLastTerm(struct SSyncLogStore* pLogStore) {
   SSyncLogStoreData* pData = pLogStore->data;
   SWal*              pWal = pData->pWal;
   if (walIsEmpty(pWal)) {
@@ -225,7 +218,7 @@ static int32_t raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntr
 // entry found, return 0
 // entry not found, return -1, terrno = TSDB_CODE_WAL_LOG_NOT_EXIST
 // other error, return -1
-static int32_t raftLogGetEntry(struct SSyncLogStore* pLogStore, SyncIndex index, SSyncRaftEntry** ppEntry) {
+int32_t raftLogGetEntry(struct SSyncLogStore* pLogStore, SyncIndex index, SSyncRaftEntry** ppEntry) {
   SSyncLogStoreData* pData = pLogStore->data;
   SWal*              pWal = pData->pWal;
   int32_t            code = 0;
@@ -364,111 +357,6 @@ SyncIndex raftlogCommitIndex(SSyncLogStore* pLogStore) {
   return pData->pSyncNode->commitIndex;
 }
 
-cJSON* logStore2Json(SSyncLogStore* pLogStore) {
-  char               u64buf[128] = {0};
-  SSyncLogStoreData* pData = (SSyncLogStoreData*)pLogStore->data;
-  cJSON*             pRoot = cJSON_CreateObject();
-
-  if (pData != NULL && pData->pWal != NULL) {
-    snprintf(u64buf, sizeof(u64buf), "%p", pData->pSyncNode);
-    cJSON_AddStringToObject(pRoot, "pSyncNode", u64buf);
-    snprintf(u64buf, sizeof(u64buf), "%p", pData->pWal);
-    cJSON_AddStringToObject(pRoot, "pWal", u64buf);
-
-    SyncIndex beginIndex = raftLogBeginIndex(pLogStore);
-    snprintf(u64buf, sizeof(u64buf), "%" PRId64, beginIndex);
-    cJSON_AddStringToObject(pRoot, "beginIndex", u64buf);
-
-    SyncIndex endIndex = raftLogEndIndex(pLogStore);
-    snprintf(u64buf, sizeof(u64buf), "%" PRId64, endIndex);
-    cJSON_AddStringToObject(pRoot, "endIndex", u64buf);
-
-    int32_t count = raftLogEntryCount(pLogStore);
-    cJSON_AddNumberToObject(pRoot, "entryCount", count);
-
-    snprintf(u64buf, sizeof(u64buf), "%" PRId64, raftLogWriteIndex(pLogStore));
-    cJSON_AddStringToObject(pRoot, "WriteIndex", u64buf);
-
-    snprintf(u64buf, sizeof(u64buf), "%d", raftLogIsEmpty(pLogStore));
-    cJSON_AddStringToObject(pRoot, "IsEmpty", u64buf);
-
-    snprintf(u64buf, sizeof(u64buf), "%" PRId64, raftLogLastIndex(pLogStore));
-    cJSON_AddStringToObject(pRoot, "LastIndex", u64buf);
-    snprintf(u64buf, sizeof(u64buf), "%" PRIu64, raftLogLastTerm(pLogStore));
-    cJSON_AddStringToObject(pRoot, "LastTerm", u64buf);
-
-    cJSON* pEntries = cJSON_CreateArray();
-    cJSON_AddItemToObject(pRoot, "pEntries", pEntries);
-
-    if (!raftLogIsEmpty(pLogStore)) {
-      for (SyncIndex i = beginIndex; i <= endIndex; ++i) {
-        SSyncRaftEntry* pEntry = NULL;
-        raftLogGetEntry(pLogStore, i, &pEntry);
-
-        cJSON_AddItemToArray(pEntries, syncEntry2Json(pEntry));
-        syncEntryDestory(pEntry);
-      }
-    }
-  }
-
-  cJSON* pJson = cJSON_CreateObject();
-  cJSON_AddItemToObject(pJson, "SSyncLogStore", pRoot);
-  return pJson;
-}
-
-char* logStore2Str(SSyncLogStore* pLogStore) {
-  cJSON* pJson = logStore2Json(pLogStore);
-  char*  serialized = cJSON_Print(pJson);
-  cJSON_Delete(pJson);
-  return serialized;
-}
-
-cJSON* logStoreSimple2Json(SSyncLogStore* pLogStore) {
-  char               u64buf[128] = {0};
-  SSyncLogStoreData* pData = (SSyncLogStoreData*)pLogStore->data;
-  cJSON*             pRoot = cJSON_CreateObject();
-
-  if (pData != NULL && pData->pWal != NULL) {
-    snprintf(u64buf, sizeof(u64buf), "%p", pData->pSyncNode);
-    cJSON_AddStringToObject(pRoot, "pSyncNode", u64buf);
-    snprintf(u64buf, sizeof(u64buf), "%p", pData->pWal);
-    cJSON_AddStringToObject(pRoot, "pWal", u64buf);
-
-    SyncIndex beginIndex = raftLogBeginIndex(pLogStore);
-    snprintf(u64buf, sizeof(u64buf), "%" PRId64, beginIndex);
-    cJSON_AddStringToObject(pRoot, "beginIndex", u64buf);
-
-    SyncIndex endIndex = raftLogEndIndex(pLogStore);
-    snprintf(u64buf, sizeof(u64buf), "%" PRId64, endIndex);
-    cJSON_AddStringToObject(pRoot, "endIndex", u64buf);
-
-    int32_t count = raftLogEntryCount(pLogStore);
-    cJSON_AddNumberToObject(pRoot, "entryCount", count);
-
-    snprintf(u64buf, sizeof(u64buf), "%" PRId64, raftLogWriteIndex(pLogStore));
-    cJSON_AddStringToObject(pRoot, "WriteIndex", u64buf);
-
-    snprintf(u64buf, sizeof(u64buf), "%d", raftLogIsEmpty(pLogStore));
-    cJSON_AddStringToObject(pRoot, "IsEmpty", u64buf);
-
-    snprintf(u64buf, sizeof(u64buf), "%" PRId64, raftLogLastIndex(pLogStore));
-    cJSON_AddStringToObject(pRoot, "LastIndex", u64buf);
-    snprintf(u64buf, sizeof(u64buf), "%" PRIu64, raftLogLastTerm(pLogStore));
-    cJSON_AddStringToObject(pRoot, "LastTerm", u64buf);
-  }
-
-  cJSON* pJson = cJSON_CreateObject();
-  cJSON_AddItemToObject(pJson, "SSyncLogStoreSimple", pRoot);
-  return pJson;
-}
-
-char* logStoreSimple2Str(SSyncLogStore* pLogStore) {
-  cJSON* pJson = logStoreSimple2Json(pLogStore);
-  char*  serialized = cJSON_Print(pJson);
-  cJSON_Delete(pJson);
-  return serialized;
-}
-
 SyncIndex logStoreFirstIndex(SSyncLogStore* pLogStore) {
   SSyncLogStoreData* pData = pLogStore->data;
   SWal*              pWal = pData->pWal;
@@ -480,63 +368,3 @@ SyncIndex logStoreWalCommitVer(SSyncLogStore* pLogStore) {
   SWal*              pWal = pData->pWal;
   return walGetCommittedVer(pWal);
 }
-
-// for debug -----------------
-void logStorePrint(SSyncLogStore* pLogStore) {
-  char* serialized = logStore2Str(pLogStore);
-  printf("logStorePrint | len:%d | %s \n", (int32_t)strlen(serialized), serialized);
-  fflush(NULL);
-  taosMemoryFree(serialized);
-}
-
-void logStorePrint2(char* s, SSyncLogStore* pLogStore) {
-  char* serialized = logStore2Str(pLogStore);
-  printf("logStorePrint2 | len:%d | %s | %s \n", (int32_t)strlen(serialized), s, serialized);
-  fflush(NULL);
-  taosMemoryFree(serialized);
-}
-
-void logStoreLog(SSyncLogStore* pLogStore) {
-  if (gRaftDetailLog) {
-    char* serialized = logStore2Str(pLogStore);
-    sLTrace("logStoreLog | len:%d | %s", (int32_t)strlen(serialized), serialized);
-    taosMemoryFree(serialized);
-  }
-}
-
-void logStoreLog2(char* s, SSyncLogStore* pLogStore) {
-  if (gRaftDetailLog) {
-    char* serialized = logStore2Str(pLogStore);
-    sLTrace("logStoreLog2 | len:%d | %s | %s", (int32_t)strlen(serialized), s, serialized);
-    taosMemoryFree(serialized);
-  }
-}
-
-// for debug -----------------
-void logStoreSimplePrint(SSyncLogStore* pLogStore) {
-  char* serialized = logStoreSimple2Str(pLogStore);
-  printf("logStoreSimplePrint | len:%d | %s \n", (int32_t)strlen(serialized), serialized);
-  fflush(NULL);
-  taosMemoryFree(serialized);
-}
-
-void logStoreSimplePrint2(char* s, SSyncLogStore* pLogStore) {
-  char* serialized = logStoreSimple2Str(pLogStore);
-  printf("logStoreSimplePrint2 | len:%d | %s | %s \n", (int32_t)strlen(serialized), s, serialized);
-  fflush(NULL);
-  taosMemoryFree(serialized);
-}
-
-void logStoreSimpleLog(SSyncLogStore* pLogStore) {
-  char* serialized = logStoreSimple2Str(pLogStore);
-  sTrace("logStoreSimpleLog | len:%d | %s", (int32_t)strlen(serialized), serialized);
-  taosMemoryFree(serialized);
-}
-
-void logStoreSimpleLog2(char* s, SSyncLogStore* pLogStore) {
-  if (gRaftDetailLog) {
-    char* serialized = logStoreSimple2Str(pLogStore);
-    sTrace("logStoreSimpleLog2 | len:%d | %s | %s", (int32_t)strlen(serialized), s, serialized);
-    taosMemoryFree(serialized);
-  }
-}

source/libs/sync/src/syncReplication.c

@@ -78,14 +78,7 @@ int32_t syncNodeReplicateOne(SSyncNode* pSyncNode, SRaftId* pDestId) {
 
     pMsg = syncAppendEntriesBuild(pEntry->bytes, pSyncNode->vgId);
     ASSERT(pMsg != NULL);
-
-    // add pEntry into msg
-    uint32_t len;
-    char*    serialized = syncEntrySerialize(pEntry, &len);
-    ASSERT(len == pEntry->bytes);
-    memcpy(pMsg->data, serialized, len);
-
-    taosMemoryFree(serialized);
+    memcpy(pMsg->data, pEntry, pEntry->bytes);
     syncEntryDestory(pEntry);
 
   } else {

source/libs/sync/src/syncRespMgr.c

@@ -13,21 +13,22 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#define _DEFAULT_SOURCE
 #include "syncRespMgr.h"
 #include "syncRaftEntry.h"
 #include "syncRaftStore.h"
 
 SSyncRespMgr *syncRespMgrCreate(void *data, int64_t ttl) {
-  SSyncRespMgr *pObj = (SSyncRespMgr *)taosMemoryMalloc(sizeof(SSyncRespMgr));
+  SSyncRespMgr *pObj = taosMemoryCalloc(1, sizeof(SSyncRespMgr));
   if (pObj == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
-  memset(pObj, 0, sizeof(SSyncRespMgr));
 
   pObj->pRespHash =
       taosHashInit(sizeof(uint64_t), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
-  ASSERT(pObj->pRespHash != NULL);
+  if (pObj->pRespHash == NULL) return NULL;
+
   pObj->ttl = ttl;
   pObj->data = data;
   pObj->seqNum = 0;
@@ -38,93 +39,84 @@ SSyncRespMgr *syncRespMgrCreate(void *data, int64_t ttl) {
 
 void syncRespMgrDestroy(SSyncRespMgr *pObj) {
   if (pObj != NULL) {
-    taosThreadMutexLock(&(pObj->mutex));
+    taosThreadMutexLock(&pObj->mutex);
     taosHashCleanup(pObj->pRespHash);
-    taosThreadMutexUnlock(&(pObj->mutex));
+    taosThreadMutexUnlock(&pObj->mutex);
     taosThreadMutexDestroy(&(pObj->mutex));
     taosMemoryFree(pObj);
   }
 }
 
-int64_t syncRespMgrAdd(SSyncRespMgr *pObj, SRespStub *pStub) {
-  taosThreadMutexLock(&(pObj->mutex));
+uint64_t syncRespMgrAdd(SSyncRespMgr *pObj, const SRespStub *pStub) {
+  taosThreadMutexLock(&pObj->mutex);
 
-  uint64_t keyCode = ++(pObj->seqNum);
-  taosHashPut(pObj->pRespHash, &keyCode, sizeof(keyCode), pStub, sizeof(SRespStub));
+  uint64_t seq = ++(pObj->seqNum);
+  int32_t  code = taosHashPut(pObj->pRespHash, &seq, sizeof(uint64_t), pStub, sizeof(SRespStub));
+  sNTrace(pObj->data, "save message handle:%p, type:%s seq:%" PRIu64 " code:0x%x", pStub->rpcMsg.info.handle,
+          TMSG_INFO(pStub->rpcMsg.msgType), seq, code);
 
-  sNTrace(pObj->data, "save message handle, type:%s seq:%" PRIu64 " handle:%p", TMSG_INFO(pStub->rpcMsg.msgType),
-          keyCode, pStub->rpcMsg.info.handle);
-  taosThreadMutexUnlock(&(pObj->mutex));
-  return keyCode;
+  taosThreadMutexUnlock(&pObj->mutex);
+  return seq;
 }
 
-int32_t syncRespMgrDel(SSyncRespMgr *pObj, uint64_t index) {
-  taosThreadMutexLock(&(pObj->mutex));
+int32_t syncRespMgrDel(SSyncRespMgr *pObj, uint64_t seq) {
+  taosThreadMutexLock(&pObj->mutex);
 
-  taosHashRemove(pObj->pRespHash, &index, sizeof(index));
+  int32_t code = taosHashRemove(pObj->pRespHash, &seq, sizeof(seq));
+  sNTrace(pObj->data, "remove message handle, seq:%" PRIu64 " code:%d", seq, code);
 
-  taosThreadMutexUnlock(&(pObj->mutex));
-  return 0;
+  taosThreadMutexUnlock(&pObj->mutex);
+  return code;
 }
 
-int32_t syncRespMgrGet(SSyncRespMgr *pObj, uint64_t index, SRespStub *pStub) {
-  taosThreadMutexLock(&(pObj->mutex));
+int32_t syncRespMgrGet(SSyncRespMgr *pObj, uint64_t seq, SRespStub *pStub) {
+  taosThreadMutexLock(&pObj->mutex);
 
-  void *pTmp = taosHashGet(pObj->pRespHash, &index, sizeof(index));
+  SRespStub *pTmp = taosHashGet(pObj->pRespHash, &seq, sizeof(uint64_t));
   if (pTmp != NULL) {
     memcpy(pStub, pTmp, sizeof(SRespStub));
+    sNTrace(pObj->data, "get message handle, type:%s seq:%" PRIu64 " handle:%p", TMSG_INFO(pStub->rpcMsg.msgType), seq,
+            pStub->rpcMsg.info.handle);
 
-    sNTrace(pObj->data, "get message handle, type:%s seq:%" PRIu64 " handle:%p", TMSG_INFO(pStub->rpcMsg.msgType),
-            index, pStub->rpcMsg.info.handle);
-    taosThreadMutexUnlock(&(pObj->mutex));
+    taosThreadMutexUnlock(&pObj->mutex);
     return 1;  // get one object
   }
-  taosThreadMutexUnlock(&(pObj->mutex));
+
+  taosThreadMutexUnlock(&pObj->mutex);
   return 0;  // get none object
 }
 
-int32_t syncRespMgrGetAndDel(SSyncRespMgr *pObj, uint64_t index, SRespStub *pStub) {
-  taosThreadMutexLock(&(pObj->mutex));
+int32_t syncRespMgrGetAndDel(SSyncRespMgr *pObj, uint64_t seq, SRpcHandleInfo *pInfo) {
+  taosThreadMutexLock(&pObj->mutex);
 
-  void *pTmp = taosHashGet(pObj->pRespHash, &index, sizeof(index));
-  if (pTmp != NULL) {
-    memcpy(pStub, pTmp, sizeof(SRespStub));
+  SRespStub *pStub = taosHashGet(pObj->pRespHash, &seq, sizeof(uint64_t));
+  if (pStub != NULL) {
+    *pInfo = pStub->rpcMsg.info;
+    sNTrace(pObj->data, "get-and-del message handle:%p, type:%s seq:%" PRIu64, pStub->rpcMsg.info.handle,
+            TMSG_INFO(pStub->rpcMsg.msgType), seq);
+    taosHashRemove(pObj->pRespHash, &seq, sizeof(uint64_t));
 
-    sNTrace(pObj->data, "get-and-del message handle, type:%s seq:%" PRIu64 " handle:%p",
-            TMSG_INFO(pStub->rpcMsg.msgType), index, pStub->rpcMsg.info.handle);
-    taosHashRemove(pObj->pRespHash, &index, sizeof(index));
-    taosThreadMutexUnlock(&(pObj->mutex));
+    taosThreadMutexUnlock(&pObj->mutex);
     return 1;  // get one object
   }
-  taosThreadMutexUnlock(&(pObj->mutex));
-  return 0;  // get none object
-}
 
-void syncRespCleanRsp(SSyncRespMgr *pObj) {
-  taosThreadMutexLock(&(pObj->mutex));
-  syncRespCleanByTTL(pObj, -1, true);
-  taosThreadMutexUnlock(&(pObj->mutex));
-}
-
-void syncRespClean(SSyncRespMgr *pObj) {
-  taosThreadMutexLock(&(pObj->mutex));
-  syncRespCleanByTTL(pObj, pObj->ttl, false);
-  taosThreadMutexUnlock(&(pObj->mutex));
+  taosThreadMutexUnlock(&pObj->mutex);
+  return 0;  // get none object
 }
 
-void syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl, bool rsp) {
+static void syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl, bool rsp) {
   SRespStub *pStub = (SRespStub *)taosHashIterate(pObj->pRespHash, NULL);
   int        cnt = 0;
   int        sum = 0;
   SSyncNode *pSyncNode = pObj->data;
 
-  SArray *delIndexArray = taosArrayInit(0, sizeof(uint64_t));
-  ASSERT(delIndexArray != NULL);
-  sDebug("vgId:%d, resp mgr begin clean by ttl", pSyncNode->vgId);
+  SArray *delIndexArray = taosArrayInit(4, sizeof(uint64_t));
+  if (delIndexArray == NULL) return;
 
+  sDebug("vgId:%d, resp mgr begin clean by ttl", pSyncNode->vgId);
   while (pStub) {
     size_t    len;
-    void *    key = taosHashGetKey(pStub, &len);
+    void     *key = taosHashGetKey(pStub, &len);
     uint64_t *pSeqNum = (uint64_t *)key;
     sum++;
 
@@ -149,15 +141,15 @@ void syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl, bool rsp) {
       pStub->rpcMsg.contLen = 0;
 
       // TODO: and make rpcMsg body, call commit cb
-      // pSyncNode->pFsm->FpCommitCb(pSyncNode->pFsm, &(pStub->rpcMsg), cbMeta);
+      // pSyncNode->pFsm->FpCommitCb(pSyncNode->pFsm, &pStub->rpcMsg, cbMeta);
 
       pStub->rpcMsg.code = TSDB_CODE_SYN_NOT_LEADER;
       if (pStub->rpcMsg.info.handle != NULL) {
-        tmsgSendRsp(&(pStub->rpcMsg));
+        tmsgSendRsp(&pStub->rpcMsg);
       }
     }
 
-    pStub = (SRespStub *)taosHashIterate(pObj->pRespHash, pStub);
+    pStub = taosHashIterate(pObj->pRespHash, pStub);
   }
 
   int32_t arraySize = taosArrayGetSize(delIndexArray);
@@ -170,3 +162,15 @@ void syncRespCleanByTTL(SSyncRespMgr *pObj, int64_t ttl, bool rsp) {
   }
   taosArrayDestroy(delIndexArray);
 }
+
+void syncRespCleanRsp(SSyncRespMgr *pObj) {
+  taosThreadMutexLock(&pObj->mutex);
+  syncRespCleanByTTL(pObj, -1, true);
+  taosThreadMutexUnlock(&pObj->mutex);
+}
+
+void syncRespClean(SSyncRespMgr *pObj) {
+  taosThreadMutexLock(&pObj->mutex);
+  syncRespCleanByTTL(pObj, pObj->ttl, false);
+  taosThreadMutexUnlock(&pObj->mutex);
+}

source/libs/sync/src/syncUtil.c

@@ -205,7 +205,7 @@ static void syncPeerState2Str(SSyncNode* pSyncNode, char* buf, int32_t bufLen) {
 
     if (i < pSyncNode->replicaNum - 1) {
       len += snprintf(buf + len, bufLen - len, "%d:%" PRId64 " %" PRId64 ", ", i, pState->lastSendIndex,
-                     pState->lastSendTime);
+                      pState->lastSendTime);
     } else {
       len += snprintf(buf + len, bufLen - len, "%d:%" PRId64 " %" PRId64 "}", i, pState->lastSendIndex,
                       pState->lastSendTime);
@@ -216,6 +216,9 @@ static void syncPeerState2Str(SSyncNode* pSyncNode, char* buf, int32_t bufLen) {
 void syncPrintNodeLog(const char* flags, ELogLevel level, int32_t dflag, SSyncNode* pNode, const char* format, ...) {
   if (pNode == NULL || pNode->pRaftCfg != NULL && pNode->pRaftStore == NULL || pNode->pLogStore == NULL) return;
 
+  // save error code, otherwise it will be overwritten
+  int32_t errCode = terrno;
+
   SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0};
   if (pNode->pFsm != NULL && pNode->pFsm->FpGetSnapshotInfo != NULL) {
     pNode->pFsm->FpGetSnapshotInfo(pNode->pFsm, &snapshot);
@@ -242,16 +245,21 @@ void syncPrintNodeLog(const char* flags, ELogLevel level, int32_t dflag, SSyncNo
   int32_t writeLen = vsnprintf(eventLog, sizeof(eventLog), format, argpointer);
   va_end(argpointer);
 
+  int32_t aqItems = pNode->pFsm->FpApplyQueueItems(pNode->pFsm);
+
+  // restore error code
+  terrno = errCode;
+
   taosPrintLog(flags, level, dflag,
                "vgId:%d, sync %s "
                "%s"
                ", tm:%" PRIu64 ", cmt:%" PRId64 ", fst:%" PRId64 ", lst:%" PRId64 ", min:%" PRId64 ", snap:%" PRId64
-               ", snap-tm:%" PRIu64 ", sby:%d, stgy:%d, bch:%d, r-num:%d, lcfg:%" PRId64
+               ", snap-tm:%" PRIu64 ", sby:%d, aq:%d, bch:%d, r-num:%d, lcfg:%" PRId64
                ", chging:%d, rsto:%d, dquorum:%d, elt:%" PRId64 ", hb:%" PRId64 ", %s, %s",
                pNode->vgId, syncStr(pNode->state), eventLog, pNode->pRaftStore->currentTerm, pNode->commitIndex,
                logBeginIndex, logLastIndex, pNode->minMatchIndex, snapshot.lastApplyIndex, snapshot.lastApplyTerm,
-               pNode->pRaftCfg->isStandBy, pNode->pRaftCfg->snapshotStrategy, pNode->pRaftCfg->batchSize,
-               pNode->replicaNum, pNode->pRaftCfg->lastConfigIndex, pNode->changing, pNode->restoreFinish, quorum,
+               pNode->pRaftCfg->isStandBy, aqItems, pNode->pRaftCfg->batchSize, pNode->replicaNum,
+               pNode->pRaftCfg->lastConfigIndex, pNode->changing, pNode->restoreFinish, quorum,
                pNode->electTimerLogicClock, pNode->heartbeatTimerLogicClockUser, peerStr, cfgStr);
 }
 

source/libs/sync/test/CMakeLists.txt

+add_subdirectory(sync_test_lib)
 add_executable(syncTest "")
 add_executable(syncRaftIdCheck "")
 add_executable(syncEnvTest "")
@@ -24,8 +25,6 @@ add_executable(syncRequestVoteReplyTest "")
 add_executable(syncAppendEntriesTest "")
 add_executable(syncAppendEntriesBatchTest "")
 add_executable(syncAppendEntriesReplyTest "")
-add_executable(syncClientRequestTest "")
-add_executable(syncClientRequestBatchTest "")
 add_executable(syncTimeoutTest "")
 add_executable(syncPingTest "")
 add_executable(syncPingReplyTest "")
@@ -167,14 +166,6 @@ target_sources(syncAppendEntriesReplyTest
     PRIVATE
     "syncAppendEntriesReplyTest.cpp"
 )
-target_sources(syncClientRequestTest
-    PRIVATE
-    "syncClientRequestTest.cpp"
-)
-target_sources(syncClientRequestBatchTest
-    PRIVATE
-    "syncClientRequestBatchTest.cpp"
-)
 target_sources(syncTimeoutTest
     PRIVATE
     "syncTimeoutTest.cpp"
@@ -287,10 +278,6 @@ target_sources(syncLeaderTransferTest
     PRIVATE
     "syncLeaderTransferTest.cpp"
 )
-target_sources(syncReconfigFinishTest
-    PRIVATE
-    "syncReconfigFinishTest.cpp"
-)
 target_sources(syncRestoreFromSnapshot
     PRIVATE
     "syncRestoreFromSnapshot.cpp"
@@ -451,16 +438,6 @@ target_include_directories(syncAppendEntriesReplyTest
     "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
-target_include_directories(syncClientRequestTest
-    PUBLIC
-    "${TD_SOURCE_DIR}/include/libs/sync"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
-)
-target_include_directories(syncClientRequestBatchTest
-    PUBLIC
-    "${TD_SOURCE_DIR}/include/libs/sync"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
-)
 target_include_directories(syncTimeoutTest
     PUBLIC
     "${TD_SOURCE_DIR}/include/libs/sync"
@@ -601,11 +578,6 @@ target_include_directories(syncLeaderTransferTest
     "${TD_SOURCE_DIR}/include/libs/sync"
     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 )
-target_include_directories(syncReconfigFinishTest
-    PUBLIC
-    "${TD_SOURCE_DIR}/include/libs/sync"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
-)
 target_include_directories(syncRestoreFromSnapshot
     PUBLIC
     "${TD_SOURCE_DIR}/include/libs/sync"
@@ -644,259 +616,247 @@ target_include_directories(syncPreSnapshotReplyTest
 
 
 target_link_libraries(syncTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRaftIdCheck
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncEnvTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncPingTimerTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncIOTickQTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncIOTickPingTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncIOSendMsgTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncIOClientTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncIOServerTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRaftStoreTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncEnqTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncIndexTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncInitTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncUtilTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncVotesGrantedTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncVotesRespondTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncIndexMgrTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncLogStoreTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncEntryTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncEntryCacheTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncHashCacheTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRequestVoteTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRequestVoteReplyTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncAppendEntriesTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncAppendEntriesBatchTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncAppendEntriesReplyTest
-    sync
-    gtest_main
-)
-target_link_libraries(syncClientRequestTest
-    sync
-    gtest_main
-)
-target_link_libraries(syncClientRequestBatchTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncTimeoutTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncPingTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncPingReplyTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRpcMsgTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncPingTimerTest2
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncPingSelfTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncElectTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncEncodeTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncWriteTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncReplicateTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRefTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncLogStoreCheck
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncLogStoreCheck2
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRaftCfgTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRespMgrTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncSnapshotTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncApplyMsgTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncConfigChangeTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncConfigChangeSnapshotTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncSnapshotSendTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncSnapshotRspTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncSnapshotSenderTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncSnapshotReceiverTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncTestTool
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRaftLogTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRaftLogTest2
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRaftLogTest3
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncLeaderTransferTest
-    sync
-    gtest_main
-)
-target_link_libraries(syncReconfigFinishTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRestoreFromSnapshot
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncRaftCfgIndexTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncHeartbeatTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncHeartbeatReplyTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncLocalCmdTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncPreSnapshotTest
-    sync
+    sync_test_lib
     gtest_main
 )
 target_link_libraries(syncPreSnapshotReplyTest
-    sync
+    sync_test_lib
     gtest_main
 )
 

source/libs/sync/test/syncAppendEntriesBatchTest.cpp

@@ -6,6 +6,7 @@
 #include "syncRaftEntry.h"
 #include "syncUtil.h"
 #include "trpc.h"
+#include "syncTest.h"
 
 void logTest() {
   sTrace("--- sync log test: trace");

source/libs/sync/test/syncClientRequestBatchTest.cpp

-#include <gtest/gtest.h>
-#include <stdio.h>
-#include "syncIO.h"
-#include "syncInt.h"
-#include "syncMessage.h"
-#include "syncUtil.h"
-
-void logTest() {
-  sTrace("--- sync log test: trace");
-  sDebug("--- sync log test: debug");
-  sInfo("--- sync log test: info");
-  sWarn("--- sync log test: warn");
-  sError("--- sync log test: error");
-  sFatal("--- sync log test: fatal");
-}
-
-SRpcMsg *createRpcMsg(int32_t i, int32_t dataLen) {
-  SyncPing *pSyncMsg = syncPingBuild(20);
-  snprintf(pSyncMsg->data, pSyncMsg->dataLen, "value_%d", i);
-
-  SRpcMsg *pRpcMsg = (SRpcMsg *)taosMemoryMalloc(sizeof(SRpcMsg));
-  memset(pRpcMsg, 0, sizeof(SRpcMsg));
-  pRpcMsg->code = 10 * i;
-  syncPing2RpcMsg(pSyncMsg, pRpcMsg);
-
-  syncPingDestroy(pSyncMsg);
-  return pRpcMsg;
-}
-
-SyncClientRequestBatch *createMsg() {
-  SRpcMsg *rpcMsgPArr[5];
-  memset(rpcMsgPArr, 0, sizeof(rpcMsgPArr));
-  for (int32_t i = 0; i < 5; ++i) {
-    SRpcMsg *pRpcMsg = createRpcMsg(i, 20);
-    rpcMsgPArr[i] = pRpcMsg;
-    // taosMemoryFree(pRpcMsg);
-  }
-
-  SRaftMeta raftArr[5];
-  memset(raftArr, 0, sizeof(raftArr));
-  for (int32_t i = 0; i < 5; ++i) {
-    raftArr[i].seqNum = i * 10;
-    raftArr[i].isWeak = i % 2;
-  }
-
-  SyncClientRequestBatch *pMsg = syncClientRequestBatchBuild(rpcMsgPArr, raftArr, 5, 1234);
-  return pMsg;
-}
-
-void test1() {
-  SyncClientRequestBatch *pMsg = createMsg();
-  syncClientRequestBatchLog2((char *)"==test1==", pMsg);
-  syncClientRequestBatchDestroyDeep(pMsg);
-}
-
-/*
-void test2() {
-  SyncClientRequest *pMsg = createMsg();
-  uint32_t           len = pMsg->bytes;
-  char *             serialized = (char *)taosMemoryMalloc(len);
-  syncClientRequestSerialize(pMsg, serialized, len);
-  SyncClientRequest *pMsg2 = syncClientRequestAlloc(pMsg->dataLen);
-  syncClientRequestDeserialize(serialized, len, pMsg2);
-  syncClientRequestLog2((char *)"test2: syncClientRequestSerialize -> syncClientRequestDeserialize ", pMsg2);
-
-  taosMemoryFree(serialized);
-  syncClientRequestDestroy(pMsg);
-  syncClientRequestDestroy(pMsg2);
-}
-
-void test3() {
-  SyncClientRequest *pMsg = createMsg();
-  uint32_t           len;
-  char *             serialized = syncClientRequestSerialize2(pMsg, &len);
-  SyncClientRequest *pMsg2 = syncClientRequestDeserialize2(serialized, len);
-  syncClientRequestLog2((char *)"test3: syncClientRequestSerialize3 -> syncClientRequestDeserialize2 ", pMsg2);
-
-  taosMemoryFree(serialized);
-  syncClientRequestDestroy(pMsg);
-  syncClientRequestDestroy(pMsg2);
-}
-
-void test4() {
-  SyncClientRequest *pMsg = createMsg();
-  SRpcMsg            rpcMsg;
-  syncClientRequest2RpcMsg(pMsg, &rpcMsg);
-  SyncClientRequest *pMsg2 = (SyncClientRequest *)taosMemoryMalloc(rpcMsg.contLen);
-  syncClientRequestFromRpcMsg(&rpcMsg, pMsg2);
-  syncClientRequestLog2((char *)"test4: syncClientRequest2RpcMsg -> syncClientRequestFromRpcMsg ", pMsg2);
-
-  rpcFreeCont(rpcMsg.pCont);
-  syncClientRequestDestroy(pMsg);
-  syncClientRequestDestroy(pMsg2);
-}
-
-void test5() {
-  SyncClientRequest *pMsg = createMsg();
-  SRpcMsg            rpcMsg;
-  syncClientRequest2RpcMsg(pMsg, &rpcMsg);
-  SyncClientRequest *pMsg2 = syncClientRequestFromRpcMsg2(&rpcMsg);
-  syncClientRequestLog2((char *)"test5: syncClientRequest2RpcMsg -> syncClientRequestFromRpcMsg2 ", pMsg2);
-
-  rpcFreeCont(rpcMsg.pCont);
-  syncClientRequestDestroy(pMsg);
-  syncClientRequestDestroy(pMsg2);
-}
-*/
-
-int main() {
-  gRaftDetailLog = true;
-  tsAsyncLog = 0;
-  sDebugFlag = DEBUG_DEBUG + DEBUG_TRACE + DEBUG_SCREEN + DEBUG_FILE;
-  logTest();
-
-  test1();
-
-  /*
-test2();
-test3();
-test4();
-test5();
-*/
-
-  return 0;
-}

source/libs/sync/test/syncClientRequestTest.cpp

-#include <gtest/gtest.h>
-#include <stdio.h>
-#include "syncIO.h"
-#include "syncInt.h"
-#include "syncMessage.h"
-#include "syncUtil.h"
-
-void logTest() {
-  sTrace("--- sync log test: trace");
-  sDebug("--- sync log test: debug");
-  sInfo("--- sync log test: info");
-  sWarn("--- sync log test: warn");
-  sError("--- sync log test: error");
-  sFatal("--- sync log test: fatal");
-}
-
-SyncClientRequest *createMsg() {
-  SRpcMsg rpcMsg;
-  memset(&rpcMsg, 0, sizeof(rpcMsg));
-  rpcMsg.msgType = 12345;
-  rpcMsg.contLen = 20;
-  rpcMsg.pCont = rpcMallocCont(rpcMsg.contLen);
-  strcpy((char *)rpcMsg.pCont, "hello rpc");
-  SyncClientRequest *pMsg = syncClientRequestBuild(&rpcMsg, 123, true, 1000);
-  rpcFreeCont(rpcMsg.pCont);
-  return pMsg;
-}
-
-void test1() {
-  SyncClientRequest *pMsg = createMsg();
-  syncClientRequestLog2((char *)"test1:", pMsg);
-  syncClientRequestDestroy(pMsg);
-}
-
-void test2() {
-  SyncClientRequest *pMsg = createMsg();
-  uint32_t           len = pMsg->bytes;
-  char              *serialized = (char *)taosMemoryMalloc(len);
-  syncClientRequestSerialize(pMsg, serialized, len);
-  SyncClientRequest *pMsg2 = syncClientRequestAlloc(pMsg->dataLen);
-  syncClientRequestDeserialize(serialized, len, pMsg2);
-  syncClientRequestLog2((char *)"test2: syncClientRequestSerialize -> syncClientRequestDeserialize ", pMsg2);
-
-  taosMemoryFree(serialized);
-  syncClientRequestDestroy(pMsg);
-  syncClientRequestDestroy(pMsg2);
-}
-
-void test3() {
-  SyncClientRequest *pMsg = createMsg();
-  uint32_t           len;
-  char              *serialized = syncClientRequestSerialize2(pMsg, &len);
-  SyncClientRequest *pMsg2 = syncClientRequestDeserialize2(serialized, len);
-  syncClientRequestLog2((char *)"test3: syncClientRequestSerialize3 -> syncClientRequestDeserialize2 ", pMsg2);
-
-  taosMemoryFree(serialized);
-  syncClientRequestDestroy(pMsg);
-  syncClientRequestDestroy(pMsg2);
-}
-
-void test4() {
-  SyncClientRequest *pMsg = createMsg();
-  SRpcMsg            rpcMsg = {0};
-  syncClientRequest2RpcMsg(pMsg, &rpcMsg);
-  SyncClientRequest *pMsg2 = (SyncClientRequest *)taosMemoryMalloc(rpcMsg.contLen);
-  syncClientRequestFromRpcMsg(&rpcMsg, pMsg2);
-  syncClientRequestLog2((char *)"test4: syncClientRequest2RpcMsg -> syncClientRequestFromRpcMsg ", pMsg2);
-
-  rpcFreeCont(rpcMsg.pCont);
-  syncClientRequestDestroy(pMsg);
-  syncClientRequestDestroy(pMsg2);
-}
-
-void test5() {
-  SyncClientRequest *pMsg = createMsg();
-  SRpcMsg            rpcMsg = {0};
-  syncClientRequest2RpcMsg(pMsg, &rpcMsg);
-  SyncClientRequest *pMsg2 = syncClientRequestFromRpcMsg2(&rpcMsg);
-  syncClientRequestLog2((char *)"test5: syncClientRequest2RpcMsg -> syncClientRequestFromRpcMsg2 ", pMsg2);
-
-  rpcFreeCont(rpcMsg.pCont);
-  syncClientRequestDestroy(pMsg);
-  syncClientRequestDestroy(pMsg2);
-}
-
-int main() {
-  tsAsyncLog = 0;
-  sDebugFlag = DEBUG_TRACE + DEBUG_SCREEN + DEBUG_FILE;
-  logTest();
-
-  test1();
-  test2();
-  test3();
-  test4();
-  test5();
-
-  return 0;
-}

source/libs/sync/test/syncEncodeTest.cpp

@@ -7,9 +7,11 @@
 #include "syncRaftEntry.h"
 #include "syncRaftLog.h"
 #include "syncRaftStore.h"
+#include "syncTest.h"
 #include "syncUtil.h"
 #include "wal.h"
 
+#if 0
 void logTest() {
   sTrace("--- sync log test: trace");
   sDebug("--- sync log test: debug");
@@ -118,17 +120,7 @@ SyncClientRequest *step3(const SRpcMsg *pMsg) {
 }
 
 SSyncRaftEntry *step4(const SyncClientRequest *pMsg) {
-  SSyncRaftEntry *pRetMsg = syncEntryBuild2((SyncClientRequest *)pMsg, 100, 0);
-  return pRetMsg;
-}
-
-char *step5(const SSyncRaftEntry *pMsg, uint32_t *len) {
-  char *pRetMsg = syncEntrySerialize(pMsg, len);
-  return pRetMsg;
-}
-
-SSyncRaftEntry *step6(const char *pMsg, uint32_t len) {
-  SSyncRaftEntry *pRetMsg = syncEntryDeserialize(pMsg, len);
+  SSyncRaftEntry *pRetMsg = syncEntryBuildFromClientRequest((SyncClientRequest *)pMsg, 100, 0);
   return pRetMsg;
 }
 
@@ -137,13 +129,14 @@ SRpcMsg *step7(const SSyncRaftEntry *pMsg) {
   syncEntry2OriginalRpc(pMsg, pRetMsg);
   return pRetMsg;
 }
-
+#endif
 int main(int argc, char **argv) {
   // taosInitLog((char *)"syncTest.log", 100000, 10);
   tsAsyncLog = 0;
   sDebugFlag = 143 + 64;
   void logTest();
 
+#if 0
   myIndex = 0;
   if (argc >= 2) {
     myIndex = atoi(argv[1]);
@@ -188,20 +181,9 @@ int main(int argc, char **argv) {
 
   syncEntryLog2((char *)"==pEntry==", pEntry);
 
-  // step5
-  uint32_t len;
-  char    *pMsg5 = step5(pMsg4, &len);
-  char    *s = syncUtilPrintBin(pMsg5, len);
-  printf("==step5== [%s] \n", s);
-  taosMemoryFree(s);
-
-  // step6
-  SSyncRaftEntry *pMsg6 = step6(pMsg5, len);
-  syncEntryLog2((char *)"==step6==", pMsg6);
-
   // step7
   SRpcMsg *pMsg7 = step7(pMsg6);
   syncRpcMsgLog2((char *)"==step7==", pMsg7);
-
+#endif
   return 0;
 }

source/libs/sync/test/syncEntryCacheTest.cpp

@@ -7,6 +7,7 @@
 #include "syncUtil.h"
 #include "tref.h"
 #include "tskiplist.h"
+#include "syncTest.h"
 
 void logTest() {
   sTrace("--- sync log test: trace");

source/libs/sync/test/syncEntryTest.cpp

@@ -6,6 +6,7 @@
 #include "syncRaftLog.h"
 #include "syncRaftStore.h"
 #include "syncUtil.h"
+#include "syncTest.h"
 
 void logTest() {
   sTrace("--- sync log test: trace");
@@ -38,10 +39,10 @@ void test2() {
   pSyncMsg->isWeak = 1;
   strcpy(pSyncMsg->data, "test2");
 
-  SSyncRaftEntry* pEntry = syncEntryBuild2(pSyncMsg, 100, 200);
+  SSyncRaftEntry* pEntry = syncEntryBuildFromClientRequest(pSyncMsg, 100, 200);
   syncEntryPrint(pEntry);
 
-  syncClientRequestDestroy(pSyncMsg);
+  taosMemoryFree(pSyncMsg);
   syncEntryDestory(pEntry);
 }
 
@@ -52,10 +53,10 @@ void test3() {
   pSyncMsg->isWeak = 1;
   strcpy(pSyncMsg->data, "test3");
 
-  SSyncRaftEntry* pEntry = syncEntryBuild3(pSyncMsg, 100, 200);
+  SSyncRaftEntry* pEntry = syncEntryBuildFromClientRequest(pSyncMsg, 100, 200);
   syncEntryPrint(pEntry);
 
-  syncClientRequestDestroy(pSyncMsg);
+  taosMemoryFree(pSyncMsg);
   syncEntryDestory(pEntry);
 }
 
@@ -71,14 +72,7 @@ void test4() {
   strcpy(pEntry->data, "test4");
   syncEntryPrint(pEntry);
 
-  uint32_t len;
-  char*    serialized = syncEntrySerialize(pEntry, &len);
-  assert(serialized != NULL);
-  SSyncRaftEntry* pEntry2 = syncEntryDeserialize(serialized, len);
-  syncEntryPrint(pEntry2);
-
-  taosMemoryFree(serialized);
-  syncEntryDestory(pEntry2);
+  // syncEntryDestory(pEntry2);
   syncEntryDestory(pEntry);
 }
 

source/libs/sync/test/syncHashCacheTest.cpp

@@ -4,6 +4,7 @@
 #include "syncInt.h"
 #include "syncRaftLog.h"
 #include "syncRaftStore.h"
+#include "syncTest.h"
 #include "syncUtil.h"
 #include "tskiplist.h"
 

source/libs/sync/test/syncLogStoreCheck.cpp

@@ -5,6 +5,7 @@
 #include "syncInt.h"
 #include "syncRaftLog.h"
 #include "syncRaftStore.h"
+#include "syncTest.h"
 #include "syncUtil.h"
 #include "wal.h"
 

source/libs/sync/test/syncLogStoreCheck2.cpp

@@ -7,6 +7,7 @@
 #include "syncRaftStore.h"
 #include "syncUtil.h"
 #include "wal.h"
+#include "syncTest.h"
 
 void logTest() {
   sTrace("--- sync log test: trace");

source/libs/sync/test/syncLogStoreTest.cpp

@@ -5,6 +5,7 @@
 #include "syncInt.h"
 #include "syncRaftLog.h"
 #include "syncRaftStore.h"
+#include "syncTest.h"
 #include "syncUtil.h"
 #include "wal.h"
 

source/libs/sync/test/syncRaftLogTest2.cpp

@@ -5,6 +5,7 @@
 #include "syncInt.h"
 #include "syncRaftLog.h"
 #include "syncRaftStore.h"
+#include "syncTest.h"
 #include "syncUtil.h"
 #include "wal.h"
 

source/libs/sync/test/syncRaftLogTest3.cpp

 #include <gtest/gtest.h>
-#include <stdio.h>
-#include "syncEnv.h"
-#include "syncIO.h"
-#include "syncInt.h"
-#include "syncRaftLog.h"
-#include "syncRaftStore.h"
-#include "syncUtil.h"
-#include "wal.h"
+#include "syncTest.h"
 
 void logTest() {
   sTrace("--- sync log test: trace");

source/libs/sync/test/syncRespMgrTest.cpp

-#include "syncRespMgr.h"
-//#include <gtest/gtest.h>
-#include <stdio.h>
-#include "syncIO.h"
-#include "syncInt.h"
+#include "syncTest.h"
 
 void logTest() {
   sTrace("--- sync log test: trace");
@@ -64,13 +60,13 @@ void syncRespMgrGetTest(uint64_t i) {
 
 void syncRespMgrGetAndDelTest(uint64_t i) {
   printf("------syncRespMgrGetAndDelTest-------%" PRIu64 "-- \n", i);
-  SRespStub stub;
-  int32_t   ret = syncRespMgrGetAndDel(pMgr, i, &stub);
-  if (ret == 1) {
-    printStub(&stub);
-  } else if (ret == 0) {
-    printf("%" PRId64 " notFound \n", i);
-  }
+  // SRespStub stub;
+  // int32_t   ret = syncRespMgrGetAndDel(pMgr, i, &stub);
+  // if (ret == 1) {
+  //   printStub(&stub);
+  // } else if (ret == 0) {
+  //   printf("%" PRId64 " notFound \n", i);
+  // }
 }
 
 SSyncNode *createSyncNode() {

source/libs/sync/test/syncRpcMsgTest.cpp

@@ -47,7 +47,11 @@ SyncClientRequest *createSyncClientRequest() {
   rpcMsg.contLen = 20;
   rpcMsg.pCont = rpcMallocCont(rpcMsg.contLen);
   strcpy((char *)rpcMsg.pCont, "hello rpc");
-  SyncClientRequest *pMsg = syncClientRequestBuild(&rpcMsg, 123, true, 1000);
+
+  SRpcMsg clientRequestMsg;
+  syncClientRequestBuildFromRpcMsg(&clientRequestMsg, &rpcMsg, 123, true, 1000);
+  SyncClientRequest *pMsg = (SyncClientRequest *)taosMemoryMalloc(clientRequestMsg.contLen);
+  memcpy(pMsg->data, clientRequestMsg.pCont, clientRequestMsg.contLen);
   return pMsg;
 }
 
@@ -155,11 +159,13 @@ void test7() {
 }
 
 void test8() {
+#if 0
   SyncClientRequest *pMsg = createSyncClientRequest();
   SRpcMsg            rpcMsg = {0};
   syncClientRequest2RpcMsg(pMsg, &rpcMsg);
   syncRpcMsgLog2((char *)"test8", &rpcMsg);
-  syncClientRequestDestroy(pMsg);
+  taosMemoryFree(pMsg);
+#endif
 }
 
 int main() {

source/libs/sync/test/syncSnapshotTest.cpp

@@ -162,8 +162,11 @@ SRpcMsg *step0() {
 }
 
 SyncClientRequest *step1(const SRpcMsg *pMsg) {
-  SyncClientRequest *pRetMsg = syncClientRequestBuild(pMsg, 123, true, 1000);
-  return pRetMsg;
+  SRpcMsg clientRequestMsg;
+  syncClientRequestBuildFromRpcMsg(&clientRequestMsg, pMsg, 123, true, 1000);
+  SyncClientRequest *pMsg2 = (SyncClientRequest *)taosMemoryMalloc(clientRequestMsg.contLen);
+  memcpy(pMsg2->data, clientRequestMsg.pCont, clientRequestMsg.contLen);
+  return pMsg2;
 }
 
 int main(int argc, char **argv) {
@@ -207,8 +210,8 @@ int main(int argc, char **argv) {
   for (int i = 0; i < 10; ++i) {
     SyncClientRequest *pSyncClientRequest = pMsg1;
     SRpcMsg            rpcMsg = {0};
-    syncClientRequest2RpcMsg(pSyncClientRequest, &rpcMsg);
-    gSyncNode->syncEqMsg(gSyncNode->msgcb, &rpcMsg);
+    // syncClientRequest2RpcMsg(pSyncClientRequest, &rpcMsg);
+    // gSyncNode->syncEqMsg(gSyncNode->msgcb, &rpcMsg);
 
     taosMsleep(1000);
   }

source/libs/sync/test/syncVotesGrantedTest.cpp

@@ -6,6 +6,7 @@
 #include "syncRaftStore.h"
 #include "syncUtil.h"
 #include "syncVoteMgr.h"
+#include "syncTest.h"
 
 void logTest() {
   sTrace("--- sync log test: trace");

source/libs/sync/test/syncVotesRespondTest.cpp

@@ -6,6 +6,8 @@
 #include "syncRaftStore.h"
 #include "syncUtil.h"
 #include "syncVoteMgr.h"
+#include "syncTest.h"
+
 
 void logTest() {
   sTrace("--- sync log test: trace");

source/libs/sync/test/syncWriteTest.cpp

@@ -7,6 +7,7 @@
 #include "syncRaftEntry.h"
 #include "syncRaftLog.h"
 #include "syncRaftStore.h"
+#include "syncTest.h"
 #include "syncUtil.h"
 #include "wal.h"
 
@@ -140,7 +141,8 @@ SRpcMsg *step0() {
 }
 
 SyncClientRequest *step1(const SRpcMsg *pMsg) {
-  SyncClientRequest *pRetMsg = syncClientRequestBuild(pMsg, 123, true, 1000);
+  SyncClientRequest *pRetMsg = NULL;
+  // syncClientRequestBuild(pMsg, 123, true, 1000);
   return pRetMsg;
 }
 
@@ -179,14 +181,14 @@ int main(int argc, char **argv) {
   SyncClientRequest *pMsg1 = step1(pMsg0);
   syncClientRequestLog2((char *)"==step1==", pMsg1);
 
-  for (int i = 0; i < 10; ++i) {
-    SyncClientRequest *pSyncClientRequest = pMsg1;
-    SRpcMsg            rpcMsg = {0};
-    syncClientRequest2RpcMsg(pSyncClientRequest, &rpcMsg);
-    gSyncNode->syncEqMsg(gSyncNode->msgcb, &rpcMsg);
+  // for (int i = 0; i < 10; ++i) {
+  //   SyncClientRequest *pSyncClientRequest = pMsg1;
+  //   SRpcMsg            rpcMsg = {0};
+  //   syncClientRequest2RpcMsg(pSyncClientRequest, &rpcMsg);
+  //   gSyncNode->syncEqMsg(gSyncNode->msgcb, &rpcMsg);
 
-    taosMsleep(1000);
-  }
+  //   taosMsleep(1000);
+  // }
 
   while (1) {
     sTrace("while 1 sleep");

source/libs/sync/test/sync_test_lib/CMakeLists.txt

+aux_source_directory(src SYNC_TEST_SRC)
+add_library(sync_test_lib STATIC ${SYNC_TEST_SRC})
+
+target_link_libraries(
+    sync_test_lib
+    PUBLIC sync
+)
+
+target_include_directories(
+    sync_test_lib
+    PUBLIC "${TD_SOURCE_DIR}/include/libs/sync"
+    PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../../inc"
+    PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)

source/libs/sync/inc/syncIO.h → source/libs/sync/test/sync_test_lib/inc/syncIO.h

@@ -50,7 +50,7 @@ typedef struct SSyncIO {
   void *pSyncNode;
   int32_t (*FpOnSyncPing)(SSyncNode *pSyncNode, SyncPing *pMsg);
   int32_t (*FpOnSyncPingReply)(SSyncNode *pSyncNode, SyncPingReply *pMsg);
-  int32_t (*FpOnSyncClientRequest)(SSyncNode *pSyncNode, SyncClientRequest *pMsg, SyncIndex *pRetIndex);
+  int32_t (*FpOnSyncClientRequest)(SSyncNode *pSyncNode, SRpcMsg *pMsg, SyncIndex *pRetIndex);
   int32_t (*FpOnSyncRequestVote)(SSyncNode *pSyncNode, SyncRequestVote *pMsg);
   int32_t (*FpOnSyncRequestVoteReply)(SSyncNode *pSyncNode, SyncRequestVoteReply *pMsg);
   int32_t (*FpOnSyncAppendEntries)(SSyncNode *pSyncNode, SyncAppendEntries *pMsg);

source/libs/sync/test/sync_test_lib/inc/syncTest.h

+/*
+ * 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/>.
+ */
+
+#ifndef _TD_LIBS_SYNC_TEST_H
+#define _TD_LIBS_SYNC_TEST_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "syncInt.h"
+
+#include "wal.h"
+
+#include "syncEnv.h"
+#include "syncIO.h"
+#include "syncIndexMgr.h"
+#include "syncInt.h"
+#include "syncMessage.h"
+#include "syncRaftCfg.h"
+#include "syncRaftEntry.h"
+#include "syncRaftLog.h"
+#include "syncRaftStore.h"
+#include "syncRespMgr.h"
+#include "syncSnapshot.h"
+#include "syncUtil.h"
+#include "syncVoteMgr.h"
+
+cJSON* syncEntry2Json(const SSyncRaftEntry* pEntry);
+char*  syncEntry2Str(const SSyncRaftEntry* pEntry);
+void   syncEntryPrint(const SSyncRaftEntry* pObj);
+void   syncEntryPrint2(char* s, const SSyncRaftEntry* pObj);
+void   syncEntryLog(const SSyncRaftEntry* pObj);
+void   syncEntryLog2(char* s, const SSyncRaftEntry* pObj);
+
+cJSON* raftCache2Json(SRaftEntryHashCache* pObj);
+char*  raftCache2Str(SRaftEntryHashCache* pObj);
+void   raftCachePrint(SRaftEntryHashCache* pObj);
+void   raftCachePrint2(char* s, SRaftEntryHashCache* pObj);
+void   raftCacheLog(SRaftEntryHashCache* pObj);
+void   raftCacheLog2(char* s, SRaftEntryHashCache* pObj);
+
+cJSON* raftEntryCache2Json(SRaftEntryCache* pObj);
+char*  raftEntryCache2Str(SRaftEntryCache* pObj);
+void   raftEntryCachePrint(SRaftEntryCache* pObj);
+void   raftEntryCachePrint2(char* s, SRaftEntryCache* pObj);
+void   raftEntryCacheLog(SRaftEntryCache* pObj);
+void   raftEntryCacheLog2(char* s, SRaftEntryCache* pObj);
+
+cJSON* syncAppendEntriesBatch2Json(const SyncAppendEntriesBatch* pMsg);
+char*  syncAppendEntriesBatch2Str(const SyncAppendEntriesBatch* pMsg);
+void   syncAppendEntriesBatchPrint(const SyncAppendEntriesBatch* pMsg);
+void   syncAppendEntriesBatchPrint2(char* s, const SyncAppendEntriesBatch* pMsg);
+void   syncAppendEntriesBatchLog(const SyncAppendEntriesBatch* pMsg);
+void   syncAppendEntriesBatchLog2(char* s, const SyncAppendEntriesBatch* pMsg);
+
+cJSON* logStore2Json(SSyncLogStore* pLogStore);
+char*  logStore2Str(SSyncLogStore* pLogStore);
+cJSON* logStoreSimple2Json(SSyncLogStore* pLogStore);
+char*  logStoreSimple2Str(SSyncLogStore* pLogStore);
+void   logStorePrint(SSyncLogStore* pLogStore);
+void   logStorePrint2(char* s, SSyncLogStore* pLogStore);
+void   logStoreLog(SSyncLogStore* pLogStore);
+void   logStoreLog2(char* s, SSyncLogStore* pLogStore);
+void   logStoreSimplePrint(SSyncLogStore* pLogStore);
+void   logStoreSimplePrint2(char* s, SSyncLogStore* pLogStore);
+void   logStoreSimpleLog(SSyncLogStore* pLogStore);
+void   logStoreSimpleLog2(char* s, SSyncLogStore* pLogStore);
+
+cJSON* syncNode2Json(const SSyncNode* pSyncNode);
+char*  syncNode2Str(const SSyncNode* pSyncNode);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_LIBS_SYNC_RAFT_ENTRY_H*/

source/libs/sync/src/syncIO.c → source/libs/sync/test/sync_test_lib/src/syncIO.c

@@ -279,10 +279,7 @@ static void *syncIOConsumerFunc(void *param) {
 
       } else if (pRpcMsg->msgType == TDMT_SYNC_CLIENT_REQUEST) {
         if (io->FpOnSyncClientRequest != NULL) {
-          SyncClientRequest *pSyncMsg = syncClientRequestFromRpcMsg2(pRpcMsg);
-          ASSERT(pSyncMsg != NULL);
-          io->FpOnSyncClientRequest(io->pSyncNode, pSyncMsg, NULL);
-          syncClientRequestDestroy(pSyncMsg);
+          io->FpOnSyncClientRequest(io->pSyncNode, pRpcMsg, NULL);
         }
 
       } else if (pRpcMsg->msgType == TDMT_SYNC_REQUEST_VOTE) {

source/libs/sync/test/sync_test_lib/src/syncMainDebug.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 "syncTest.h"
+
+cJSON* syncNode2Json(const SSyncNode* pSyncNode) {
+  char   u64buf[128] = {0};
+  cJSON* pRoot = cJSON_CreateObject();
+
+  if (pSyncNode != NULL) {
+    // init by SSyncInfo
+    cJSON_AddNumberToObject(pRoot, "vgId", pSyncNode->vgId);
+    cJSON_AddItemToObject(pRoot, "SRaftCfg", raftCfg2Json(pSyncNode->pRaftCfg));
+    cJSON_AddStringToObject(pRoot, "path", pSyncNode->path);
+    cJSON_AddStringToObject(pRoot, "raftStorePath", pSyncNode->raftStorePath);
+    cJSON_AddStringToObject(pRoot, "configPath", pSyncNode->configPath);
+
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->pWal);
+    cJSON_AddStringToObject(pRoot, "pWal", u64buf);
+
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->msgcb);
+    cJSON_AddStringToObject(pRoot, "rpcClient", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->syncSendMSg);
+    cJSON_AddStringToObject(pRoot, "syncSendMSg", u64buf);
+
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->msgcb);
+    cJSON_AddStringToObject(pRoot, "queue", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->syncEqMsg);
+    cJSON_AddStringToObject(pRoot, "syncEqMsg", u64buf);
+
+    // init internal
+    cJSON* pMe = syncUtilNodeInfo2Json(&pSyncNode->myNodeInfo);
+    cJSON_AddItemToObject(pRoot, "myNodeInfo", pMe);
+    cJSON* pRaftId = syncUtilRaftId2Json(&pSyncNode->myRaftId);
+    cJSON_AddItemToObject(pRoot, "myRaftId", pRaftId);
+
+    cJSON_AddNumberToObject(pRoot, "peersNum", pSyncNode->peersNum);
+    cJSON* pPeers = cJSON_CreateArray();
+    cJSON_AddItemToObject(pRoot, "peersNodeInfo", pPeers);
+    for (int32_t i = 0; i < pSyncNode->peersNum; ++i) {
+      cJSON_AddItemToArray(pPeers, syncUtilNodeInfo2Json(&pSyncNode->peersNodeInfo[i]));
+    }
+    cJSON* pPeersId = cJSON_CreateArray();
+    cJSON_AddItemToObject(pRoot, "peersId", pPeersId);
+    for (int32_t i = 0; i < pSyncNode->peersNum; ++i) {
+      cJSON_AddItemToArray(pPeersId, syncUtilRaftId2Json(&pSyncNode->peersId[i]));
+    }
+
+    cJSON_AddNumberToObject(pRoot, "replicaNum", pSyncNode->replicaNum);
+    cJSON* pReplicasId = cJSON_CreateArray();
+    cJSON_AddItemToObject(pRoot, "replicasId", pReplicasId);
+    for (int32_t i = 0; i < pSyncNode->replicaNum; ++i) {
+      cJSON_AddItemToArray(pReplicasId, syncUtilRaftId2Json(&pSyncNode->replicasId[i]));
+    }
+
+    // raft algorithm
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->pFsm);
+    cJSON_AddStringToObject(pRoot, "pFsm", u64buf);
+    cJSON_AddNumberToObject(pRoot, "quorum", pSyncNode->quorum);
+    cJSON* pLaderCache = syncUtilRaftId2Json(&pSyncNode->leaderCache);
+    cJSON_AddItemToObject(pRoot, "leaderCache", pLaderCache);
+
+    // life cycle
+    snprintf(u64buf, sizeof(u64buf), "%" PRId64, pSyncNode->rid);
+    cJSON_AddStringToObject(pRoot, "rid", u64buf);
+
+    // tla+ server vars
+    cJSON_AddNumberToObject(pRoot, "state", pSyncNode->state);
+    cJSON_AddStringToObject(pRoot, "state_str", syncStr(pSyncNode->state));
+    cJSON_AddItemToObject(pRoot, "pRaftStore", raftStore2Json(pSyncNode->pRaftStore));
+
+    // tla+ candidate vars
+    cJSON_AddItemToObject(pRoot, "pVotesGranted", voteGranted2Json(pSyncNode->pVotesGranted));
+    cJSON_AddItemToObject(pRoot, "pVotesRespond", votesRespond2Json(pSyncNode->pVotesRespond));
+
+    // tla+ leader vars
+    cJSON_AddItemToObject(pRoot, "pNextIndex", syncIndexMgr2Json(pSyncNode->pNextIndex));
+    cJSON_AddItemToObject(pRoot, "pMatchIndex", syncIndexMgr2Json(pSyncNode->pMatchIndex));
+
+    // tla+ log vars
+    cJSON_AddItemToObject(pRoot, "pLogStore", logStore2Json(pSyncNode->pLogStore));
+    snprintf(u64buf, sizeof(u64buf), "%" PRId64, pSyncNode->commitIndex);
+    cJSON_AddStringToObject(pRoot, "commitIndex", u64buf);
+
+    // timer ms init
+    cJSON_AddNumberToObject(pRoot, "pingBaseLine", pSyncNode->pingBaseLine);
+    cJSON_AddNumberToObject(pRoot, "electBaseLine", pSyncNode->electBaseLine);
+    cJSON_AddNumberToObject(pRoot, "hbBaseLine", pSyncNode->hbBaseLine);
+
+    // ping timer
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->pPingTimer);
+    cJSON_AddStringToObject(pRoot, "pPingTimer", u64buf);
+    cJSON_AddNumberToObject(pRoot, "pingTimerMS", pSyncNode->pingTimerMS);
+    snprintf(u64buf, sizeof(u64buf), "%" PRId64, pSyncNode->pingTimerLogicClock);
+    cJSON_AddStringToObject(pRoot, "pingTimerLogicClock", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%" PRId64, pSyncNode->pingTimerLogicClockUser);
+    cJSON_AddStringToObject(pRoot, "pingTimerLogicClockUser", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpPingTimerCB);
+    cJSON_AddStringToObject(pRoot, "FpPingTimerCB", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%" PRId64, pSyncNode->pingTimerCounter);
+    cJSON_AddStringToObject(pRoot, "pingTimerCounter", u64buf);
+
+    // elect timer
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->pElectTimer);
+    cJSON_AddStringToObject(pRoot, "pElectTimer", u64buf);
+    cJSON_AddNumberToObject(pRoot, "electTimerMS", pSyncNode->electTimerMS);
+    snprintf(u64buf, sizeof(u64buf), "%" PRId64, pSyncNode->electTimerLogicClock);
+    cJSON_AddStringToObject(pRoot, "electTimerLogicClock", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpElectTimerCB);
+    cJSON_AddStringToObject(pRoot, "FpElectTimerCB", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%" PRId64, pSyncNode->electTimerCounter);
+    cJSON_AddStringToObject(pRoot, "electTimerCounter", u64buf);
+
+    // heartbeat timer
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->pHeartbeatTimer);
+    cJSON_AddStringToObject(pRoot, "pHeartbeatTimer", u64buf);
+    cJSON_AddNumberToObject(pRoot, "heartbeatTimerMS", pSyncNode->heartbeatTimerMS);
+    snprintf(u64buf, sizeof(u64buf), "%" PRId64, pSyncNode->heartbeatTimerLogicClock);
+    cJSON_AddStringToObject(pRoot, "heartbeatTimerLogicClock", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%" PRId64, pSyncNode->heartbeatTimerLogicClockUser);
+    cJSON_AddStringToObject(pRoot, "heartbeatTimerLogicClockUser", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpHeartbeatTimerCB);
+    cJSON_AddStringToObject(pRoot, "FpHeartbeatTimerCB", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%" PRId64, pSyncNode->heartbeatTimerCounter);
+    cJSON_AddStringToObject(pRoot, "heartbeatTimerCounter", u64buf);
+
+    // callback
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpOnPing);
+    cJSON_AddStringToObject(pRoot, "FpOnPing", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpOnPingReply);
+    cJSON_AddStringToObject(pRoot, "FpOnPingReply", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpOnRequestVote);
+    cJSON_AddStringToObject(pRoot, "FpOnRequestVote", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpOnRequestVoteReply);
+    cJSON_AddStringToObject(pRoot, "FpOnRequestVoteReply", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpOnAppendEntries);
+    cJSON_AddStringToObject(pRoot, "FpOnAppendEntries", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpOnAppendEntriesReply);
+    cJSON_AddStringToObject(pRoot, "FpOnAppendEntriesReply", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%p", pSyncNode->FpOnTimeout);
+    cJSON_AddStringToObject(pRoot, "FpOnTimeout", u64buf);
+
+    // restoreFinish
+    cJSON_AddNumberToObject(pRoot, "restoreFinish", pSyncNode->restoreFinish);
+
+    // snapshot senders
+    cJSON* pSenders = cJSON_CreateArray();
+    cJSON_AddItemToObject(pRoot, "senders", pSenders);
+    for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
+      cJSON_AddItemToArray(pSenders, snapshotSender2Json((pSyncNode->senders)[i]));
+    }
+
+    // snapshot receivers
+    cJSON* pReceivers = cJSON_CreateArray();
+    cJSON_AddItemToObject(pRoot, "receiver", snapshotReceiver2Json(pSyncNode->pNewNodeReceiver));
+
+    // changing
+    cJSON_AddNumberToObject(pRoot, "changing", pSyncNode->changing);
+  }
+
+  cJSON* pJson = cJSON_CreateObject();
+  cJSON_AddItemToObject(pJson, "SSyncNode", pRoot);
+  return pJson;
+}
+
+char* syncNode2Str(const SSyncNode* pSyncNode) {
+  cJSON* pJson = syncNode2Json(pSyncNode);
+  char*  serialized = cJSON_Print(pJson);
+  cJSON_Delete(pJson);
+  return serialized;
+}
+
+inline char* syncNode2SimpleStr(const SSyncNode* pSyncNode) {
+  int32_t len = 256;
+  char*   s = (char*)taosMemoryMalloc(len);
+
+  SSnapshot snapshot = {.data = NULL, .lastApplyIndex = -1, .lastApplyTerm = 0};
+  if (pSyncNode->pFsm->FpGetSnapshotInfo != NULL) {
+    pSyncNode->pFsm->FpGetSnapshotInfo(pSyncNode->pFsm, &snapshot);
+  }
+  SyncIndex logLastIndex = pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore);
+  SyncIndex logBeginIndex = pSyncNode->pLogStore->syncLogBeginIndex(pSyncNode->pLogStore);
+
+  snprintf(s, len,
+           "vgId:%d, sync %s, tm:%" PRId64 ", cmt:%" PRId64 ", fst:%" PRId64 ", lst:%" PRId64 ", snap:%" PRId64
+           ", sby:%d, "
+           "r-num:%d, "
+           "lcfg:%" PRId64 ", chging:%d, rsto:%d",
+           pSyncNode->vgId, syncStr(pSyncNode->state), pSyncNode->pRaftStore->currentTerm, pSyncNode->commitIndex,
+           logBeginIndex, logLastIndex, snapshot.lastApplyIndex, pSyncNode->pRaftCfg->isStandBy, pSyncNode->replicaNum,
+           pSyncNode->pRaftCfg->lastConfigIndex, pSyncNode->changing, pSyncNode->restoreFinish);
+
+  return s;
+}
+
+// ping --------------
+int32_t syncNodePing(SSyncNode* pSyncNode, const SRaftId* destRaftId, SyncPing* pMsg) {
+  syncPingLog2((char*)"==syncNodePing==", pMsg);
+  int32_t ret = 0;
+
+  SRpcMsg rpcMsg;
+  syncPing2RpcMsg(pMsg, &rpcMsg);
+  syncRpcMsgLog2((char*)"==syncNodePing==", &rpcMsg);
+
+  ret = syncNodeSendMsgById(destRaftId, pSyncNode, &rpcMsg);
+  return ret;
+}
+
+int32_t syncNodePingSelf(SSyncNode* pSyncNode) {
+  int32_t   ret = 0;
+  SyncPing* pMsg = syncPingBuild3(&pSyncNode->myRaftId, &pSyncNode->myRaftId, pSyncNode->vgId);
+  ret = syncNodePing(pSyncNode, &pMsg->destId, pMsg);
+  ASSERT(ret == 0);
+
+  syncPingDestroy(pMsg);
+  return ret;
+}
+
+int32_t syncNodePingPeers(SSyncNode* pSyncNode) {
+  int32_t ret = 0;
+  for (int32_t i = 0; i < pSyncNode->peersNum; ++i) {
+    SRaftId*  destId = &(pSyncNode->peersId[i]);
+    SyncPing* pMsg = syncPingBuild3(&pSyncNode->myRaftId, destId, pSyncNode->vgId);
+    ret = syncNodePing(pSyncNode, destId, pMsg);
+    ASSERT(ret == 0);
+    syncPingDestroy(pMsg);
+  }
+  return ret;
+}
+
+int32_t syncNodePingAll(SSyncNode* pSyncNode) {
+  int32_t ret = 0;
+  for (int32_t i = 0; i < pSyncNode->pRaftCfg->cfg.replicaNum; ++i) {
+    SRaftId*  destId = &(pSyncNode->replicasId[i]);
+    SyncPing* pMsg = syncPingBuild3(&pSyncNode->myRaftId, destId, pSyncNode->vgId);
+    ret = syncNodePing(pSyncNode, destId, pMsg);
+    ASSERT(ret == 0);
+    syncPingDestroy(pMsg);
+  }
+  return ret;
+}
+

source/libs/sync/test/sync_test_lib/src/syncRaftCfgDebug.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 "syncTest.h"
+
+

source/libs/sync/test/sync_test_lib/src/syncRaftEntryDebug.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 "syncTest.h"
+
+cJSON* syncEntry2Json(const SSyncRaftEntry* pEntry) {
+  char   u64buf[128] = {0};
+  cJSON* pRoot = cJSON_CreateObject();
+
+  if (pEntry != NULL) {
+    cJSON_AddNumberToObject(pRoot, "bytes", pEntry->bytes);
+    cJSON_AddNumberToObject(pRoot, "msgType", pEntry->msgType);
+    cJSON_AddNumberToObject(pRoot, "originalRpcType", pEntry->originalRpcType);
+    snprintf(u64buf, sizeof(u64buf), "%" PRIu64, pEntry->seqNum);
+    cJSON_AddStringToObject(pRoot, "seqNum", u64buf);
+    cJSON_AddNumberToObject(pRoot, "isWeak", pEntry->isWeak);
+    snprintf(u64buf, sizeof(u64buf), "%" PRIu64, pEntry->term);
+    cJSON_AddStringToObject(pRoot, "term", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%" PRIu64, pEntry->index);
+    cJSON_AddStringToObject(pRoot, "index", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%" PRIu64, pEntry->rid);
+    cJSON_AddStringToObject(pRoot, "rid", u64buf);
+    cJSON_AddNumberToObject(pRoot, "dataLen", pEntry->dataLen);
+
+    char* s;
+    s = syncUtilPrintBin((char*)(pEntry->data), pEntry->dataLen);
+    cJSON_AddStringToObject(pRoot, "data", s);
+    taosMemoryFree(s);
+
+    s = syncUtilPrintBin2((char*)(pEntry->data), pEntry->dataLen);
+    cJSON_AddStringToObject(pRoot, "data2", s);
+    taosMemoryFree(s);
+  }
+
+  cJSON* pJson = cJSON_CreateObject();
+  cJSON_AddItemToObject(pJson, "SSyncRaftEntry", pRoot);
+  return pJson;
+}
+
+char* syncEntry2Str(const SSyncRaftEntry* pEntry) {
+  cJSON* pJson = syncEntry2Json(pEntry);
+  char*  serialized = cJSON_Print(pJson);
+  cJSON_Delete(pJson);
+  return serialized;
+}
+
+// for debug ----------------------
+void syncEntryPrint(const SSyncRaftEntry* pObj) {
+  char* serialized = syncEntry2Str(pObj);
+  printf("syncEntryPrint | len:%zu | %s \n", strlen(serialized), serialized);
+  fflush(NULL);
+  taosMemoryFree(serialized);
+}
+
+void syncEntryPrint2(char* s, const SSyncRaftEntry* pObj) {
+  char* serialized = syncEntry2Str(pObj);
+  printf("syncEntryPrint2 | len:%zu | %s | %s \n", strlen(serialized), s, serialized);
+  fflush(NULL);
+  taosMemoryFree(serialized);
+}
+
+void syncEntryLog(const SSyncRaftEntry* pObj) {
+  char* serialized = syncEntry2Str(pObj);
+  sTrace("syncEntryLog | len:%zu | %s", strlen(serialized), serialized);
+  taosMemoryFree(serialized);
+}
+
+void syncEntryLog2(char* s, const SSyncRaftEntry* pObj) {
+  char* serialized = syncEntry2Str(pObj);
+  sTrace("syncEntryLog2 | len:%zu | %s | %s", strlen(serialized), s, serialized);
+  taosMemoryFree(serialized);
+}
+
+//-----------------------------------
+cJSON* raftCache2Json(SRaftEntryHashCache* pCache) {
+  char   u64buf[128] = {0};
+  cJSON* pRoot = cJSON_CreateObject();
+
+  if (pCache != NULL) {
+    taosThreadMutexLock(&pCache->mutex);
+
+    snprintf(u64buf, sizeof(u64buf), "%p", pCache->pSyncNode);
+    cJSON_AddStringToObject(pRoot, "pSyncNode", u64buf);
+    cJSON_AddNumberToObject(pRoot, "currentCount", pCache->currentCount);
+    cJSON_AddNumberToObject(pRoot, "maxCount", pCache->maxCount);
+    cJSON* pEntries = cJSON_CreateArray();
+    cJSON_AddItemToObject(pRoot, "entries", pEntries);
+
+    SSyncRaftEntry* pIter = (SSyncRaftEntry*)taosHashIterate(pCache->pEntryHash, NULL);
+    if (pIter != NULL) {
+      SSyncRaftEntry* pEntry = (SSyncRaftEntry*)pIter;
+      cJSON_AddItemToArray(pEntries, syncEntry2Json(pEntry));
+    }
+    while (pIter) {
+      pIter = taosHashIterate(pCache->pEntryHash, pIter);
+      if (pIter != NULL) {
+        SSyncRaftEntry* pEntry = (SSyncRaftEntry*)pIter;
+        cJSON_AddItemToArray(pEntries, syncEntry2Json(pEntry));
+      }
+    }
+
+    taosThreadMutexUnlock(&pCache->mutex);
+  }
+
+  cJSON* pJson = cJSON_CreateObject();
+  cJSON_AddItemToObject(pJson, "SRaftEntryHashCache", pRoot);
+  return pJson;
+}
+
+char* raftCache2Str(SRaftEntryHashCache* pCache) {
+  cJSON* pJson = raftCache2Json(pCache);
+  char*  serialized = cJSON_Print(pJson);
+  cJSON_Delete(pJson);
+  return serialized;
+}
+
+void raftCachePrint(SRaftEntryHashCache* pCache) {
+  char* serialized = raftCache2Str(pCache);
+  printf("raftCachePrint | len:%d | %s \n", (int32_t)strlen(serialized), serialized);
+  fflush(NULL);
+  taosMemoryFree(serialized);
+}
+
+void raftCachePrint2(char* s, SRaftEntryHashCache* pCache) {
+  char* serialized = raftCache2Str(pCache);
+  printf("raftCachePrint2 | len:%d | %s | %s \n", (int32_t)strlen(serialized), s, serialized);
+  fflush(NULL);
+  taosMemoryFree(serialized);
+}
+
+void raftCacheLog(SRaftEntryHashCache* pCache) {
+  char* serialized = raftCache2Str(pCache);
+  sTrace("raftCacheLog | len:%d | %s", (int32_t)strlen(serialized), serialized);
+  taosMemoryFree(serialized);
+}
+
+void raftCacheLog2(char* s, SRaftEntryHashCache* pCache) {
+  if (gRaftDetailLog) {
+    char* serialized = raftCache2Str(pCache);
+    sLTrace("raftCacheLog2 | len:%d | %s | %s", (int32_t)strlen(serialized), s, serialized);
+    taosMemoryFree(serialized);
+  }
+}
+
+cJSON* raftEntryCache2Json(SRaftEntryCache* pCache) {
+  char   u64buf[128] = {0};
+  cJSON* pRoot = cJSON_CreateObject();
+
+  if (pCache != NULL) {
+    taosThreadMutexLock(&pCache->mutex);
+
+    snprintf(u64buf, sizeof(u64buf), "%p", pCache->pSyncNode);
+    cJSON_AddStringToObject(pRoot, "pSyncNode", u64buf);
+    cJSON_AddNumberToObject(pRoot, "currentCount", pCache->currentCount);
+    cJSON_AddNumberToObject(pRoot, "maxCount", pCache->maxCount);
+    cJSON* pEntries = cJSON_CreateArray();
+    cJSON_AddItemToObject(pRoot, "entries", pEntries);
+
+    SSkipListIterator* pIter = tSkipListCreateIter(pCache->pSkipList);
+    while (tSkipListIterNext(pIter)) {
+      SSkipListNode* pNode = tSkipListIterGet(pIter);
+      ASSERT(pNode != NULL);
+      SSyncRaftEntry* pEntry = (SSyncRaftEntry*)SL_GET_NODE_DATA(pNode);
+      cJSON_AddItemToArray(pEntries, syncEntry2Json(pEntry));
+    }
+    tSkipListDestroyIter(pIter);
+
+    taosThreadMutexUnlock(&pCache->mutex);
+  }
+
+  cJSON* pJson = cJSON_CreateObject();
+  cJSON_AddItemToObject(pJson, "SRaftEntryCache", pRoot);
+  return pJson;
+}
+
+char* raftEntryCache2Str(SRaftEntryCache* pObj) {
+  cJSON* pJson = raftEntryCache2Json(pObj);
+  char*  serialized = cJSON_Print(pJson);
+  cJSON_Delete(pJson);
+  return serialized;
+}
+
+void raftEntryCachePrint(SRaftEntryCache* pObj) {
+  char* serialized = raftEntryCache2Str(pObj);
+  printf("raftEntryCachePrint | len:%d | %s \n", (int32_t)strlen(serialized), serialized);
+  fflush(NULL);
+  taosMemoryFree(serialized);
+}
+
+void raftEntryCachePrint2(char* s, SRaftEntryCache* pObj) {
+  char* serialized = raftEntryCache2Str(pObj);
+  printf("raftEntryCachePrint2 | len:%d | %s | %s \n", (int32_t)strlen(serialized), s, serialized);
+  fflush(NULL);
+  taosMemoryFree(serialized);
+}
+
+void raftEntryCacheLog(SRaftEntryCache* pObj) {
+  char* serialized = raftEntryCache2Str(pObj);
+  sTrace("raftEntryCacheLog | len:%d | %s", (int32_t)strlen(serialized), serialized);
+  taosMemoryFree(serialized);
+}
+
+void raftEntryCacheLog2(char* s, SRaftEntryCache* pObj) {
+  if (gRaftDetailLog) {
+    char* serialized = raftEntryCache2Str(pObj);
+    sLTrace("raftEntryCacheLog2 | len:%d | %s | %s", (int32_t)strlen(serialized), s, serialized);
+    taosMemoryFree(serialized);
+  }
+}

source/util/src/tlog.c

@@ -317,14 +317,14 @@ static void taosGetLogFileName(char *fn) {
     for (int32_t i = 0; i < tsLogObj.fileNum; i++) {
       char fileName[LOG_FILE_NAME_LEN];
 
-      snprintf(fileName, LOG_FILE_NAME_LEN,"%s%d.0", fn, i);
+      snprintf(fileName, LOG_FILE_NAME_LEN, "%s%d.0", fn, i);
       bool file1open = taosCheckFileIsOpen(fileName);
 
-      snprintf(fileName, LOG_FILE_NAME_LEN,"%s%d.1", fn, i);
+      snprintf(fileName, LOG_FILE_NAME_LEN, "%s%d.1", fn, i);
       bool file2open = taosCheckFileIsOpen(fileName);
 
       if (!file1open && !file2open) {
-        snprintf(tsLogObj.logName, tListLen(tsLogObj.logName), "%s%d", fn, i);
+        snprintf(tsLogObj.logName, LOG_FILE_NAME_LEN, "%s%d", fn, i);
         return;
       }
     }
@@ -598,7 +598,7 @@ static int32_t taosPushLogBuffer(SLogBuff *pLogBuf, const char *msg, int32_t msg
   remainSize = (start > end) ? (start - end - 1) : (start + LOG_BUF_SIZE(pLogBuf) - end - 1);
 
   if (lostLine > 0) {
-    sprintf(tmpBuf, "...Lost %" PRId64 " lines here...\n", lostLine);
+    snprintf(tmpBuf, tListLen(tmpBuf), "...Lost %" PRId64 " lines here...\n", lostLine);
     tmpBufLen = (int32_t)strlen(tmpBuf);
   }