Merge remote-tracking branch 'origin/3.0' into feature/qnode

cmake/libuv_CMakeLists.txt.in

@@ -4,7 +4,7 @@ ExternalProject_Add(libuv
         GIT_REPOSITORY https://github.com/libuv/libuv.git
         GIT_TAG v1.42.0
         SOURCE_DIR "${CMAKE_CONTRIB_DIR}/libuv"
-        BINARY_DIR ""
+        BINARY_DIR "${CMAKE_CONTRIB_DIR}/libuv"
         CONFIGURE_COMMAND "" 
         BUILD_COMMAND ""  
         INSTALL_COMMAND ""

include/dnode/bnode/bnode.h

@@ -23,9 +23,9 @@ extern "C" {
 /* ------------------------ TYPES EXPOSED ------------------------ */
 typedef struct SDnode SDnode;
 typedef struct SBnode SBnode;
-typedef int32_t (*SendReqToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
-typedef int32_t (*SendReqToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
-typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef int32_t (*SendReqToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *pMsg);
+typedef int32_t (*SendReqToMnodeFp)(SDnode *pDnode, struct SRpcMsg *pMsg);
+typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *pMsg);
 
 typedef struct {
   int64_t numOfErrors;
@@ -33,12 +33,8 @@ typedef struct {
 
 typedef struct {
   int32_t           sver;
-} SBnodeCfg;
-
-typedef struct {
   int32_t           dnodeId;
   int64_t           clusterId;
-  SBnodeCfg         cfg;
   SDnode           *pDnode;
   SendReqToDnodeFp  sendReqToDnodeFp;
   SendReqToMnodeFp  sendReqToMnodeFp;

include/dnode/mgmt/dnode.h

@@ -22,15 +22,39 @@
 extern "C" {
 #endif
 
-/* ------------------------ TYPES EXPOSED ------------------------ */
+/* ------------------------ TYPES EXPOSED ---------------- */
 typedef struct SDnode SDnode;
 
+/* ------------------------ Environment ------------------ */
 typedef struct {
   int32_t sver;
   int32_t numOfCores;
-  int32_t  numOfSupportVnodes;
   int16_t numOfCommitThreads;
   int8_t  enableTelem;
+  char    timezone[TSDB_TIMEZONE_LEN];
+  char    locale[TSDB_LOCALE_LEN];
+  char    charset[TSDB_LOCALE_LEN];
+  char    buildinfo[64];
+  char    gitinfo[48];
+} SDnodeEnvCfg;
+
+/**
+ * @brief Initialize the environment
+ *
+ * @param pOption Option of the environment
+ * @return int32_t 0 for success and -1 for failure
+ */
+int32_t dndInit(const SDnodeEnvCfg *pCfg);
+
+/**
+ * @brief clear the environment
+ *
+ */
+void dndCleanup();
+
+/* ------------------------ SDnode ----------------------- */
+typedef struct {
+  int32_t  numOfSupportVnodes;
   int32_t  statusInterval;
   float    numOfThreadsPerCore;
   float    ratioOfQueryCores;
@@ -41,28 +65,22 @@ typedef struct {
   char     localEp[TSDB_EP_LEN];
   char     localFqdn[TSDB_FQDN_LEN];
   char     firstEp[TSDB_EP_LEN];
-  char     timezone[TSDB_TIMEZONE_LEN];
-  char     locale[TSDB_LOCALE_LEN];
-  char     charset[TSDB_LOCALE_LEN];
-  char     buildinfo[64];
-  char     gitinfo[48];
-} SDnodeOpt;
+} SDnodeObjCfg;
 
-/* ------------------------ SDnode ------------------------ */
 /**
  * @brief Initialize and start the dnode.
  *
- * @param pOption Option of the dnode.
+ * @param pCfg Config of the dnode.
  * @return SDnode* The dnode object.
  */
-SDnode *dndInit(SDnodeOpt *pOption);
+SDnode *dndCreate(SDnodeObjCfg *pCfg);
 
 /**
  * @brief Stop and cleanup the dnode.
  *
  * @param pDnode The dnode object to close.
  */
-void dndCleanup(SDnode *pDnode);
+void dndClose(SDnode *pDnode);
 
 #ifdef __cplusplus
 }

include/dnode/qnode/qnode.h

@@ -23,9 +23,9 @@ extern "C" {
 /* ------------------------ TYPES EXPOSED ------------------------ */
 typedef struct SDnode SDnode;
 typedef struct SQnode SQnode;
-typedef int32_t (*SendReqToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
-typedef int32_t (*SendReqToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
-typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef int32_t (*SendReqToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *pMsg);
+typedef int32_t (*SendReqToMnodeFp)(SDnode *pDnode, struct SRpcMsg *pMsg);
+typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *pMsg);
 
 typedef struct {
   int64_t numOfStartTask;
@@ -40,12 +40,8 @@ typedef struct {
 
 typedef struct {
   int32_t           sver;
-} SQnodeCfg;
-
-typedef struct {
   int32_t           dnodeId;
   int64_t           clusterId;
-  SQnodeCfg         cfg;
   SDnode           *pDnode;
   SendReqToDnodeFp  sendReqToDnodeFp;
   SendReqToMnodeFp  sendReqToMnodeFp;

include/dnode/snode/snode.h

@@ -23,9 +23,9 @@ extern "C" {
 /* ------------------------ TYPES EXPOSED ------------------------ */
 typedef struct SDnode SDnode;
 typedef struct SSnode SSnode;
-typedef int32_t (*SendReqToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
-typedef int32_t (*SendReqToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
-typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef int32_t (*SendReqToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *pMsg);
+typedef int32_t (*SendReqToMnodeFp)(SDnode *pDnode, struct SRpcMsg *pMsg);
+typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *pMsg);
 
 typedef struct {
   int64_t numOfErrors;
@@ -33,12 +33,8 @@ typedef struct {
 
 typedef struct {
   int32_t           sver;
-} SSnodeCfg;
-
-typedef struct {
   int32_t           dnodeId;
   int64_t           clusterId;
-  SSnodeCfg         cfg;
   SDnode           *pDnode;
   SendReqToDnodeFp  sendReqToDnodeFp;
   SendReqToMnodeFp  sendReqToMnodeFp;

include/libs/parser/parsenodes.h

@@ -43,15 +43,6 @@ typedef struct SField {
   int32_t  bytes;
 } SField;
 
-typedef struct SParseBasicCtx {
-  uint64_t         requestId;
-  int32_t          acctId;
-  const char      *db;
-  void            *pTransporter;
-  SEpSet           mgmtEpSet;
-  struct SCatalog *pCatalog;
-} SParseBasicCtx;
-
 typedef struct SFieldInfo {
   int16_t     numOfOutput;   // number of column in result
   SField     *final;

include/libs/parser/parser.h

@@ -23,11 +23,17 @@ extern "C" {
 #include "parsenodes.h"
 
 typedef struct SParseContext {
-  SParseBasicCtx   ctx;
+  uint64_t         requestId;
+  int32_t          acctId;
+  const char      *db;
+  void            *pTransporter;
+  SEpSet           mgmtEpSet;
   const char      *pSql;           // sql string
   size_t           sqlLen;         // length of the sql string
   char            *pMsg;           // extended error message if exists to help identifying the problem in sql statement.
   int32_t          msgLen;         // max length of the msg
+
+  struct SCatalog *pCatalog;
 } SParseContext;
 
 /**

include/libs/planner/planner.h

@@ -93,6 +93,8 @@ typedef struct SScanPhyNode {
   SPhyNode    node;
   uint64_t    uid;           // unique id of the table
   int8_t      tableType;
+  int32_t     order;         // scan order: TSDB_ORDER_ASC|TSDB_ORDER_DESC
+  int32_t     count;         // repeat count
 } SScanPhyNode;
 
 typedef SScanPhyNode SSystemTableScanPhyNode;

include/libs/tfs/tfs.h

@@ -49,7 +49,7 @@ typedef struct {
 } STierMeta;
 
 int  tfsInit(SDiskCfg *pDiskCfg, int ndisk);
-void tfsDestroy();
+void tfsCleanup();
 void tfsUpdateInfo(SFSMeta *pFSMeta, STierMeta *tierMetas, int8_t numLevels);
 void tfsGetMeta(SFSMeta *pMeta);
 void tfsAllocDisk(int expLevel, int *level, int *id);

include/libs/tkv/tkv.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_TKV_H_
-#define _TD_TKV_H_
-
-#if 0
-#include "os.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Types exported
-typedef struct STkvDb        STkvDb;
-typedef struct STkvOpts      STkvOpts;
-typedef struct STkvCache     STkvCache;
-typedef struct STkvReadOpts  STkvReadOpts;
-typedef struct STkvWriteOpts STkvWriteOpts;
-
-// DB operations
-STkvDb *tkvOpen(const STkvOpts *options, const char *path);
-void    tkvClose(STkvDb *db);
-void    tkvPut(STkvDb *db, const STkvWriteOpts *, const char *key, size_t keylen, const char *val, size_t vallen);
-char *  tkvGet(STkvDb *db, const STkvReadOpts *, const char *key, size_t keylen, size_t *vallen);
-void    tkvCommit(STkvDb *db);
-
-// DB options
-STkvOpts *tkvOptsCreate();
-void      tkvOptsDestroy(STkvOpts *);
-void      tkvOptionsSetCache(STkvOpts *, STkvCache *);
-void      tkvOptsSetCreateIfMissing(STkvOpts *, unsigned char);
-
-// DB cache
-typedef enum { TKV_LRU_CACHE = 0, TKV_LFU_CACHE = 1 } ETkvCacheType;
-STkvCache *tkvCacheCreate(size_t capacity, ETkvCacheType type);
-void       tkvCacheDestroy(STkvCache *);
-
-// STkvReadOpts
-STkvReadOpts *tkvReadOptsCreate();
-void          tkvReadOptsDestroy(STkvReadOpts *);
-
-// STkvWriteOpts
-STkvWriteOpts *tkvWriteOptsCreate();
-void           tkvWriteOptsDestroy(STkvWriteOpts *);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-#endif /*_TD_TKV_H_*/
\ No newline at end of file

include/util/taoserror.h

@@ -70,6 +70,8 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_INVALID_MSG                   TAOS_DEF_ERROR_CODE(0, 0x0108)
 #define TSDB_CODE_MSG_NOT_PROCESSED             TAOS_DEF_ERROR_CODE(0, 0x0109)
 #define TSDB_CODE_INVALID_PARA                  TAOS_DEF_ERROR_CODE(0, 0x010A)
+#define TSDB_CODE_REPEAT_INIT                   TAOS_DEF_ERROR_CODE(0, 0x010B)
+
 #define TSDB_CODE_REF_NO_MEMORY                 TAOS_DEF_ERROR_CODE(0, 0x0110)
 #define TSDB_CODE_REF_FULL                      TAOS_DEF_ERROR_CODE(0, 0x0111)
 #define TSDB_CODE_REF_ID_REMOVED                TAOS_DEF_ERROR_CODE(0, 0x0112)

include/util/tarray.h

@@ -23,6 +23,19 @@ extern "C" {
 #include "os.h"
 #include "talgo.h"
 
+#if 0
+#define TARRAY(TYPE)             \
+  struct {                       \
+    int32_t      tarray_size_;   \
+    int32_t      tarray_neles_;  \
+    struct TYPE* td_array_data_; \
+  }
+
+#define TARRAY_SIZE(ARRAY) (ARRAY)->tarray_size_
+#define TARRAY_NELES(ARRAY) (ARRAY)->tarray_neles_
+#define TARRAY_ELE_AT(ARRAY, IDX) ((ARRAY)->td_array_data_ + idx)
+#endif
+
 #define TARRAY_MIN_SIZE 8
 #define TARRAY_GET_ELEM(array, index) ((void*)((char*)((array)->pData) + (index) * (array)->elemSize))
 #define TARRAY_ELEM_IDX(array, ele) (POINTER_DISTANCE(ele, (array)->pData) / (array)->elemSize)
@@ -57,7 +70,7 @@ int32_t taosArrayEnsureCap(SArray* pArray, size_t tsize);
  * @param nEles
  * @return
  */
-void *taosArrayAddBatch(SArray *pArray, const void *pData, int nEles);
+void* taosArrayAddBatch(SArray* pArray, const void* pData, int nEles);
 
 /**
  *
@@ -65,7 +78,7 @@ void *taosArrayAddBatch(SArray *pArray, const void *pData, int nEles);
  * @param pData           position array list
  * @param numOfElems      the number of removed position
  */
-void taosArrayRemoveBatch(SArray *pArray, const int32_t* pData, int32_t numOfElems);
+void taosArrayRemoveBatch(SArray* pArray, const int32_t* pData, int32_t numOfElems);
 
 /**
  *
@@ -73,7 +86,7 @@ void taosArrayRemoveBatch(SArray *pArray, const int32_t* pData, int32_t numOfEle
  * @param comparFn
  * @param fp
  */
-void taosArrayRemoveDuplicate(SArray *pArray, __compar_fn_t comparFn, void (*fp)(void*));
+void taosArrayRemoveDuplicate(SArray* pArray, __compar_fn_t comparFn, void (*fp)(void*));
 
 /**
  *  add all element from the source array list into the destination
@@ -242,7 +255,6 @@ int32_t taosArraySearchIdx(const SArray* pArray, const void* key, __compar_fn_t
  */
 char* taosArraySearchString(const SArray* pArray, const char* key, __compar_fn_t comparFn, int flags);
 
-
 /**
  * sort the pointer data in the array
  * @param pArray
@@ -251,7 +263,7 @@ char* taosArraySearchString(const SArray* pArray, const char* key, __compar_fn_t
  * @return
  */
 
-void taosArraySortPWithExt(SArray* pArray, __ext_compar_fn_t fn, const void *param);
+void taosArraySortPWithExt(SArray* pArray, __ext_compar_fn_t fn, const void* param);
 
 #ifdef __cplusplus
 }

source/client/inc/clientInt.h

@@ -93,13 +93,12 @@ typedef struct SReqResultInfo {
   const char  *pData;
   TAOS_FIELD  *fields;
   uint32_t     numOfCols;
-
   int32_t     *length;
   TAOS_ROW     row;
   char       **pCol;
-
   uint32_t     numOfRows;
   uint32_t     current;
+  bool         completed;
 } SReqResultInfo;
 
 typedef struct SShowReqInfo {
@@ -130,7 +129,6 @@ typedef struct SRequestObj {
   char            *msgBuf;
   void            *pInfo;   // sql parse info, generated by parser module
   int32_t          code;
-  uint64_t         affectedRows;  // todo remove it
   SQueryExecMetric metric;
   SRequestSendRecvBody body;
 } SRequestObj;

source/client/src/clientImpl.c

@@ -25,8 +25,9 @@
 static int32_t initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSet);
 static SMsgSendInfo* buildConnectMsg(SRequestObj *pRequest);
 static void destroySendMsgInfo(SMsgSendInfo* pMsgBody);
+static void setQueryResultByRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp);
 
-static bool stringLengthCheck(const char* str, size_t maxsize) {
+  static bool stringLengthCheck(const char* str, size_t maxsize) {
   if (str == NULL) {
     return false;
   }
@@ -150,23 +151,26 @@ int32_t parseSql(SRequestObj* pRequest, SQueryNode** pQuery) {
   STscObj* pTscObj = pRequest->pTscObj;
 
   SParseContext cxt = {
-    .ctx = {.requestId = pRequest->requestId, .acctId = pTscObj->acctId, .db = getConnectionDB(pTscObj), .pTransporter = pTscObj->pTransporter},
+    .requestId = pRequest->requestId,
+    .acctId = pTscObj->acctId,
+    .db     = getConnectionDB(pTscObj),
+    .pTransporter = pTscObj->pTransporter,
     .pSql   = pRequest->sqlstr,
     .sqlLen = pRequest->sqlLen,
     .pMsg   = pRequest->msgBuf,
     .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE
   };
 
-  cxt.ctx.mgmtEpSet = getEpSet_s(&pTscObj->pAppInfo->mgmtEp);
-  int32_t code = catalogGetHandle(pTscObj->pAppInfo->clusterId, &cxt.ctx.pCatalog);
+  cxt.mgmtEpSet = getEpSet_s(&pTscObj->pAppInfo->mgmtEp);
+  int32_t code = catalogGetHandle(pTscObj->pAppInfo->clusterId, &cxt.pCatalog);
   if (code != TSDB_CODE_SUCCESS) {
-    tfree(cxt.ctx.db);
+    tfree(cxt.db);
     return code;
   }
 
   code = qParseQuerySql(&cxt, pQuery);
 
-  tfree(cxt.ctx.db);
+  tfree(cxt.db);
   return code;
 }
 
@@ -212,6 +216,7 @@ int32_t getPlan(SRequestObj* pRequest, SQueryNode* pQueryNode, SQueryDag** pDag)
     SSubplan* pPlan = taosArrayGetP(pa, 0);
     SDataBlockSchema* pDataBlockSchema = &(pPlan->pDataSink->schema);
     setResSchemaInfo(pResInfo, pDataBlockSchema);
+
     pRequest->type = TDMT_VND_QUERY;
   }
 
@@ -228,7 +233,7 @@ void setResSchemaInfo(SReqResultInfo* pResInfo, const SDataBlockSchema* pDataBlo
     SSchema* pSchema = &pDataBlockSchema->pSchema[i];
     pResInfo->fields[i].bytes = pSchema->bytes;
     pResInfo->fields[i].type  = pSchema->type;
-    tstrncpy(pResInfo->fields[i].name, pSchema[i].name, tListLen(pResInfo->fields[i].name));
+    tstrncpy(pResInfo->fields[i].name, pSchema->name, tListLen(pResInfo->fields[i].name));
   }
 }
 
@@ -245,8 +250,9 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag) {
       }
     }
 
-    pRequest->affectedRows = res.numOfRows;
-    return res.code;
+    pRequest->body.resInfo.numOfRows = res.numOfRows;
+    pRequest->code = res.code;
+    return pRequest->code;
   }
 
   return scheduleAsyncExecJob(pRequest->pTscObj->pTransporter, NULL, pDag, &pRequest->body.pQueryJob);
@@ -545,11 +551,15 @@ void* doFetchRow(SRequestObj* pRequest) {
 
   if (pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) {
     if (pRequest->type == TDMT_VND_QUERY) {
-      pRequest->type = TDMT_VND_FETCH;
+      // All data has returned to App already, no need to try again
+      if (pResultInfo->completed) {
+        return NULL;
+      }
+
       scheduleFetchRows(pRequest->body.pQueryJob, (void **)&pRequest->body.resInfo.pData);
+      setQueryResultByRsp(&pRequest->body.resInfo, (SRetrieveTableRsp*)pRequest->body.resInfo.pData);
 
-      pResultInfo->current = 0;
-      if (pResultInfo->numOfRows <= pResultInfo->current) {
+      if (pResultInfo->numOfRows == 0) {
         return NULL;
       }
 
@@ -611,12 +621,23 @@ _return:
   return pResultInfo->row;
 }
 
+static void doPrepareResPtr(SReqResultInfo* pResInfo) {
+  if (pResInfo->row == NULL) {
+    pResInfo->row    = calloc(pResInfo->numOfCols, POINTER_BYTES);
+    pResInfo->pCol   = calloc(pResInfo->numOfCols, POINTER_BYTES);
+    pResInfo->length = calloc(pResInfo->numOfCols, sizeof(int32_t));
+  }
+}
+
 void setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows) {
   assert(numOfCols > 0 && pFields != NULL && pResultInfo != NULL);
   if (numOfRows == 0) {
     return;
   }
 
+  // todo check for the failure of malloc
+  doPrepareResPtr(pResultInfo);
+
   int32_t offset = 0;
   for (int32_t i = 0; i < numOfCols; ++i) {
     pResultInfo->length[i] = pResultInfo->fields[i].bytes;
@@ -642,3 +663,14 @@ void setConnectionDB(STscObj* pTscObj, const char* db) {
   pthread_mutex_unlock(&pTscObj->mutex);
 }
 
+void setQueryResultByRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp) {
+  assert(pResultInfo != NULL && pRsp != NULL);
+
+  pResultInfo->pRspMsg   = (const char*) pRsp;
+  pResultInfo->pData     = (void*) pRsp->data;
+  pResultInfo->numOfRows = htonl(pRsp->numOfRows);
+  pResultInfo->current   = 0;
+  pResultInfo->completed = (pRsp->completed == 1);
+
+  setResultDataPtr(pResultInfo, pResultInfo->fields, pResultInfo->numOfCols, pResultInfo->numOfRows);
+}
\ No newline at end of file

source/client/src/clientMain.c

@@ -265,7 +265,13 @@ const char *taos_data_type(int type) {
 const char *taos_get_client_info() { return version; }
 
 int taos_affected_rows(TAOS_RES *res) {
-  return ((SRequestObj*)res)->affectedRows;
+  if (res == NULL) {
+    return 0;
+  }
+
+  SRequestObj* pRequest = (SRequestObj*) res;
+  SReqResultInfo* pResInfo = &pRequest->body.resInfo;
+  return pResInfo->numOfRows;
 }
 
 int taos_result_precision(TAOS_RES *res) { return TSDB_TIME_PRECISION_MILLI; }

source/client/src/clientMsgHandler.c

@@ -154,9 +154,6 @@ int32_t processShowRsp(void* param, const SDataBuf* pMsg, int32_t code) {
 
   pResInfo->fields    = pFields;
   pResInfo->numOfCols = pMetaMsg->numOfColumns;
-  pResInfo->row       = calloc(pResInfo->numOfCols, POINTER_BYTES);
-  pResInfo->pCol      = calloc(pResInfo->numOfCols, POINTER_BYTES);
-  pResInfo->length    = calloc(pResInfo->numOfCols, sizeof(int32_t));
 
   pRequest->body.showInfo.execId = pShow->showId;
 

source/client/test/clientTests.cpp

@@ -279,7 +279,7 @@ TEST(testCase, connect_Test) {
 //  taos_free_result(pRes);
 //  taos_close(pConn);
 //}
-//
+
 //TEST(testCase, create_table_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
@@ -292,26 +292,26 @@ TEST(testCase, connect_Test) {
 //
 //  taos_close(pConn);
 //}
-//
-//TEST(testCase, create_ctable_Test) {
-//  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-//  assert(pConn != NULL);
-//
-//  TAOS_RES* pRes = taos_query(pConn, "use abc1");
-//  if (taos_errno(pRes) != 0) {
-//    printf("failed to use db, reason:%s\n", taos_errstr(pRes));
-//  }
-//  taos_free_result(pRes);
-//
-//  pRes = taos_query(pConn, "create table tm0 using st1 tags(1)");
-//  if (taos_errno(pRes) != 0) {
-//    printf("failed to create child table tm0, reason:%s\n", taos_errstr(pRes));
-//  }
-//
-//  taos_free_result(pRes);
-//  taos_close(pConn);
-//}
-//
+
+TEST(testCase, create_ctable_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to use db, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table tm0 using st1 tags(1)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create child table tm0, reason:%s\n", taos_errstr(pRes));
+  }
+
+  taos_free_result(pRes);
+  taos_close(pConn);
+}
+
 //TEST(testCase, show_stable_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
@@ -533,6 +533,7 @@ TEST(testCase, connect_Test) {
 //  tmq_create_topic(pConn, "test_topic_1", sql, strlen(sql));
 //  taos_close(pConn);
 //}
+
 //TEST(testCase, insert_test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  ASSERT_EQ(pConn, nullptr);
@@ -550,49 +551,48 @@ TEST(testCase, connect_Test) {
 //  taos_free_result(pRes);
 //  taos_close(pConn);
 //}
-//#endif
 
-TEST(testCase, projection_query_tables) {
-  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  ASSERT_NE(pConn, nullptr);
-
-//  TAOS_RES* pRes = taos_query(pConn, "create database abc1 vgroups 2");
+//TEST(testCase, projection_query_tables) {
+//  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+//  ASSERT_NE(pConn, nullptr);
+//
+////  TAOS_RES* pRes = taos_query(pConn, "create database abc1 vgroups 2");
+////  if (taos_errno(pRes) != 0) {
+////    printf("failed to use db, reason:%s\n", taos_errstr(pRes));
+////    taos_free_result(pRes);
+////    return;
+////  }
+//
+////  taos_free_result(pRes);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+//
+////  pRes = taos_query(pConn, "create table m1 (ts timestamp,  k int) tags(a int)");
+//  taos_free_result(pRes);
+////
+////  pRes = taos_query(pConn, "create table tu using m1 tags(1)");
+////  taos_free_result(pRes);
+////
+////  pRes = taos_query(pConn, "insert into tu values(now, 1)");
+////  taos_free_result(pRes);
+//
+//  pRes = taos_query(pConn, "select * from tu");
 //  if (taos_errno(pRes) != 0) {
-//    printf("failed to use db, reason:%s\n", taos_errstr(pRes));
+//    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
 //    taos_free_result(pRes);
-//    return;
+//    ASSERT_TRUE(false);
 //  }
-
-//  taos_free_result(pRes);
-
-  TAOS_RES* pRes = taos_query(pConn, "use abc1");
-
-//  pRes = taos_query(pConn, "create table m1 (ts timestamp,  k int) tags(a int)");
-  taos_free_result(pRes);
 //
-//  pRes = taos_query(pConn, "create table tu using m1 tags(1)");
-//  taos_free_result(pRes);
+//  TAOS_ROW    pRow = NULL;
+//  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+//  int32_t     numOfFields = taos_num_fields(pRes);
+//
+//  char str[512] = {0};
+//  while ((pRow = taos_fetch_row(pRes)) != NULL) {
+//    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
+//    printf("%s\n", str);
+//  }
 //
-//  pRes = taos_query(pConn, "insert into tu values(now, 1)");
 //  taos_free_result(pRes);
-
-  pRes = taos_query(pConn, "select * from tu");
-  if (taos_errno(pRes) != 0) {
-    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
-    taos_free_result(pRes);
-    ASSERT_TRUE(false);
-  }
-
-  TAOS_ROW    pRow = NULL;
-  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  int32_t     numOfFields = taos_num_fields(pRes);
-
-  char str[512] = {0};
-  while ((pRow = taos_fetch_row(pRes)) != NULL) {
-    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
-    printf("%s\n", str);
-  }
-
-  taos_free_result(pRes);
-  taos_close(pConn);
-}
+//  taos_close(pConn);
+//}

source/dnode/bnode/inc/bndInt.h

@@ -30,12 +30,7 @@ extern "C" {
 #endif
 
 typedef struct SBnode {
-  int32_t           dnodeId;
-  int64_t           clusterId;
-  SBnodeCfg         cfg;
-  SendReqToDnodeFp  sendReqToDnodeFp;
-  SendReqToMnodeFp  sendReqToMnodeFp;
-  SendRedirectRspFp sendRedirectRspFp;
+  SBnodeOpt opt;
 } SBnode;
 
 #ifdef __cplusplus

source/dnode/mgmt/daemon/src/daemon.c

@@ -28,11 +28,11 @@ static struct {
   bool printAuth;
   bool printVersion;
   char configDir[PATH_MAX];
-} global = {0};
+} dmn = {0};
 
 void dmnSigintHandle(int signum, void *info, void *ctx) {
   uInfo("singal:%d is received", signum);
-  global.stop = true;
+  dmn.stop = true;
 }
 
 void dmnSetSignalHandle() {
@@ -44,7 +44,7 @@ void dmnSetSignalHandle() {
 }
 
 int dmnParseOption(int argc, char const *argv[]) {
-  tstrncpy(global.configDir, "/etc/taos", PATH_MAX);
+  tstrncpy(dmn.configDir, "/etc/taos", PATH_MAX);
 
   for (int i = 1; i < argc; ++i) {
     if (strcmp(argv[i], "-c") == 0) {
@@ -53,19 +53,19 @@ int dmnParseOption(int argc, char const *argv[]) {
           printf("config file path overflow");
           return -1;
         }
-        tstrncpy(global.configDir, argv[i], PATH_MAX);
+        tstrncpy(dmn.configDir, argv[i], PATH_MAX);
       } else {
         printf("'-c' requires a parameter, default is %s\n", configDir);
         return -1;
       }
     } else if (strcmp(argv[i], "-C") == 0) {
-      global.dumpConfig = true;
+      dmn.dumpConfig = true;
     } else if (strcmp(argv[i], "-k") == 0) {
-      global.generateGrant = true;
+      dmn.generateGrant = true;
     } else if (strcmp(argv[i], "-A") == 0) {
-      global.printAuth = true;
+      dmn.printAuth = true;
     } else if (strcmp(argv[i], "-V") == 0) {
-      global.printVersion = true;
+      dmn.printVersion = true;
     } else {
     }
   }
@@ -92,7 +92,7 @@ void dmnPrintVersion() {
 }
 
 int dmnReadConfig(const char *path) {
-  tstrncpy(configDir, global.configDir, PATH_MAX);
+  tstrncpy(configDir, dmn.configDir, PATH_MAX);
   taosInitGlobalCfg();
   taosReadGlobalLogCfg();
 
@@ -114,12 +114,12 @@ int dmnReadConfig(const char *path) {
   }
 
   if (taosReadCfgFromFile() != 0) {
-    uError("failed to read global config");
+    uError("failed to read config");
     return -1;
   }
 
   if (taosCheckAndPrintCfg() != 0) {
-    uError("failed to check global config");
+    uError("failed to check config");
     return -1;
   }
 
@@ -131,38 +131,50 @@ void dmnDumpConfig() { taosDumpGlobalCfg(); }
 
 void dmnWaitSignal() {
   dmnSetSignalHandle();
-  while (!global.stop) {
+  while (!dmn.stop) {
     taosMsleep(100);
   }
 }
 
-void dmnInitOption(SDnodeOpt *pOption) {
-  pOption->sver = 30000000; //3.0.0.0
-  pOption->numOfCores = tsNumOfCores;
-  pOption->numOfSupportVnodes = tsNumOfSupportVnodes;
-  pOption->numOfCommitThreads = tsNumOfCommitThreads;
-  pOption->statusInterval = tsStatusInterval;
-  pOption->numOfThreadsPerCore = tsNumOfThreadsPerCore;
-  pOption->ratioOfQueryCores = tsRatioOfQueryCores;
-  pOption->maxShellConns = tsMaxShellConns;
-  pOption->shellActivityTimer = tsShellActivityTimer;
-  pOption->serverPort = tsServerPort;
-  tstrncpy(pOption->dataDir, tsDataDir, TSDB_FILENAME_LEN);
-  tstrncpy(pOption->localEp, tsLocalEp, TSDB_EP_LEN);
-  tstrncpy(pOption->localFqdn, tsLocalFqdn, TSDB_FQDN_LEN);
-  tstrncpy(pOption->firstEp, tsFirst, TSDB_EP_LEN);
-  tstrncpy(pOption->timezone, tsTimezone, TSDB_TIMEZONE_LEN);
-  tstrncpy(pOption->locale, tsLocale, TSDB_LOCALE_LEN);
-  tstrncpy(pOption->charset, tsCharset, TSDB_LOCALE_LEN);
-  tstrncpy(pOption->buildinfo, buildinfo, 64);
-  tstrncpy(pOption->gitinfo, gitinfo, 48);
+void dnmInitEnvCfg(SDnodeEnvCfg *pCfg) {
+  pCfg->sver = 30000000;  // 3.0.0.0
+  pCfg->numOfCores = tsNumOfCores;
+  pCfg->numOfCommitThreads = tsNumOfCommitThreads;
+  pCfg->enableTelem = 0;
+  tstrncpy(pCfg->timezone, tsTimezone, TSDB_TIMEZONE_LEN);
+  tstrncpy(pCfg->locale, tsLocale, TSDB_LOCALE_LEN);
+  tstrncpy(pCfg->charset, tsCharset, TSDB_LOCALE_LEN);
+  tstrncpy(pCfg->buildinfo, buildinfo, 64);
+  tstrncpy(pCfg->gitinfo, gitinfo, 48);
+}
+
+void dmnInitObjCfg(SDnodeObjCfg *pCfg) {
+  pCfg->numOfSupportVnodes = tsNumOfSupportVnodes;
+  pCfg->statusInterval = tsStatusInterval;
+  pCfg->numOfThreadsPerCore = tsNumOfThreadsPerCore;
+  pCfg->ratioOfQueryCores = tsRatioOfQueryCores;
+  pCfg->maxShellConns = tsMaxShellConns;
+  pCfg->shellActivityTimer = tsShellActivityTimer;
+  pCfg->serverPort = tsServerPort;
+  tstrncpy(pCfg->dataDir, tsDataDir, TSDB_FILENAME_LEN);
+  tstrncpy(pCfg->localEp, tsLocalEp, TSDB_EP_LEN);
+  tstrncpy(pCfg->localFqdn, tsLocalFqdn, TSDB_FQDN_LEN);
+  tstrncpy(pCfg->firstEp, tsFirst, TSDB_EP_LEN);
 }
 
 int dmnRunDnode() {
-  SDnodeOpt option = {0};
-  dmnInitOption(&option);
+  SDnodeEnvCfg envCfg = {0};
+  SDnodeObjCfg objCfg = {0};
+
+  dnmInitEnvCfg(&envCfg);
+  dmnInitObjCfg(&objCfg);
+
+  if (dndInit(&envCfg) != 0) {
+    uInfo("Failed to start TDengine, please check the log at %s", tsLogDir);
+    return -1;
+  }
 
-  SDnode *pDnode = dndInit(&option);
+  SDnode *pDnode = dndCreate(&objCfg);
   if (pDnode == NULL) {
     uInfo("Failed to start TDengine, please check the log at %s", tsLogDir);
     return -1;
@@ -172,7 +184,8 @@ int dmnRunDnode() {
   dmnWaitSignal();
   uInfo("TDengine is shut down!");
 
-  dndCleanup(pDnode);
+  dndClose(pDnode);
+  dndCleanup();
   taosCloseLog();
   return 0;
 }
@@ -182,21 +195,21 @@ int main(int argc, char const *argv[]) {
     return -1;
   }
 
-  if (global.generateGrant) {
+  if (dmn.generateGrant) {
     dmnGenerateGrant();
     return 0;
   }
 
-  if (global.printVersion) {
+  if (dmn.printVersion) {
     dmnPrintVersion();
     return 0;
   }
 
-  if (dmnReadConfig(global.configDir) != 0) {
+  if (dmnReadConfig(dmn.configDir) != 0) {
     return -1;
   }
 
-  if (global.dumpConfig) {
+  if (dmn.dumpConfig) {
     dmnDumpConfig();
     return 0;
   }

source/dnode/mgmt/impl/inc/dndBnode.h

@@ -19,7 +19,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "dndInt.h"
+#include "dndEnv.h"
 
 int32_t dndInitBnode(SDnode *pDnode);
 void    dndCleanupBnode(SDnode *pDnode);

source/dnode/mgmt/impl/inc/dndEnv.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_DND_ENV_H_
+#define _TD_DND_ENV_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "dndInt.h"
+
+typedef struct {
+  EWorkerType type;
+  const char *name;
+  int32_t     minNum;
+  int32_t     maxNum;
+  void       *queueFp;
+  SDnode     *pDnode;
+  STaosQueue *queue;
+  union {
+    SWorkerPool  pool;
+    SMWorkerPool mpool;
+  };
+} SDnodeWorker;
+
+typedef struct {
+  char *dnode;
+  char *mnode;
+  char *snode;
+  char *bnode;
+  char *vnodes;
+} SDnodeDir;
+
+typedef struct {
+  int32_t      dnodeId;
+  int32_t      dropped;
+  int64_t      clusterId;
+  int64_t      dver;
+  int64_t      rebootTime;
+  int64_t      updateTime;
+  int8_t       statusSent;
+  SEpSet       mnodeEpSet;
+  char        *file;
+  SHashObj    *dnodeHash;
+  SDnodeEps   *dnodeEps;
+  pthread_t   *threadId;
+  SRWLatch     latch;
+  SDnodeWorker mgmtWorker;
+  SDnodeWorker statusWorker;
+} SDnodeMgmt;
+
+typedef struct {
+  int32_t      refCount;
+  int8_t       deployed;
+  int8_t       dropped;
+  SMnode      *pMnode;
+  SRWLatch     latch;
+  SDnodeWorker readWorker;
+  SDnodeWorker writeWorker;
+  SDnodeWorker syncWorker;
+  int8_t       replica;
+  int8_t       selfIndex;
+  SReplica     replicas[TSDB_MAX_REPLICA];
+} SMnodeMgmt;
+
+typedef struct {
+  int32_t      refCount;
+  int8_t       deployed;
+  int8_t       dropped;
+  SQnode      *pQnode;
+  SRWLatch     latch;
+  SDnodeWorker queryWorker;
+  SDnodeWorker fetchWorker;
+} SQnodeMgmt;
+
+typedef struct {
+  int32_t      refCount;
+  int8_t       deployed;
+  int8_t       dropped;
+  SSnode      *pSnode;
+  SRWLatch     latch;
+  SDnodeWorker writeWorker;
+} SSnodeMgmt;
+
+typedef struct {
+  int32_t      refCount;
+  int8_t       deployed;
+  int8_t       dropped;
+  SBnode      *pBnode;
+  SRWLatch     latch;
+  SDnodeWorker writeWorker;
+} SBnodeMgmt;
+
+typedef struct {
+  SHashObj    *hash;
+  int32_t      openVnodes;
+  int32_t      totalVnodes;
+  SRWLatch     latch;
+  SWorkerPool  queryPool;
+  SWorkerPool  fetchPool;
+  SMWorkerPool syncPool;
+  SMWorkerPool writePool;
+} SVnodesMgmt;
+
+typedef struct {
+  void    *serverRpc;
+  void    *clientRpc;
+  DndMsgFp msgFp[TDMT_MAX];
+} STransMgmt;
+
+typedef struct SDnode {
+  EStat        stat;
+  SDnodeObjCfg cfg;
+  SDnodeEnvCfg env;
+  SDnodeDir    dir;
+  FileFd       lockFd;
+  SDnodeMgmt   dmgmt;
+  SMnodeMgmt   mmgmt;
+  SQnodeMgmt   qmgmt;
+  SSnodeMgmt   smgmt;
+  SBnodeMgmt   bmgmt;
+  SVnodesMgmt  vmgmt;
+  STransMgmt   tmgmt;
+  SStartupReq  startup;
+} SDnode;
+
+typedef struct {
+  int8_t       once;
+  SDnodeEnvCfg cfg;
+} SDnodeEnv;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_DND_ENV_H_*/
\ No newline at end of file

source/dnode/mgmt/impl/inc/dndInt.h

@@ -55,125 +55,12 @@ extern int32_t dDebugFlag;
 
 typedef enum { DND_STAT_INIT, DND_STAT_RUNNING, DND_STAT_STOPPED } EStat;
 typedef enum { DND_WORKER_SINGLE, DND_WORKER_MULTI } EWorkerType;
+typedef enum { DND_ENV_INIT = 0, DND_ENV_READY = 1, DND_ENV_CLEANUP = 2 } EEnvStat;
 typedef void (*DndMsgFp)(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEps);
 
-typedef struct {
-  EWorkerType    type;
-  const char    *name;
-  int32_t        minNum;
-  int32_t        maxNum;
-  void          *queueFp;
-  SDnode        *pDnode;
-  STaosQueue    *queue;
-  union {
-    SWorkerPool  pool;
-    SMWorkerPool mpool;
-  };
-} SDnodeWorker;
-
-typedef struct {
-  char *dnode;
-  char *mnode;
-  char *snode;
-  char *bnode;
-  char *vnodes;
-} SDnodeDir;
-
-typedef struct {
-  int32_t      dnodeId;
-  int32_t      dropped;
-  int64_t      clusterId;
-  int64_t      dver;
-  int64_t      rebootTime;
-  int64_t      updateTime;
-  int8_t       statusSent;
-  SEpSet       mnodeEpSet;
-  char        *file;
-  SHashObj    *dnodeHash;
-  SDnodeEps   *dnodeEps;
-  pthread_t   *threadId;
-  SRWLatch     latch;
-  SDnodeWorker mgmtWorker;
-  SDnodeWorker statusWorker;
-} SDnodeMgmt;
-
-typedef struct {
-  int32_t      refCount;
-  int8_t       deployed;
-  int8_t       dropped;
-  SMnode      *pMnode;
-  SRWLatch     latch;
-  SDnodeWorker readWorker;
-  SDnodeWorker writeWorker;
-  SDnodeWorker syncWorker;
-  int8_t       replica;
-  int8_t       selfIndex;
-  SReplica     replicas[TSDB_MAX_REPLICA];
-} SMnodeMgmt;
-
-typedef struct {
-  int32_t      refCount;
-  int8_t       deployed;
-  int8_t       dropped;
-  SQnode      *pQnode;
-  SRWLatch     latch;
-  SDnodeWorker queryWorker;
-  SDnodeWorker fetchWorker;
-} SQnodeMgmt;
-
-typedef struct {
-  int32_t      refCount;
-  int8_t       deployed;
-  int8_t       dropped;
-  SSnode      *pSnode;
-  SRWLatch     latch;
-  SDnodeWorker writeWorker;
-} SSnodeMgmt;
-
-typedef struct {
-  int32_t      refCount;
-  int8_t       deployed;
-  int8_t       dropped;
-  SBnode      *pBnode;
-  SRWLatch     latch;
-  SDnodeWorker writeWorker;
-} SBnodeMgmt;
-
-typedef struct {
-  SHashObj    *hash;
-  int32_t      openVnodes;
-  int32_t      totalVnodes;
-  SRWLatch     latch;
-  SWorkerPool  queryPool;
-  SWorkerPool  fetchPool;
-  SMWorkerPool syncPool;
-  SMWorkerPool writePool;
-} SVnodesMgmt;
-
-typedef struct {
-  void    *serverRpc;
-  void    *clientRpc;
-  DndMsgFp msgFp[TDMT_MAX];
-} STransMgmt;
-
-typedef struct SDnode {
-  EStat       stat;
-  SDnodeOpt   opt;
-  SDnodeDir   dir;
-  FileFd      lockFd;
-  SDnodeMgmt  dmgmt;
-  SMnodeMgmt  mmgmt;
-  SQnodeMgmt  qmgmt;
-  SSnodeMgmt  smgmt;
-  SBnodeMgmt  bmgmt;
-  SVnodesMgmt vmgmt;
-  STransMgmt  tmgmt;
-  SStartupReq startup;
-} SDnode;
-
 EStat       dndGetStat(SDnode *pDnode);
 void        dndSetStat(SDnode *pDnode, EStat stat);
-char *dndStatStr(EStat stat);
+const char *dndStatStr(EStat stat);
 
 void dndReportStartup(SDnode *pDnode, char *pName, char *pDesc);
 void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup);

source/dnode/mgmt/impl/inc/dndMgmt.h

@@ -19,7 +19,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "dndInt.h"
+#include "dndEnv.h"
 
 int32_t dndInitMgmt(SDnode *pDnode);
 void    dndStopMgmt(SDnode *pDnode);

source/dnode/mgmt/impl/inc/dndMnode.h

@@ -19,7 +19,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "dndInt.h"
+#include "dndEnv.h"
 
 int32_t dndInitMnode(SDnode *pDnode);
 void    dndCleanupMnode(SDnode *pDnode);

source/dnode/mgmt/impl/inc/dndQnode.h

@@ -19,7 +19,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "dndInt.h"
+#include "dndEnv.h"
 
 int32_t dndInitQnode(SDnode *pDnode);
 void    dndCleanupQnode(SDnode *pDnode);

source/dnode/mgmt/impl/inc/dndSnode.h

@@ -19,7 +19,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "dndInt.h"
+#include "dndEnv.h"
 
 int32_t dndInitSnode(SDnode *pDnode);
 void    dndCleanupSnode(SDnode *pDnode);

source/dnode/mgmt/impl/inc/dndTransport.h

@@ -19,7 +19,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "dndInt.h"
+#include "dndEnv.h"
 
 int32_t dndInitTrans(SDnode *pDnode);
 void    dndCleanupTrans(SDnode *pDnode);

source/dnode/mgmt/impl/inc/dndVnodes.h

@@ -19,7 +19,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "dndInt.h"
+#include "dndEnv.h"
 
 int32_t dndInitVnodes(SDnode *pDnode);
 void    dndCleanupVnodes(SDnode *pDnode);

source/dnode/mgmt/impl/inc/dndWorker.h

@@ -19,7 +19,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "dndInt.h"
+#include "dndEnv.h"
 
 int32_t dndInitWorker(SDnode *pDnode, SDnodeWorker *pWorker, EWorkerType type, const char *name, int32_t minNum,
                       int32_t maxNum, void *queueFp);

source/dnode/mgmt/impl/src/dndBnode.c

@@ -179,7 +179,7 @@ static void dndBuildBnodeOption(SDnode *pDnode, SBnodeOpt *pOption) {
   pOption->sendRedirectRspFp = dndSendRedirectRsp;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
-  pOption->cfg.sver = pDnode->opt.sver;
+  pOption->sver = pDnode->env.sver;
 }
 
 static int32_t dndOpenBnode(SDnode *pDnode) {

source/dnode/mgmt/impl/src/dnode.c → source/dnode/mgmt/impl/src/dndEnv.c

@@ -25,6 +25,8 @@
 #include "tfs.h"
 #include "wal.h"
 
+static SDnodeEnv dndEnv = {0};
+
 EStat dndGetStat(SDnode *pDnode) { return pDnode->stat; }
 
 void dndSetStat(SDnode *pDnode, EStat stat) {
@@ -32,7 +34,7 @@ void dndSetStat(SDnode *pDnode, EStat stat) {
   pDnode->stat = stat;
 }
 
-char *dndStatStr(EStat stat) {
+const char *dndStatStr(EStat stat) {
   switch (stat) {
     case DND_STAT_INIT:
       return "init";
@@ -79,25 +81,26 @@ static FileFd dndCheckRunning(char *dataDir) {
   return fd;
 }
 
-static int32_t dndInitEnv(SDnode *pDnode, SDnodeOpt *pOption) {
-  pDnode->lockFd = dndCheckRunning(pOption->dataDir);
+static int32_t dndCreateImp(SDnode *pDnode, SDnodeObjCfg *pCfg) {
+  pDnode->lockFd = dndCheckRunning(pCfg->dataDir);
   if (pDnode->lockFd < 0) {
     return -1;
   }
 
   char path[PATH_MAX + 100];
-  snprintf(path, sizeof(path), "%s%smnode", pOption->dataDir, TD_DIRSEP);
+  snprintf(path, sizeof(path), "%s%smnode", pCfg->dataDir, TD_DIRSEP);
   pDnode->dir.mnode = tstrdup(path);
-  snprintf(path, sizeof(path), "%s%svnode", pOption->dataDir, TD_DIRSEP);
+  snprintf(path, sizeof(path), "%s%svnode", pCfg->dataDir, TD_DIRSEP);
   pDnode->dir.vnodes = tstrdup(path);
-  snprintf(path, sizeof(path), "%s%sdnode", pOption->dataDir, TD_DIRSEP);
+  snprintf(path, sizeof(path), "%s%sdnode", pCfg->dataDir, TD_DIRSEP);
   pDnode->dir.dnode = tstrdup(path);
-  snprintf(path, sizeof(path), "%s%ssnode", pOption->dataDir, TD_DIRSEP);
+  snprintf(path, sizeof(path), "%s%ssnode", pCfg->dataDir, TD_DIRSEP);
   pDnode->dir.snode = tstrdup(path);
-  snprintf(path, sizeof(path), "%s%sbnode", pOption->dataDir, TD_DIRSEP);
+  snprintf(path, sizeof(path), "%s%sbnode", pCfg->dataDir, TD_DIRSEP);
   pDnode->dir.bnode = tstrdup(path);
 
-  if (pDnode->dir.mnode == NULL || pDnode->dir.vnodes == NULL || pDnode->dir.dnode == NULL) {
+  if (pDnode->dir.mnode == NULL || pDnode->dir.vnodes == NULL || pDnode->dir.dnode == NULL ||
+      pDnode->dir.snode == NULL || pDnode->dir.bnode == NULL) {
     dError("failed to malloc dir object");
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -133,11 +136,12 @@ static int32_t dndInitEnv(SDnode *pDnode, SDnodeOpt *pOption) {
     return -1;
   }
 
-  memcpy(&pDnode->opt, pOption, sizeof(SDnodeOpt));
+  memcpy(&pDnode->cfg, pCfg, sizeof(SDnodeObjCfg));
+  memcpy(&pDnode->env, &dndEnv.cfg, sizeof(SDnodeEnvCfg));
   return 0;
 }
 
-static void dndCleanupEnv(SDnode *pDnode) {
+static void dndCloseImp(SDnode *pDnode) {
   tfree(pDnode->dir.mnode);
   tfree(pDnode->dir.vnodes);
   tfree(pDnode->dir.dnode);
@@ -149,126 +153,95 @@ static void dndCleanupEnv(SDnode *pDnode) {
     taosCloseFile(pDnode->lockFd);
     pDnode->lockFd = 0;
   }
-
-  taosStopCacheRefreshWorker();
 }
 
-SDnode *dndInit(SDnodeOpt *pOption) {
-  taosIgnSIGPIPE();
-  taosBlockSIGPIPE();
-  taosResolveCRC();
+SDnode *dndCreate(SDnodeObjCfg *pCfg) {
+  dInfo("start to create dnode object");
 
   SDnode *pDnode = calloc(1, sizeof(SDnode));
   if (pDnode == NULL) {
-    dError("failed to create dnode object");
     terrno = TSDB_CODE_OUT_OF_MEMORY;
+    dError("failed to create dnode object since %s", terrstr());
     return NULL;
   }
 
-  dInfo("start to initialize TDengine");
   dndSetStat(pDnode, DND_STAT_INIT);
 
-  if (dndInitEnv(pDnode, pOption) != 0) {
-    dError("failed to init env");
-    dndCleanup(pDnode);
-    return NULL;
-  }
-
-  if (rpcInit() != 0) {
-    dError("failed to init rpc env");
-    dndCleanup(pDnode);
-    return NULL;
-  }
-
-  if (walInit() != 0) {
-    dError("failed to init wal env");
-    dndCleanup(pDnode);
+  if (dndCreateImp(pDnode, pCfg) != 0) {
+    dError("failed to init dnode dir since %s", terrstr());
+    dndClose(pDnode);
     return NULL;
   }
 
   SDiskCfg dCfg;
-  strcpy(dCfg.dir, pDnode->opt.dataDir);
+  strcpy(dCfg.dir, pDnode->cfg.dataDir);
   dCfg.level = 0;
   dCfg.primary = 1;
   if (tfsInit(&dCfg, 1) != 0) {
-    dError("failed to init tfs env");
-    dndCleanup(pDnode);
-    return NULL;
-  }
-
-  SVnodeOpt vnodeOpt = {
-      .sver = pDnode->opt.sver,
-      .timezone = pDnode->opt.timezone,
-      .locale = pDnode->opt.locale,
-      .charset = pDnode->opt.charset,
-      .nthreads = pDnode->opt.numOfCommitThreads,
-      .putReqToVQueryQFp = dndPutReqToVQueryQ,
-  };
-  if (vnodeInit(&vnodeOpt) != 0) {
-    dError("failed to init vnode env");
-    dndCleanup(pDnode);
+    dError("failed to init tfs since %s", terrstr());
+    dndClose(pDnode);
     return NULL;
   }
 
   if (dndInitMgmt(pDnode) != 0) {
-    dError("failed to init dnode");
-    dndCleanup(pDnode);
+    dError("failed to init mgmt since %s", terrstr());
+    dndClose(pDnode);
     return NULL;
   }
 
   if (dndInitVnodes(pDnode) != 0) {
-    dError("failed to init vnodes");
-    dndCleanup(pDnode);
+    dError("failed to init vnodes since %s", terrstr());
+    dndClose(pDnode);
     return NULL;
   }
 
   if (dndInitQnode(pDnode) != 0) {
-    dError("failed to init qnode");
-    dndCleanup(pDnode);
+    dError("failed to init qnode since %s", terrstr());
+    dndClose(pDnode);
     return NULL;
   }
 
   if (dndInitSnode(pDnode) != 0) {
-    dError("failed to init snode");
-    dndCleanup(pDnode);
+    dError("failed to init snode since %s", terrstr());
+    dndClose(pDnode);
     return NULL;
   }
 
   if (dndInitBnode(pDnode) != 0) {
-    dError("failed to init bnode");
-    dndCleanup(pDnode);
+    dError("failed to init bnode since %s", terrstr());
+    dndClose(pDnode);
     return NULL;
   }
 
   if (dndInitMnode(pDnode) != 0) {
-    dError("failed to init mnode");
-    dndCleanup(pDnode);
+    dError("failed to init mnode since %s", terrstr());
+    dndClose(pDnode);
     return NULL;
   }
 
   if (dndInitTrans(pDnode) != 0) {
-    dError("failed to init transport");
-    dndCleanup(pDnode);
+    dError("failed to init transport since %s", terrstr());
+    dndClose(pDnode);
     return NULL;
   }
 
   dndSetStat(pDnode, DND_STAT_RUNNING);
   dndSendStatusReq(pDnode);
   dndReportStartup(pDnode, "TDengine", "initialized successfully");
-  dInfo("TDengine is initialized successfully, pDnode:%p", pDnode);
+  dInfo("dnode object is created, data:%p", pDnode);
 
   return pDnode;
 }
 
-void dndCleanup(SDnode *pDnode) {
+void dndClose(SDnode *pDnode) {
   if (pDnode == NULL) return;
 
   if (dndGetStat(pDnode) == DND_STAT_STOPPED) {
-    dError("dnode is shutting down");
+    dError("dnode is shutting down, data:%p", pDnode);
     return;
   }
 
-  dInfo("start to cleanup TDengine");
+  dInfo("start to close dnode, data:%p", pDnode);
   dndSetStat(pDnode, DND_STAT_STOPPED);
   dndCleanupTrans(pDnode);
   dndStopMgmt(pDnode);
@@ -278,12 +251,66 @@ void dndCleanup(SDnode *pDnode) {
   dndCleanupQnode(pDnode);
   dndCleanupVnodes(pDnode);
   dndCleanupMgmt(pDnode);
-  vnodeClear();
-  tfsDestroy();
+  tfsCleanup();
+
+  dndCloseImp(pDnode);
+  free(pDnode);
+  dInfo("dnode object is closed, data:%p", pDnode);
+}
+
+int32_t dndInit(const SDnodeEnvCfg *pCfg) {
+  if (atomic_val_compare_exchange_8(&dndEnv.once, DND_ENV_INIT, DND_ENV_READY) != DND_ENV_INIT) {
+    terrno = TSDB_CODE_REPEAT_INIT;
+    dError("failed to init dnode env since %s", terrstr());
+    return -1;
+  }
+
+  taosIgnSIGPIPE();
+  taosBlockSIGPIPE();
+  taosResolveCRC();
+
+  if (rpcInit() != 0) {
+    dError("failed to init rpc since %s", terrstr());
+    dndCleanup();
+    return -1;
+  }
+
+  if (walInit() != 0) {
+    dError("failed to init wal since %s", terrstr());
+    dndCleanup();
+    return -1;
+  }
+
+  SVnodeOpt vnodeOpt = {
+      .sver = pCfg->sver,
+      .timezone = pCfg->timezone,
+      .locale = pCfg->locale,
+      .charset = pCfg->charset,
+      .nthreads = pCfg->numOfCommitThreads,
+      .putReqToVQueryQFp = dndPutReqToVQueryQ,
+  };
+
+  if (vnodeInit(&vnodeOpt) != 0) {
+    dError("failed to init vnode since %s", terrstr());
+    dndCleanup();
+    return NULL;
+  }
+
+  memcpy(&dndEnv.cfg, pCfg, sizeof(SDnodeEnvCfg));
+  dInfo("dnode env is initialized");
+  return 0;
+}
+
+void dndCleanup() {
+  if (atomic_val_compare_exchange_8(&dndEnv.once, DND_ENV_READY, DND_ENV_CLEANUP) != DND_ENV_READY) {
+    dError("dnode env is already cleaned up");
+    return;
+  }
+
   walCleanUp();
+  vnodeCleanup();
   rpcCleanup();
 
-  dndCleanupEnv(pDnode);
-  free(pDnode);
-  dInfo("TDengine is cleaned up successfully");
+  taosStopCacheRefreshWorker();
+  dInfo("dnode env is cleaned up");
 }
\ No newline at end of file

source/dnode/mgmt/impl/src/dndMgmt.c

@@ -86,7 +86,7 @@ void dndSendRedirectRsp(SDnode *pDnode, SRpcMsg *pReq) {
   dDebug("RPC %p, req:%s is redirected, num:%d use:%d", pReq->handle, TMSG_INFO(msgType), epSet.numOfEps, epSet.inUse);
   for (int32_t i = 0; i < epSet.numOfEps; ++i) {
     dDebug("mnode index:%d %s:%u", i, epSet.fqdn[i], epSet.port[i]);
-    if (strcmp(epSet.fqdn[i], pDnode->opt.localFqdn) == 0 && epSet.port[i] == pDnode->opt.serverPort) {
+    if (strcmp(epSet.fqdn[i], pDnode->cfg.localFqdn) == 0 && epSet.port[i] == pDnode->cfg.serverPort) {
       epSet.inUse = (i + 1) % epSet.numOfEps;
     }
 
@@ -289,8 +289,8 @@ PRASE_DNODE_OVER:
   if (root != NULL) cJSON_Delete(root);
   if (fp != NULL) fclose(fp);
 
-  if (dndIsEpChanged(pDnode, pMgmt->dnodeId, pDnode->opt.localEp)) {
-    dError("localEp %s different with %s and need reconfigured", pDnode->opt.localEp, pMgmt->file);
+  if (dndIsEpChanged(pDnode, pMgmt->dnodeId, pDnode->cfg.localEp)) {
+    dError("localEp %s different with %s and need reconfigured", pDnode->cfg.localEp, pMgmt->file);
     return -1;
   }
 
@@ -298,7 +298,7 @@ PRASE_DNODE_OVER:
     pMgmt->dnodeEps = calloc(1, sizeof(SDnodeEps) + sizeof(SDnodeEp));
     pMgmt->dnodeEps->num = 1;
     pMgmt->dnodeEps->eps[0].isMnode = 1;
-    taosGetFqdnPortFromEp(pDnode->opt.firstEp, pMgmt->dnodeEps->eps[0].fqdn, &pMgmt->dnodeEps->eps[0].port);
+    taosGetFqdnPortFromEp(pDnode->cfg.firstEp, pMgmt->dnodeEps->eps[0].fqdn, &pMgmt->dnodeEps->eps[0].port);
   }
 
   dndResetDnodes(pDnode, pMgmt->dnodeEps);
@@ -362,24 +362,24 @@ void dndSendStatusReq(SDnode *pDnode) {
 
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
   taosRLockLatch(&pMgmt->latch);
-  pStatus->sver = htonl(pDnode->opt.sver);
+  pStatus->sver = htonl(pDnode->env.sver);
   pStatus->dver = htobe64(pMgmt->dver);
   pStatus->dnodeId = htonl(pMgmt->dnodeId);
   pStatus->clusterId = htobe64(pMgmt->clusterId);
   pStatus->rebootTime = htobe64(pMgmt->rebootTime);
   pStatus->updateTime = htobe64(pMgmt->updateTime);
-  pStatus->numOfCores = htonl(pDnode->opt.numOfCores);
-  pStatus->numOfSupportVnodes = htonl(pDnode->opt.numOfSupportVnodes);
-  tstrncpy(pStatus->dnodeEp, pDnode->opt.localEp, TSDB_EP_LEN);
+  pStatus->numOfCores = htonl(pDnode->env.numOfCores);
+  pStatus->numOfSupportVnodes = htonl(pDnode->cfg.numOfSupportVnodes);
+  tstrncpy(pStatus->dnodeEp, pDnode->cfg.localEp, TSDB_EP_LEN);
 
-  pStatus->clusterCfg.statusInterval = htonl(pDnode->opt.statusInterval);
+  pStatus->clusterCfg.statusInterval = htonl(pDnode->cfg.statusInterval);
   pStatus->clusterCfg.checkTime = 0;
   char timestr[32] = "1970-01-01 00:00:00.00";
   (void)taosParseTime(timestr, &pStatus->clusterCfg.checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
   pStatus->clusterCfg.checkTime = htonl(pStatus->clusterCfg.checkTime);
-  tstrncpy(pStatus->clusterCfg.timezone, pDnode->opt.timezone, TSDB_TIMEZONE_LEN);
-  tstrncpy(pStatus->clusterCfg.locale, pDnode->opt.locale, TSDB_LOCALE_LEN);
-  tstrncpy(pStatus->clusterCfg.charset, pDnode->opt.charset, TSDB_LOCALE_LEN);
+  tstrncpy(pStatus->clusterCfg.timezone, pDnode->env.timezone, TSDB_TIMEZONE_LEN);
+  tstrncpy(pStatus->clusterCfg.locale, pDnode->env.locale, TSDB_LOCALE_LEN);
+  tstrncpy(pStatus->clusterCfg.charset, pDnode->env.charset, TSDB_LOCALE_LEN);
   taosRUnLockLatch(&pMgmt->latch);
 
   dndGetVnodeLoads(pDnode, &pStatus->vnodeLoads);
@@ -485,7 +485,7 @@ void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
 static void *dnodeThreadRoutine(void *param) {
   SDnode     *pDnode = param;
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
-  int32_t     ms = pDnode->opt.statusInterval * 1000;
+  int32_t     ms = pDnode->cfg.statusInterval * 1000;
 
   while (true) {
     pthread_testcancel();

source/dnode/mgmt/impl/src/dndMnode.c

@@ -247,7 +247,7 @@ static bool dndNeedDeployMnode(SDnode *pDnode) {
     return false;
   }
 
-  if (strcmp(pDnode->opt.localEp, pDnode->opt.firstEp) != 0) {
+  if (strcmp(pDnode->cfg.localEp, pDnode->cfg.firstEp) != 0) {
     return false;
   }
 
@@ -266,15 +266,15 @@ static void dndInitMnodeOption(SDnode *pDnode, SMnodeOpt *pOption) {
   pOption->putReqToMWriteQFp = dndPutMsgToMWriteQ;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
-  pOption->cfg.sver = pDnode->opt.sver;
-  pOption->cfg.enableTelem = pDnode->opt.enableTelem;
-  pOption->cfg.statusInterval = pDnode->opt.statusInterval;
-  pOption->cfg.shellActivityTimer = pDnode->opt.shellActivityTimer;
-  pOption->cfg.timezone = pDnode->opt.timezone;
-  pOption->cfg.charset = pDnode->opt.charset;
-  pOption->cfg.locale = pDnode->opt.locale;
-  pOption->cfg.gitinfo = pDnode->opt.gitinfo;
-  pOption->cfg.buildinfo = pDnode->opt.buildinfo;
+  pOption->cfg.sver = pDnode->env.sver;
+  pOption->cfg.enableTelem = pDnode->env.enableTelem;
+  pOption->cfg.statusInterval = pDnode->cfg.statusInterval;
+  pOption->cfg.shellActivityTimer = pDnode->cfg.shellActivityTimer;
+  pOption->cfg.timezone = pDnode->env.timezone;
+  pOption->cfg.charset = pDnode->env.charset;
+  pOption->cfg.locale = pDnode->env.locale;
+  pOption->cfg.gitinfo = pDnode->env.gitinfo;
+  pOption->cfg.buildinfo = pDnode->env.buildinfo;
 }
 
 static void dndBuildMnodeDeployOption(SDnode *pDnode, SMnodeOpt *pOption) {
@@ -283,8 +283,8 @@ static void dndBuildMnodeDeployOption(SDnode *pDnode, SMnodeOpt *pOption) {
   pOption->selfIndex = 0;
   SReplica *pReplica = &pOption->replicas[0];
   pReplica->id = 1;
-  pReplica->port = pDnode->opt.serverPort;
-  memcpy(pReplica->fqdn, pDnode->opt.localFqdn, TSDB_FQDN_LEN);
+  pReplica->port = pDnode->cfg.serverPort;
+  memcpy(pReplica->fqdn, pDnode->cfg.localFqdn, TSDB_FQDN_LEN);
 
   SMnodeMgmt *pMgmt = &pDnode->mmgmt;
   pMgmt->selfIndex = pOption->selfIndex;

source/dnode/mgmt/impl/src/dndQnode.c

@@ -185,7 +185,7 @@ static void dndBuildQnodeOption(SDnode *pDnode, SQnodeOpt *pOption) {
   pOption->sendRedirectRspFp = dndSendRedirectRsp;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
-  pOption->cfg.sver = pDnode->opt.sver;
+  pOption->sver = pDnode->env.sver;
 }
 
 static int32_t dndOpenQnode(SDnode *pDnode) {

source/dnode/mgmt/impl/src/dndSnode.c

@@ -179,7 +179,7 @@ static void dndBuildSnodeOption(SDnode *pDnode, SSnodeOpt *pOption) {
   pOption->sendRedirectRspFp = dndSendRedirectRsp;
   pOption->dnodeId = dndGetDnodeId(pDnode);
   pOption->clusterId = dndGetClusterId(pDnode);
-  pOption->cfg.sver = pDnode->opt.sver;
+  pOption->sver = pDnode->env.sver;
 }
 
 static int32_t dndOpenSnode(SDnode *pDnode) {

source/dnode/mgmt/impl/src/dndTransport.c

@@ -176,7 +176,7 @@ static int32_t dndInitClient(SDnode *pDnode) {
   rpcInit.cfp = dndProcessResponse;
   rpcInit.sessions = 1024;
   rpcInit.connType = TAOS_CONN_CLIENT;
-  rpcInit.idleTime = pDnode->opt.shellActivityTimer * 1000;
+  rpcInit.idleTime = pDnode->cfg.shellActivityTimer * 1000;
   rpcInit.user = INTERNAL_USER;
   rpcInit.ckey = INTERNAL_CKEY;
   rpcInit.secret = INTERNAL_SECRET;
@@ -325,20 +325,20 @@ static int32_t dndInitServer(SDnode *pDnode) {
   STransMgmt *pMgmt = &pDnode->tmgmt;
   dndInitMsgFp(pMgmt);
 
-  int32_t numOfThreads = (int32_t)((pDnode->opt.numOfCores * pDnode->opt.numOfThreadsPerCore) / 2.0);
+  int32_t numOfThreads = (int32_t)((pDnode->env.numOfCores * pDnode->cfg.numOfThreadsPerCore) / 2.0);
   if (numOfThreads < 1) {
     numOfThreads = 1;
   }
 
   SRpcInit rpcInit;
   memset(&rpcInit, 0, sizeof(rpcInit));
-  rpcInit.localPort = pDnode->opt.serverPort;
+  rpcInit.localPort = pDnode->cfg.serverPort;
   rpcInit.label = "DND-S";
   rpcInit.numOfThreads = numOfThreads;
   rpcInit.cfp = dndProcessRequest;
-  rpcInit.sessions = pDnode->opt.maxShellConns;
+  rpcInit.sessions = pDnode->cfg.maxShellConns;
   rpcInit.connType = TAOS_CONN_SERVER;
-  rpcInit.idleTime = pDnode->opt.shellActivityTimer * 1000;
+  rpcInit.idleTime = pDnode->cfg.shellActivityTimer * 1000;
   rpcInit.afp = dndRetrieveUserAuthInfo;
   rpcInit.parent = pDnode;
 

source/dnode/mgmt/impl/src/dndVnodes.c

@@ -420,7 +420,7 @@ static int32_t dndOpenVnodes(SDnode *pDnode) {
 
   pMgmt->totalVnodes = numOfVnodes;
 
-  int32_t threadNum = pDnode->opt.numOfCores;
+  int32_t threadNum = pDnode->env.numOfCores;
   int32_t vnodesPerThread = numOfVnodes / threadNum + 1;
 
   SVnodeThread *threads = calloc(threadNum, sizeof(SVnodeThread));
@@ -904,11 +904,11 @@ static int32_t dndInitVnodeWorkers(SDnode *pDnode) {
   SVnodesMgmt *pMgmt = &pDnode->vmgmt;
 
   int32_t maxFetchThreads = 4;
-  int32_t minFetchThreads = MIN(maxFetchThreads, pDnode->opt.numOfCores);
-  int32_t minQueryThreads = MAX((int32_t)(pDnode->opt.numOfCores * pDnode->opt.ratioOfQueryCores), 1);
+  int32_t minFetchThreads = MIN(maxFetchThreads, pDnode->env.numOfCores);
+  int32_t minQueryThreads = MAX((int32_t)(pDnode->env.numOfCores * pDnode->cfg.ratioOfQueryCores), 1);
   int32_t maxQueryThreads = minQueryThreads;
-  int32_t maxWriteThreads = MAX(pDnode->opt.numOfCores, 1);
-  int32_t maxSyncThreads = MAX(pDnode->opt.numOfCores / 2, 1);
+  int32_t maxWriteThreads = MAX(pDnode->env.numOfCores, 1);
+  int32_t maxSyncThreads = MAX(pDnode->env.numOfCores / 2, 1);
 
   SWorkerPool *pPool = &pMgmt->queryPool;
   pPool->name = "vnode-query";

source/dnode/mgmt/impl/test/sut/inc/server.h

@@ -24,7 +24,7 @@ class TestServer {
   bool DoStart();
 
  private:
-  SDnodeOpt BuildOption(const char* path, const char* fqdn, uint16_t port, const char* firstEp);
+  SDnodeObjCfg BuildOption(const char* path, const char* fqdn, uint16_t port, const char* firstEp);
 
  private:
   SDnode*    pDnode;

source/dnode/mgmt/impl/test/sut/src/server.cpp

@@ -22,30 +22,27 @@ void* serverLoop(void* param) {
   }
 }
 
-SDnodeOpt TestServer::BuildOption(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
-  SDnodeOpt option = {0};
-  option.sver = 1;
-  option.numOfCores = 1;
-  option.numOfSupportVnodes = 16;
-  option.numOfCommitThreads = 1;
-  option.statusInterval = 1;
-  option.numOfThreadsPerCore = 1;
-  option.ratioOfQueryCores = 1;
-  option.maxShellConns = 1000;
-  option.shellActivityTimer = 30;
-  option.serverPort = port;
-  strcpy(option.dataDir, path);
-  snprintf(option.localEp, TSDB_EP_LEN, "%s:%u", fqdn, port);
-  snprintf(option.localFqdn, TSDB_FQDN_LEN, "%s", fqdn);
-  snprintf(option.firstEp, TSDB_EP_LEN, "%s", firstEp);
-  return option;
+SDnodeObjCfg TestServer::BuildOption(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
+  SDnodeObjCfg cfg = {0};
+  cfg.numOfSupportVnodes = 16;
+  cfg.statusInterval = 1;
+  cfg.numOfThreadsPerCore = 1;
+  cfg.ratioOfQueryCores = 1;
+  cfg.maxShellConns = 1000;
+  cfg.shellActivityTimer = 30;
+  cfg.serverPort = port;
+  strcpy(cfg.dataDir, path);
+  snprintf(cfg.localEp, TSDB_EP_LEN, "%s:%u", fqdn, port);
+  snprintf(cfg.localFqdn, TSDB_FQDN_LEN, "%s", fqdn);
+  snprintf(cfg.firstEp, TSDB_EP_LEN, "%s", firstEp);
+  return cfg;
 }
 
 bool TestServer::DoStart() {
-  SDnodeOpt option = BuildOption(path, fqdn, port, firstEp);
+  SDnodeObjCfg cfg = BuildOption(path, fqdn, port, firstEp);
   taosMkDir(path);
 
-  pDnode = dndInit(&option);
+  pDnode = dndCreate(&cfg);
   if (pDnode != NULL) {
     return false;
   }
@@ -81,7 +78,7 @@ void TestServer::Stop() {
   }
 
   if (pDnode != NULL) {
-    dndCleanup(pDnode);
+    dndClose(pDnode);
     pDnode = NULL;
   }
 }

source/dnode/mgmt/impl/test/sut/src/sut.cpp

@@ -43,6 +43,11 @@ void Testbase::InitLog(const char* path) {
 }
 
 void Testbase::Init(const char* path, int16_t port) {
+  SDnodeEnvCfg cfg = {0};
+  cfg.numOfCommitThreads = 1;
+  cfg.numOfCores = 1;
+  dndInit(&cfg);
+
   char fqdn[] = "localhost";
   char firstEp[TSDB_EP_LEN] = {0};
   snprintf(firstEp, TSDB_EP_LEN, "%s:%u", fqdn, port);
@@ -56,6 +61,7 @@ void Testbase::Init(const char* path, int16_t port) {
 void Testbase::Cleanup() {
   server.Stop();
   client.Cleanup();
+  dndCleanup();
 }
 
 void Testbase::Restart() { server.Restart(); }

source/dnode/qnode/inc/qndInt.h

@@ -29,12 +29,7 @@ extern "C" {
 #endif
 
 typedef struct SQnode {
-  int32_t           dnodeId;
-  int64_t           clusterId;
-  SQnodeCfg         cfg;
-  SendReqToDnodeFp  sendReqToDnodeFp;
-  SendReqToMnodeFp  sendReqToMnodeFp;
-  SendRedirectRspFp sendRedirectRspFp;
+  SQnodeOpt opt;
 } SQnode;
 
 #ifdef __cplusplus

source/dnode/snode/inc/sndInt.h

@@ -29,12 +29,7 @@ extern "C" {
 #endif
 
 typedef struct SSnode {
-  int32_t           dnodeId;
-  int64_t           clusterId;
-  SSnodeCfg         cfg;
-  SendReqToDnodeFp  sendReqToDnodeFp;
-  SendReqToMnodeFp  sendReqToMnodeFp;
-  SendRedirectRspFp sendRedirectRspFp;
+  SSnodeOpt cfg;
 } SSnode;
 
 #ifdef __cplusplus

source/dnode/vnode/CMakeLists.txt

-add_subdirectory(meta)
-add_subdirectory(tq)
-add_subdirectory(tsdb)
-add_subdirectory(impl)
+aux_source_directory(src/meta META_SRC)
+aux_source_directory(src/tq TQ_SRC)
+aux_source_directory(src/tsdb TSDB_SRC)
+aux_source_directory(src/vnd VND_SRC)
\ No newline at end of file
+list(APPEND
+    VNODE_SRC
+    ${META_SRC}
+    ${TQ_SRC}
+    ${TSDB_SRC}
+    ${VND_SRC}
+)
+
+add_library(vnode STATIC ${VNODE_SRC})
+target_include_directories(
+    vnode
+    PUBLIC inc
+    PRIVATE src/inc
+)
+target_link_libraries(
+    vnode
+    PUBLIC os
+    PUBLIC util
+    PUBLIC common
+    PUBLIC transport
+    PUBLIC bdb
+    PUBLIC tfs
+    PUBLIC wal
+    PUBLIC qworker
+)
+
+if(${BUILD_TEST})
+    # add_subdirectory(test)
+endif(${BUILD_TEST})

source/dnode/vnode/impl/test/CMakeLists.txt

-# Vnode API test
-add_executable(vnodeApiTests "")
-target_sources(vnodeApiTests
-    PRIVATE
-    "vnodeApiTests.cpp"
-)
-target_link_libraries(vnodeApiTests vnode gtest gtest_main)
-
-add_test(
-    NAME vnode_api_tests 
-    COMMAND ${CMAKE_CURRENT_BINARY_DIR}/vnodeApiTests
-    )
\ No newline at end of file

source/dnode/vnode/impl/test/vBenchmarkTest.cpp

-// https://stackoverflow.com/questions/8565666/benchmarking-with-googletest
-// https://github.com/google/benchmark
\ No newline at end of file

source/dnode/vnode/impl/test/vnodeApiTests.cpp

-/**
- * @file vnodeApiTests.cpp
- * @author hzcheng (hzcheng@taosdata.com)
- * @brief VNODE module API tests
- * @version 0.1
- * @date 2021-12-13
- *
- * @copyright Copyright (c) 2021
- *
- */
-
-#include <gtest/gtest.h>
-#include <iostream>
-
-#include "vnode.h"
-
-static STSchema *vtCreateBasicSchema() {
-  STSchemaBuilder sb;
-  STSchema *      pSchema = NULL;
-
-  tdInitTSchemaBuilder(&sb, 0);
-
-  tdAddColToSchema(&sb, TSDB_DATA_TYPE_TIMESTAMP, 0, 0);
-  for (int i = 1; i < 10; i++) {
-    tdAddColToSchema(&sb, TSDB_DATA_TYPE_INT, i, 0);
-  }
-
-  pSchema = tdGetSchemaFromBuilder(&sb);
-
-  tdDestroyTSchemaBuilder(&sb);
-
-  return pSchema;
-}
-
-static STSchema *vtCreateBasicTagSchema() {
-  STSchemaBuilder sb;
-  STSchema *      pSchema = NULL;
-
-  tdInitTSchemaBuilder(&sb, 0);
-
-  tdAddColToSchema(&sb, TSDB_DATA_TYPE_TIMESTAMP, 0, 0);
-  for (int i = 10; i < 12; i++) {
-    tdAddColToSchema(&sb, TSDB_DATA_TYPE_BINARY, i, 20);
-  }
-
-  pSchema = tdGetSchemaFromBuilder(&sb);
-
-  tdDestroyTSchemaBuilder(&sb);
-
-  return pSchema;
-}
-
-static SKVRow vtCreateBasicTag() {
-  SKVRowBuilder rb;
-  SKVRow        pTag;
-
-  tdInitKVRowBuilder(&rb);
-
-  for (int i = 0; i < 2; i++) {
-    void *pVal = malloc(sizeof(VarDataLenT) + strlen("foo"));
-    varDataLen(pVal) = strlen("foo");
-    memcpy(varDataVal(pVal), "foo", strlen("foo"));
-
-    tdAddColToKVRow(&rb, i, TSDB_DATA_TYPE_BINARY, pVal);
-    free(pVal);
-  }
-
-  pTag = tdGetKVRowFromBuilder(&rb);
-  tdDestroyKVRowBuilder(&rb);
-
-  return pTag;
-}
-
-static void vtBuildCreateStbReq(tb_uid_t suid, char *tbname, SRpcMsg **ppMsg) {
-  SRpcMsg * pMsg;
-  STSchema *pSchema;
-  STSchema *pTagSchema;
-  int       zs;
-  void *    pBuf;
-
-  pSchema = vtCreateBasicSchema();
-  pTagSchema = vtCreateBasicTagSchema();
-
-  SVnodeReq vCreateSTbReq;
-  vnodeSetCreateStbReq(&vCreateSTbReq, tbname, UINT32_MAX, UINT32_MAX, suid, pSchema, pTagSchema);
-
-  zs = vnodeBuildReq(NULL, &vCreateSTbReq, TDMT_VND_CREATE_STB);
-  pMsg = (SRpcMsg *)malloc(sizeof(SRpcMsg) + zs);
-  pMsg->msgType = TDMT_VND_CREATE_STB;
-  pMsg->contLen = zs;
-  pMsg->pCont = POINTER_SHIFT(pMsg, sizeof(SRpcMsg));
-
-  pBuf = pMsg->pCont;
-  vnodeBuildReq(&pBuf, &vCreateSTbReq, TDMT_VND_CREATE_STB);
-  META_CLEAR_TB_CFG(&vCreateSTbReq);
-
-  tdFreeSchema(pSchema);
-  tdFreeSchema(pTagSchema);
-
-  *ppMsg = pMsg;
-}
-
-static void vtBuildCreateCtbReq(tb_uid_t suid, char *tbname, SRpcMsg **ppMsg) {
-  SRpcMsg *pMsg;
-  int      tz;
-  SKVRow   pTag = vtCreateBasicTag();
-
-  SVnodeReq vCreateCTbReq;
-  vnodeSetCreateCtbReq(&vCreateCTbReq, tbname, UINT32_MAX, UINT32_MAX, suid, pTag);
-
-  tz = vnodeBuildReq(NULL, &vCreateCTbReq, TDMT_VND_CREATE_TABLE);
-  pMsg = (SRpcMsg *)malloc(sizeof(SRpcMsg) + tz);
-  pMsg->msgType = TDMT_VND_CREATE_TABLE;
-  pMsg->contLen = tz;
-  pMsg->pCont = POINTER_SHIFT(pMsg, sizeof(*pMsg));
-  void *pBuf = pMsg->pCont;
-
-  vnodeBuildReq(&pBuf, &vCreateCTbReq, TDMT_VND_CREATE_TABLE);
-  META_CLEAR_TB_CFG(&vCreateCTbReq);
-  free(pTag);
-
-  *ppMsg = pMsg;
-}
-
-static void vtBuildCreateNtbReq(char *tbname, SRpcMsg **ppMsg) {
-  // TODO
-}
-
-static void vtBuildSubmitReq(SRpcMsg **ppMsg) {
-  SRpcMsg *   pMsg;
-  SSubmitMsg *pSubmitMsg;
-  SSubmitBlk *pSubmitBlk;
-  int         tz = 1024;  // TODO
-
-  pMsg = (SRpcMsg *)malloc(sizeof(*pMsg) + tz);
-  pMsg->msgType = TDMT_VND_SUBMIT;
-  pMsg->contLen = tz;
-  pMsg->pCont = POINTER_SHIFT(pMsg, sizeof(*pMsg));
-
-  // For submit msg header
-  pSubmitMsg = (SSubmitMsg *)(pMsg->pCont);
-  // pSubmitMsg->header.contLen = 0;
-  // pSubmitMsg->header.vgId = 0;
-  // pSubmitMsg->length = 0;
-  pSubmitMsg->numOfBlocks = 1;
-
-  // For submit blk
-  pSubmitBlk = (SSubmitBlk *)(pSubmitMsg->blocks);
-  pSubmitBlk->uid = 0;
-  pSubmitBlk->tid = 0;
-  pSubmitBlk->padding = 0;
-  pSubmitBlk->sversion = 0;
-  pSubmitBlk->dataLen = 0;
-  pSubmitBlk->numOfRows = 0;
-
-  // For row batch
-
-  *ppMsg = pMsg;
-}
-
-static void vtClearMsgBatch(SArray *pMsgArr) {
-  SRpcMsg *pMsg;
-  for (size_t i = 0; i < taosArrayGetSize(pMsgArr); i++) {
-    pMsg = *(SRpcMsg **)taosArrayGet(pMsgArr, i);
-    free(pMsg);
-  }
-
-  taosArrayClear(pMsgArr);
-}
-
-static void vtProcessAndApplyReqs(SVnode *pVnode, SArray *pMsgArr) {
-  int      rcode;
-  SRpcMsg *pReq;
-  SRpcMsg *pRsp;
-
-  rcode = vnodeProcessWMsgs(pVnode, pMsgArr);
-  GTEST_ASSERT_EQ(rcode, 0);
-
-  for (size_t i = 0; i < taosArrayGetSize(pMsgArr); i++) {
-    pReq = *(SRpcMsg **)taosArrayGet(pMsgArr, i);
-    rcode = vnodeApplyWMsg(pVnode, pReq, NULL);
-    GTEST_ASSERT_EQ(rcode, 0);
-  }
-}
-
-TEST(vnodeApiTest, vnode_simple_create_table_test) {
-  tb_uid_t suid = 1638166374163;
-  SRpcMsg *pMsg;
-  SArray * pMsgArr = NULL;
-  SVnode * pVnode;
-  int      rcode;
-  int      ntables = 1000000;
-  int      batch = 10;
-  char     tbname[128];
-
-  pMsgArr = (SArray *)taosArrayInit(batch, sizeof(pMsg));
-
-  vnodeDestroy("vnode1");
-  GTEST_ASSERT_GE(vnodeInit(2), 0);
-
-  // CREATE AND OPEN A VNODE
-  pVnode = vnodeOpen("vnode1", NULL);
-  ASSERT_NE(pVnode, nullptr);
-
-  // CREATE A SUPER TABLE
-  sprintf(tbname, "st");
-  vtBuildCreateStbReq(suid, tbname, &pMsg);
-  taosArrayPush(pMsgArr, &pMsg);
-  vtProcessAndApplyReqs(pVnode, pMsgArr);
-  vtClearMsgBatch(pMsgArr);
-
-  // CREATE A LOT OF CHILD TABLES
-  for (int i = 0; i < ntables / batch; i++) {
-    // Build request batch
-    for (int j = 0; j < batch; j++) {
-      sprintf(tbname, "ct%d", i * batch + j + 1);
-      vtBuildCreateCtbReq(suid, tbname, &pMsg);
-      taosArrayPush(pMsgArr, &pMsg);
-    }
-
-    // Process request batch
-    vtProcessAndApplyReqs(pVnode, pMsgArr);
-
-    // Clear request batch
-    vtClearMsgBatch(pMsgArr);
-  }
-
-  // CLOSE THE VNODE
-  vnodeClose(pVnode);
-  vnodeClear();
-
-  taosArrayDestroy(pMsgArr);
-}
-
-TEST(vnodeApiTest, vnode_simple_insert_test) {
-  const char *vname = "vnode2";
-  char        tbname[128];
-  tb_uid_t    suid = 1638166374163;
-  SRpcMsg *   pMsg;
-  SArray *    pMsgArr;
-  int         rcode;
-  SVnode *    pVnode;
-  int         batch = 1;
-  int         loop = 1000000;
-
-  pMsgArr = (SArray *)taosArrayInit(0, sizeof(pMsg));
-
-  vnodeDestroy(vname);
-
-  GTEST_ASSERT_GE(vnodeInit(2), 0);
-
-  // Open a vnode
-  pVnode = vnodeOpen(vname, NULL);
-  GTEST_ASSERT_NE(pVnode, nullptr);
-
-  // 1. CREATE A SUPER TABLE
-  sprintf(tbname, "st");
-  vtBuildCreateStbReq(suid, tbname, &pMsg);
-  taosArrayPush(pMsgArr, &pMsg);
-  vtProcessAndApplyReqs(pVnode, pMsgArr);
-  vtClearMsgBatch(pMsgArr);
-
-  // 2. CREATE A CHILD TABLE
-  sprintf(tbname, "t0");
-  vtBuildCreateCtbReq(suid, tbname, &pMsg);
-  taosArrayPush(pMsgArr, &pMsg);
-  vtProcessAndApplyReqs(pVnode, pMsgArr);
-  vtClearMsgBatch(pMsgArr);
-
-  // 3. WRITE A LOT OF TIME-SERIES DATA
-  for (int j = 0; j < loop; j++) {
-    for (int i = 0; i < batch; i++) {
-      vtBuildSubmitReq(&pMsg);
-      taosArrayPush(pMsgArr, &pMsg);
-    }
-    vtProcessAndApplyReqs(pVnode, pMsgArr);
-    vtClearMsgBatch(pMsgArr);
-  }
-
-  // Close the vnode
-  vnodeClose(pVnode);
-  vnodeClear();
-
-  taosArrayDestroy(pMsgArr);
-}
\ No newline at end of file

include/dnode/vnode/vnode.h → source/dnode/vnode/inc/vnode.h

@@ -89,10 +89,10 @@ typedef struct {
 int vnodeInit(const SVnodeOpt *pOption);
 
 /**
- * @brief clear a vnode
+ * @brief Cleanup the vnode module
  *
  */
-void vnodeClear();
+void vnodeCleanup();
 
 /**
  * @brief Open a VNODE.

source/dnode/vnode/meta/src/metaSQLiteImpl.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "metaDef.h"
-#include "sqlite3.h"
-
-struct SMetaDB {
-  sqlite3 *pDB;
-};
-
-int metaOpenDB(SMeta *pMeta) {
-  char  dir[128];
-  int   rc;
-  char *err = NULL;
-
-  pMeta->pDB = (SMetaDB *)calloc(1, sizeof(SMetaDB));
-  if (pMeta->pDB == NULL) {
-    // TODO: handle error
-    return -1;
-  }
-
-  sprintf(dir, "%s/meta.db", pMeta->path);
-  rc = sqlite3_open(dir, &(pMeta->pDB->pDB));
-  if (rc != SQLITE_OK) {
-    // TODO: handle error
-    printf("failed to open meta.db\n");
-  }
-
-  // For all tables
-  rc = sqlite3_exec(pMeta->pDB->pDB,
-                    "CREATE TABLE IF NOT EXISTS tb ("
-                    "  tbname VARCHAR(256) NOT NULL UNIQUE,"
-                    "  tb_uid INTEGER NOT NULL UNIQUE "
-                    ");",
-                    NULL, NULL, &err);
-  if (rc != SQLITE_OK) {
-    // TODO: handle error
-    printf("failed to create meta table tb since %s\n", err);
-  }
-
-  // For super tables
-  rc = sqlite3_exec(pMeta->pDB->pDB,
-                    "CREATE TABLE IF NOT EXISTS stb ("
-                    "    tb_uid INTEGER NOT NULL UNIQUE,"
-                    "    tbname VARCHAR(256) NOT NULL UNIQUE,"
-                    "    tb_schema BLOB NOT NULL,"
-                    "    tag_schema BLOB NOT NULL"
-                    ");",
-                    NULL, NULL, &err);
-  if (rc != SQLITE_OK) {
-    // TODO: handle error
-    printf("failed to create meta table stb since %s\n", err);
-  }
-
-  // For normal tables
-  rc = sqlite3_exec(pMeta->pDB->pDB,
-                    "CREATE TABLE IF NOT EXISTS ntb ("
-                    "    tb_uid INTEGER NOT NULL UNIQUE,"
-                    "    tbname VARCHAR(256) NOT NULL,"
-                    "    tb_schema BLOB NOT NULL"
-                    ");",
-                    NULL, NULL, &err);
-  if (rc != SQLITE_OK) {
-    // TODO: handle error
-    printf("failed to create meta table ntb since %s\n", err);
-  }
-
-  sqlite3_exec(pMeta->pDB->pDB, "BEGIN;", NULL, NULL, &err);
-
-  tfree(err);
-
-  return 0;
-}
-
-void metaCloseDB(SMeta *pMeta) {
-  if (pMeta->pDB) {
-    sqlite3_exec(pMeta->pDB->pDB, "COMMIT;", NULL, NULL, NULL);
-    sqlite3_close(pMeta->pDB->pDB);
-    free(pMeta->pDB);
-    pMeta->pDB = NULL;
-  }
-
-  // TODO
-}
-
-int metaSaveTableToDB(SMeta *pMeta, const STbCfg *pTbCfg) {
-  char          sql[256];
-  char *        err = NULL;
-  int           rc;
-  tb_uid_t      uid;
-  sqlite3_stmt *stmt;
-  char          buf[256];
-  void *        pBuf;
-
-  switch (pTbCfg->type) {
-    case META_SUPER_TABLE:
-      uid = pTbCfg->stbCfg.suid;
-      sprintf(sql,
-              "INSERT INTO tb VALUES (\'%s\', %" PRIu64
-              ");"
-              "CREATE TABLE IF NOT EXISTS stb_%" PRIu64
-              " ("
-              "    tb_uid INTEGER NOT NULL UNIQUE,"
-              "    tbname VARCHAR(256),"
-              "    tag1 INTEGER);",
-              pTbCfg->name, uid, uid);
-      rc = sqlite3_exec(pMeta->pDB->pDB, sql, NULL, NULL, &err);
-      if (rc != SQLITE_OK) {
-        printf("failed to create normal table since %s\n", err);
-      }
-
-      sprintf(sql, "INSERT INTO stb VALUES (%" PRIu64 ", %s, ?, ?)", uid, pTbCfg->name);
-      sqlite3_prepare_v2(pMeta->pDB->pDB, sql, -1, &stmt, NULL);
-
-      pBuf = buf;
-      tdEncodeSchema(&pBuf, pTbCfg->stbCfg.pSchema);
-      sqlite3_bind_blob(stmt, 1, buf, POINTER_DISTANCE(pBuf, buf), NULL);
-      pBuf = buf;
-      tdEncodeSchema(&pBuf, pTbCfg->stbCfg.pTagSchema);
-      sqlite3_bind_blob(stmt, 2, buf, POINTER_DISTANCE(pBuf, buf), NULL);
-
-      sqlite3_step(stmt);
-
-      sqlite3_finalize(stmt);
-
-#if 0
-      sprintf(sql,
-              "INSERT INTO tb VALUES (?, ?);"
-              // "INSERT INTO stb VALUES (?, ?, ?, ?);"
-              // "CREATE TABLE IF NOT EXISTS stb_%" PRIu64
-              // " ("
-              // "    tb_uid INTEGER NOT NULL UNIQUE,"
-              // "    tbname VARCHAR(256),"
-              // "    tag1 INTEGER);"
-              ,
-              uid);
-      rc = sqlite3_prepare_v2(pMeta->pDB->pDB, sql, -1, &stmt, NULL);
-      if (rc != SQLITE_OK) {
-        return -1;
-      }
-      sqlite3_bind_text(stmt, 1, pTbCfg->name, -1, SQLITE_TRANSIENT);
-      sqlite3_bind_int64(stmt, 2, uid);
-      sqlite3_step(stmt);
-      sqlite3_finalize(stmt);
-
-
-      // sqlite3_bind_int64(stmt, 3, uid);
-      // sqlite3_bind_text(stmt, 4, pTbCfg->name, -1, SQLITE_TRANSIENT);
-      // pBuf = buf;
-      // tdEncodeSchema(&pBuf, pTbCfg->stbCfg.pSchema);
-      // sqlite3_bind_blob(stmt, 5, buf, POINTER_DISTANCE(pBuf, buf), NULL);
-      // pBuf = buf;
-      // tdEncodeSchema(&pBuf, pTbCfg->stbCfg.pTagSchema);
-      // sqlite3_bind_blob(stmt, 6, buf, POINTER_DISTANCE(pBuf, buf), NULL);
-
-      rc = sqliteVjj3_step(stmt);
-      if (rc != SQLITE_OK) {
-        printf("failed to create normal table since %s\n", sqlite3_errmsg(pMeta->pDB->pDB));
-      }
-      sqlite3_finalize(stmt);
-#endif
-      break;
-    case META_NORMAL_TABLE:
-      // uid = metaGenerateUid(pMeta);
-      // sprintf(sql,
-      //         "INSERT INTO tb VALUES (\'%s\', %" PRIu64
-      //         ");"
-      //         "INSERT INTO ntb VALUES (%" PRIu64 ", \'%s\', );",
-      //         pTbCfg->name, uid, uid, pTbCfg->name, );
-
-      // rc = sqlite3_exec(pMeta->pDB->pDB, sql, NULL, NULL, &err);
-      // if (rc != SQLITE_OK) {
-      //   printf("failed to create normal table since %s\n", err);
-      // }
-      break;
-    case META_CHILD_TABLE:
-#if 0
-      uid = metaGenerateUid(pMeta);
-      // sprintf(sql, "INSERT INTO tb VALUES (\'%s\', %" PRIu64
-      //              ");"
-      //              "INSERT INTO stb_%" PRIu64 " VALUES (%" PRIu64 ", \'%s\', );");
-      rc = sqlite3_exec(pMeta->pDB->pDB, sql, NULL, NULL, &err);
-      if (rc != SQLITE_OK) {
-        printf("failed to create child table since %s\n", err);
-      }
-#endif
-      break;
-    default:
-      break;
-  }
-
-  tfree(err);
-
-  return 0;
-}
-
-int metaRemoveTableFromDb(SMeta *pMeta, tb_uid_t uid) {
-  /* TODO */
-  return 0;
-}
\ No newline at end of file

source/dnode/vnode/meta/test/CMakeLists.txt

-# add_executable(metaTest "")
-# target_sources(metaTest
-#     PRIVATE
-#     "../src/metaMain.c"
-#     "../src/metaUid.c"
-#     "metaTests.cpp"
-# )
-# target_include_directories(metaTest 
-#     PUBLIC
-#     "${CMAKE_SOURCE_DIR}/include/server/vnode/meta"
-#     "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
-# )
-# target_link_libraries(metaTest
-#     os
-#     util
-#     common
-#     gtest_main
-#     tkv
-# )
-# enable_testing()
-# add_test(
-#     NAME meta_test
-#     COMMAND metaTest
-# )

source/dnode/vnode/meta/test/metaAPITest.cpp

-#if 0
-#include <gtest/gtest.h>
-#include <string.h>
-#include <iostream>
-
-#include "meta.h"
-
-static STSchema *metaGetSimpleSchema() {
-  STSchema *      pSchema = NULL;
-  STSchemaBuilder sb = {0};
-
-  tdInitTSchemaBuilder(&sb, 0);
-  tdAddColToSchema(&sb, TSDB_DATA_TYPE_TIMESTAMP, 0, 8);
-  tdAddColToSchema(&sb, TSDB_DATA_TYPE_INT, 1, 4);
-
-  pSchema = tdGetSchemaFromBuilder(&sb);
-  tdDestroyTSchemaBuilder(&sb);
-
-  return pSchema;
-}
-
-static SKVRow metaGetSimpleTags() {
-  SKVRowBuilder kvrb = {0};
-  SKVRow        row;
-
-  tdInitKVRowBuilder(&kvrb);
-  int64_t ts = 1634287978000;
-  int32_t a = 10;
-
-  tdAddColToKVRow(&kvrb, 0, TSDB_DATA_TYPE_TIMESTAMP, (void *)(&ts));
-  tdAddColToKVRow(&kvrb, 0, TSDB_DATA_TYPE_INT, (void *)(&a));
-
-  row = tdGetKVRowFromBuilder(&kvrb);
-
-  tdDestroyKVRowBuilder(&kvrb);
-
-  return row;
-}
-
-TEST(MetaTest, DISABLED_meta_create_1m_normal_tables_test) {
-  // Open Meta
-  SMeta *meta = metaOpen(NULL, NULL);
-  std::cout << "Meta is opened!" << std::endl;
-
-  // Create 1000000 normal tables
-  META_TABLE_OPTS_DECLARE(tbOpts);
-  STSchema *pSchema = metaGetSimpleSchema();
-  char      tbname[128];
-
-  for (size_t i = 0; i < 1000000; i++) {
-    sprintf(tbname, "ntb%ld", i);
-    metaNormalTableOptsInit(&tbOpts, tbname, pSchema);
-    metaCreateTable(meta, &tbOpts);
-    metaTableOptsClear(&tbOpts);
-  }
-
-  tdFreeSchema(pSchema);
-
-  // Close Meta
-  metaClose(meta);
-  std::cout << "Meta is closed!" << std::endl;
-
-  // Destroy Meta
-  metaDestroy("meta");
-  std::cout << "Meta is destroyed!" << std::endl;
-}
-
-TEST(MetaTest, meta_create_1m_child_tables_test) {
-  // Open Meta
-  SMeta *meta = metaOpen(NULL);
-  std::cout << "Meta is opened!" << std::endl;
-
-  // Create a super tables
-  tb_uid_t uid = 477529885843758ul;
-  META_TABLE_OPTS_DECLARE(tbOpts);
-  STSchema *pSchema = metaGetSimpleSchema();
-  STSchema *pTagSchema = metaGetSimpleSchema();
-
-  metaSuperTableOptsInit(&tbOpts, "st", uid, pSchema, pTagSchema);
-  metaCreateTable(meta, &tbOpts);
-  metaTableOptsClear(&tbOpts);
-
-  tdFreeSchema(pSchema);
-  tdFreeSchema(pTagSchema);
-
-  // Create 1000000 child tables
-  char   name[128];
-  SKVRow row = metaGetSimpleTags();
-  for (size_t i = 0; i < 1000000; i++) {
-    sprintf(name, "ctb%ld", i);
-    metaChildTableOptsInit(&tbOpts, name, uid, row);
-    metaCreateTable(meta, &tbOpts);
-    metaTableOptsClear(&tbOpts);
-  }
-  kvRowFree(row);
-
-  // Close Meta
-  metaClose(meta);
-  std::cout << "Meta is closed!" << std::endl;
-
-  // Destroy Meta
-  metaDestroy("meta");
-  std::cout << "Meta is destroyed!" << std::endl;
-}
-#endif
\ No newline at end of file

source/dnode/vnode/impl/inc/vnodeDef.h → source/dnode/vnode/src/inc/vnodeDef.h

@@ -17,7 +17,7 @@
 #define _TD_VNODE_DEF_H_
 
 #include "mallocator.h"
-#include "sync.h"
+// #include "sync.h"
 #include "tcoding.h"
 #include "tlist.h"
 #include "tlockfree.h"

source/dnode/vnode/impl/inc/vnodeInt.h → source/dnode/vnode/src/inc/vnodeInt.h

@@ -19,7 +19,7 @@
 #include "vnode.h"
 
 #include "meta.h"
-#include "sync.h"
+// #include "sync.h"
 #include "tlog.h"
 #include "tq.h"
 #include "tsdb.h"

source/dnode/vnode/impl/inc/vnodeSync.h → source/dnode/vnode/src/inc/vnodeSync.h

@@ -16,7 +16,7 @@
 #ifndef _TD_VNODE_SYNC_H_
 #define _TD_VNODE_SYNC_H_
 
-#include "sync.h"
+// #include "sync.h"
 
 #ifdef __cplusplus
 extern "C" {

source/dnode/vnode/meta/src/metaIdx.c → source/dnode/vnode/src/meta/metaIdx.c

@@ -13,7 +13,9 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifdef USE_INVERTED_INDEX
 #include "index.h"
+#endif
 #include "metaDef.h"
 
 struct SMetaIdx {

source/dnode/vnode/src/tsdb/tsdbHealth.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// #include "os.h"
+// #include "tmsg.h"
+// #include "tarray.h"
+// #include "query.h"
+// #include "tglobal.h"
+// #include "tlist.h"
+// #include "tsdbint.h"
+// #include "tsdbBuffer.h"
+// #include "tsdbLog.h"
+// #include "tsdbHealth.h"
+// #include "ttimer.h"
+// #include "tthread.h"
+
+
+// // return malloc new block count 
+// int32_t tsdbInsertNewBlock(STsdbRepo * pRepo) {
+//   STsdbBufPool *pPool = pRepo->pPool;
+//   int32_t cnt = 0;
+
+//   if(tsdbAllowNewBlock(pRepo)) {
+//     STsdbBufBlock *pBufBlock = tsdbNewBufBlock(pPool->bufBlockSize);
+//     if (pBufBlock) {
+//         if (tdListAppend(pPool->bufBlockList, (void *)(&pBufBlock)) < 0) {
+//           // append error
+//           tsdbFreeBufBlock(pBufBlock);
+//         } else {
+//           pPool->nElasticBlocks ++;
+//           cnt ++ ;
+//         }
+//     }
+//  } 
+//  return cnt;
+// }
+
+// // switch anther thread to run
+// void* cbKillQueryFree(void* param) {
+//   STsdbRepo* pRepo =  (STsdbRepo*)param;
+//   // vnode
+//   if(pRepo->appH.notifyStatus) {
+//     pRepo->appH.notifyStatus(pRepo->appH.appH, TSDB_STATUS_COMMIT_NOBLOCK, TSDB_CODE_SUCCESS);
+//   }
+
+//   // free 
+//   if(pRepo->pthread){
+//     void* p = pRepo->pthread;
+//     pRepo->pthread = NULL;
+//     free(p);
+//   }
+
+//   return NULL;
+// }
+
+// // return true do free , false do nothing
+// bool tsdbUrgeQueryFree(STsdbRepo * pRepo) {
+//   // check previous running
+//   if(pRepo->pthread && taosThreadRunning(pRepo->pthread)) {
+//     tsdbWarn("vgId:%d pre urge thread is runing. nBlocks=%d nElasticBlocks=%d", REPO_ID(pRepo), pRepo->pPool->nBufBlocks, pRepo->pPool->nElasticBlocks);
+//     return false;
+//   }
+//   // create new
+//   pRepo->pthread = taosCreateThread(cbKillQueryFree, pRepo);
+//   if(pRepo->pthread == NULL) {
+//     tsdbError("vgId:%d create urge thread error.", REPO_ID(pRepo));
+//     return false;
+//   }
+//   return true;
+// }
+
+// bool tsdbAllowNewBlock(STsdbRepo* pRepo) {
+//   int32_t nMaxElastic = pRepo->config.totalBlocks/3;
+//   STsdbBufPool* pPool = pRepo->pPool;
+//   if(pPool->nElasticBlocks >= nMaxElastic) {
+//     tsdbWarn("vgId:%d tsdbAllowNewBlock return fasle. nElasticBlock(%d) >= MaxElasticBlocks(%d)", REPO_ID(pRepo), pPool->nElasticBlocks, nMaxElastic);
+//     return false;
+//   }
+//   return true;
+// }
+
+// bool tsdbNoProblem(STsdbRepo* pRepo) {
+//   if(listNEles(pRepo->pPool->bufBlockList) == 0) 
+//      return false;
+//   return true;
+// }
\ No newline at end of file

source/dnode/vnode/tsdb/src/tsdbRead.c → source/dnode/vnode/src/tsdb/tsdbRead.c

@@ -28,7 +28,7 @@
 
 #include "taosdef.h"
 #include "tlosertree.h"
-#include "tsdbint.h"
+#include "tsdbDef.h"
 #include "tmsg.h"
 
 #define EXTRA_BYTES 2

source/dnode/vnode/tsdb/src/tsdbRowMergeBuf.c → source/dnode/vnode/src/tsdb/tsdbRowMergeBuf.c

@@ -13,18 +13,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "tsdbRowMergeBuf.h"
-#include "tdataformat.h"
+// #include "tsdbRowMergeBuf.h"
+// #include "tdataformat.h"
 
-// row1 has higher priority
-SMemRow tsdbMergeTwoRows(SMergeBuf *pBuf, SMemRow row1, SMemRow row2, STSchema *pSchema1, STSchema *pSchema2) {
-  if(row2 == NULL) return row1;
-  if(row1 == NULL) return row2;
-  ASSERT(pSchema1->version == memRowVersion(row1)); 
-  ASSERT(pSchema2->version == memRowVersion(row2));
+// // row1 has higher priority
+// SMemRow tsdbMergeTwoRows(SMergeBuf *pBuf, SMemRow row1, SMemRow row2, STSchema *pSchema1, STSchema *pSchema2) {
+//   if(row2 == NULL) return row1;
+//   if(row1 == NULL) return row2;
+//   ASSERT(pSchema1->version == memRowVersion(row1)); 
+//   ASSERT(pSchema2->version == memRowVersion(row2));
 
-  if(tsdbMergeBufMakeSureRoom(pBuf, pSchema1, pSchema2) < 0) {
-    return NULL;
-  }
-  return mergeTwoMemRows(*pBuf, row1, row2, pSchema1, pSchema2);
-}
+//   if(tsdbMergeBufMakeSureRoom(pBuf, pSchema1, pSchema2) < 0) {
+//     return NULL;
+//   }
+//   return mergeTwoMemRows(*pBuf, row1, row2, pSchema1, pSchema2);
+// }

source/dnode/vnode/tsdb/src/tsdbScan.c → source/dnode/vnode/src/tsdb/tsdbScan.c

@@ -13,9 +13,9 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "tsdbint.h"
 
 #if 0
+#include "tsdbint.h"
 #ifndef _TSDB_PLUGINS
 
 int tsdbScanFGroup(STsdbScanHandle* pScanHandle, char* rootDir, int fid) { return 0; }

source/dnode/vnode/impl/src/vnodeMgr.c → source/dnode/vnode/src/vnd/vnodeMgr.c

@@ -56,13 +56,11 @@ int vnodeInit(const SVnodeOpt *pOption) {
   return 0;
 }
 
-void vnodeClear() {
+void vnodeCleanup() {
   if (TD_CHECK_AND_SET_MOD_CLEAR(&(vnodeMgr.vnodeInitFlag)) == TD_MOD_UNINITIALIZED) {
     return;
   }
 
-  walCleanUp();
-
   // Stop commit handler
   pthread_mutex_lock(&(vnodeMgr.mutex));
   vnodeMgr.stop = true;

source/dnode/vnode/impl/src/vnodeWrite.c → source/dnode/vnode/src/vnd/vnodeWrite.c

@@ -83,7 +83,17 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
         if (metaCreateTable(pVnode->pMeta, pCreateTbReq) < 0) {
           // TODO: handle error
         }
+        if (pCreateTbReq->type == TD_SUPER_TABLE) {
+          free(pCreateTbReq->stbCfg.pSchema);
+          free(pCreateTbReq->stbCfg.pTagSchema);
+        } else if (pCreateTbReq->type == TD_CHILD_TABLE) {
+          free(pCreateTbReq->ctbCfg.pTag);
+        } else {
+          free(pCreateTbReq->ntbCfg.pSchema);
         }
+      }
+      taosArrayDestroy(vCreateTbBatchReq.pArray);
+      break;
 
     case TDMT_VND_DROP_STB:
     case TDMT_VND_DROP_TABLE:

source/dnode/vnode/tsdb/inc/tsdbint.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_TSDB_INT_H_
-#define _TD_TSDB_INT_H_
-
-#if 0
-// // TODO: remove the include
-// #include <errno.h>
-// #include <fcntl.h>
-// #include <limits.h>
-// #include <inttypes.h>
-// #include <sys/stat.h>
-// #include <sys/types.h>
-// #include <semaphore.h>
-// #include <dirent.h>
-
-#include "hash.h"
-#include "os.h"
-#include "taosdef.h"
-#include "taoserror.h"
-#include "tarray.h"
-#include "tchecksum.h"
-#include "tcoding.h"
-#include "tcompression.h"
-#include "tdataformat.h"
-#include "tfs.h"
-#include "tlist.h"
-#include "tlockfree.h"
-#include "tlog.h"
-#include "tskiplist.h"
-#include "tsocket.h"
-
-#include "tsdb.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Log
-#include "tsdbLog.h"
-// Meta
-#include "tsdbMeta.h"
-// Buffer
-#include "tsdbBuffer.h"
-// MemTable
-#include "tsdbMemTable.h"
-// File
-#include "tsdbFile.h"
-// FS
-#include "tsdbFS.h"
-// ReadImpl
-#include "tsdbReadImpl.h"
-// Commit
-#include "tsdbCommit.h"
-// Compact
-#include "tsdbCompact.h"
-// Commit Queue
-#include "tsdbCommitQueue.h"
-
-#include "tsdbRowMergeBuf.h"
-// Main definitions
-struct STsdbRepo {
-  uint8_t state;
-
-  STsdbCfg        config;
-
-  STsdbCfg        save_config;    // save apply config
-  bool            config_changed; // config changed flag
-  pthread_mutex_t save_mutex;     // protect save config
-  
-  uint8_t         hasCachedLastColumn;
-
-  STsdbAppH       appH;
-  STsdbStat       stat;
-  STsdbMeta*      tsdbMeta;
-  STsdbBufPool*   pPool;
-  SMemTable*      mem;
-  SMemTable*      imem;
-  STsdbFS*        fs;
-  SRtn            rtn;
-  tsem_t          readyToCommit;
-  pthread_mutex_t mutex;
-  bool            repoLocked;
-  int32_t         code;  // Commit code
-
-  SMergeBuf       mergeBuf;  //used when update=2
-  int8_t          compactState;  // compact state: inCompact/noCompact/waitingCompact?
-  pthread_t*      pthread;
-};
-
-#define REPO_ID(r) (r)->config.tsdbId
-#define REPO_CFG(r) (&((r)->config))
-#define REPO_FS(r) ((r)->fs)
-#define IS_REPO_LOCKED(r) (r)->repoLocked
-#define TSDB_SUBMIT_MSG_HEAD_SIZE sizeof(SSubmitMsg)
-
-int        tsdbLockRepo(STsdbRepo* pRepo);
-int        tsdbUnlockRepo(STsdbRepo* pRepo);
-STsdbMeta* tsdbGetMeta(STsdbRepo* pRepo);
-int        tsdbCheckCommit(STsdbRepo* pRepo);
-int        tsdbRestoreInfo(STsdbRepo* pRepo);
-int        tsdbCacheLastData(STsdbRepo *pRepo, STsdbCfg* oldCfg);
-void       tsdbGetRootDir(int repoid, char dirName[]);
-void       tsdbGetDataDir(int repoid, char dirName[]);
-
-static FORCE_INLINE STsdbBufBlock* tsdbGetCurrBufBlock(STsdbRepo* pRepo) {
-  ASSERT(pRepo != NULL);
-  if (pRepo->mem == NULL) return NULL;
-
-  SListNode* pNode = listTail(pRepo->mem->bufBlockList);
-  if (pNode == NULL) return NULL;
-
-  STsdbBufBlock* pBufBlock = NULL;
-  tdListNodeGetData(pRepo->mem->bufBlockList, pNode, (void*)(&pBufBlock));
-
-  return pBufBlock;
-}
-
-static FORCE_INLINE int tsdbGetNextMaxTables(int tid) {
-  ASSERT(tid >= 1 && tid <= TSDB_MAX_TABLES);
-  int maxTables = TSDB_INIT_NTABLES;
-  while (true) {
-    maxTables = MIN(maxTables, TSDB_MAX_TABLES);
-    if (tid <= maxTables) break;
-    maxTables *= 2;
-  }
-
-  return maxTables + 1;
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-#endif /* _TD_TSDB_INT_H_ */

source/dnode/vnode/tsdb/src/tsdbHealth.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "os.h"
-#include "tmsg.h"
-#include "tarray.h"
-#include "query.h"
-#include "tglobal.h"
-#include "tlist.h"
-#include "tsdbint.h"
-#include "tsdbBuffer.h"
-#include "tsdbLog.h"
-#include "tsdbHealth.h"
-#include "ttimer.h"
-#include "tthread.h"
-
-
-// return malloc new block count 
-int32_t tsdbInsertNewBlock(STsdbRepo * pRepo) {
-  STsdbBufPool *pPool = pRepo->pPool;
-  int32_t cnt = 0;
-
-  if(tsdbAllowNewBlock(pRepo)) {
-    STsdbBufBlock *pBufBlock = tsdbNewBufBlock(pPool->bufBlockSize);
-    if (pBufBlock) {
-        if (tdListAppend(pPool->bufBlockList, (void *)(&pBufBlock)) < 0) {
-          // append error
-          tsdbFreeBufBlock(pBufBlock);
-        } else {
-          pPool->nElasticBlocks ++;
-          cnt ++ ;
-        }
-    }
- } 
- return cnt;
-}
-
-// switch anther thread to run
-void* cbKillQueryFree(void* param) {
-  STsdbRepo* pRepo =  (STsdbRepo*)param;
-  // vnode
-  if(pRepo->appH.notifyStatus) {
-    pRepo->appH.notifyStatus(pRepo->appH.appH, TSDB_STATUS_COMMIT_NOBLOCK, TSDB_CODE_SUCCESS);
-  }
-
-  // free 
-  if(pRepo->pthread){
-    void* p = pRepo->pthread;
-    pRepo->pthread = NULL;
-    free(p);
-  }
-
-  return NULL;
-}
-
-// return true do free , false do nothing
-bool tsdbUrgeQueryFree(STsdbRepo * pRepo) {
-  // check previous running
-  if(pRepo->pthread && taosThreadRunning(pRepo->pthread)) {
-    tsdbWarn("vgId:%d pre urge thread is runing. nBlocks=%d nElasticBlocks=%d", REPO_ID(pRepo), pRepo->pPool->nBufBlocks, pRepo->pPool->nElasticBlocks);
-    return false;
-  }
-  // create new
-  pRepo->pthread = taosCreateThread(cbKillQueryFree, pRepo);
-  if(pRepo->pthread == NULL) {
-    tsdbError("vgId:%d create urge thread error.", REPO_ID(pRepo));
-    return false;
-  }
-  return true;
-}
-
-bool tsdbAllowNewBlock(STsdbRepo* pRepo) {
-  int32_t nMaxElastic = pRepo->config.totalBlocks/3;
-  STsdbBufPool* pPool = pRepo->pPool;
-  if(pPool->nElasticBlocks >= nMaxElastic) {
-    tsdbWarn("vgId:%d tsdbAllowNewBlock return fasle. nElasticBlock(%d) >= MaxElasticBlocks(%d)", REPO_ID(pRepo), pPool->nElasticBlocks, nMaxElastic);
-    return false;
-  }
-  return true;
-}
-
-bool tsdbNoProblem(STsdbRepo* pRepo) {
-  if(listNEles(pRepo->pPool->bufBlockList) == 0) 
-     return false;
-  return true;
-}
\ No newline at end of file

source/dnode/vnode/tsdb/src/tsdbSync.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 "os.h"
-#include "taoserror.h"
-#include "tsdbint.h"
-
-// Sync handle
-typedef struct {
-  STsdbRepo *pRepo;
-  SRtn       rtn;
-  SOCKET     socketFd;
-  void *     pBuf;
-  bool       mfChanged;
-  SMFile *   pmf;
-  SMFile     mf;
-  SDFileSet  df;
-  SDFileSet *pdf;
-} SSyncH;
-
-#define SYNC_BUFFER(sh) ((sh)->pBuf)
-
-static void    tsdbInitSyncH(SSyncH *pSyncH, STsdbRepo *pRepo, SOCKET socketFd);
-static void    tsdbDestroySyncH(SSyncH *pSyncH);
-static int32_t tsdbSyncSendMeta(SSyncH *pSynch);
-static int32_t tsdbSyncRecvMeta(SSyncH *pSynch);
-static int32_t tsdbSendMetaInfo(SSyncH *pSynch);
-static int32_t tsdbRecvMetaInfo(SSyncH *pSynch);
-static int32_t tsdbSendDecision(SSyncH *pSynch, bool toSend);
-static int32_t tsdbRecvDecision(SSyncH *pSynch, bool *toSend);
-static int32_t tsdbSyncSendDFileSetArray(SSyncH *pSynch);
-static int32_t tsdbSyncRecvDFileSetArray(SSyncH *pSynch);
-static bool    tsdbIsTowFSetSame(SDFileSet *pSet1, SDFileSet *pSet2);
-static int32_t tsdbSyncSendDFileSet(SSyncH *pSynch, SDFileSet *pSet);
-static int32_t tsdbSendDFileSetInfo(SSyncH *pSynch, SDFileSet *pSet);
-static int32_t tsdbRecvDFileSetInfo(SSyncH *pSynch);
-static int     tsdbReload(STsdbRepo *pRepo, bool isMfChanged);
-
-int32_t tsdbSyncSend(void *tsdb, SOCKET socketFd) {
-  STsdbRepo *pRepo = (STsdbRepo *)tsdb;
-  SSyncH     synch = {0};
-
-  tsdbInitSyncH(&synch, pRepo, socketFd);
-  // Disable TSDB commit
-  tsem_wait(&(pRepo->readyToCommit));
-
-  if (tsdbSyncSendMeta(&synch) < 0) {
-    tsdbError("vgId:%d, failed to send metafile since %s", REPO_ID(pRepo), tstrerror(terrno));
-    goto _err;
-  }
-
-  if (tsdbSyncSendDFileSetArray(&synch) < 0) {
-    tsdbError("vgId:%d, failed to send filesets since %s", REPO_ID(pRepo), tstrerror(terrno));
-    goto _err;
-  }
-
-  // Enable TSDB commit
-  tsem_post(&(pRepo->readyToCommit));
-  tsdbDestroySyncH(&synch);
-  return 0;
-
-_err:
-  tsem_post(&(pRepo->readyToCommit));
-  tsdbDestroySyncH(&synch);
-  return -1;
-}
-
-int32_t tsdbSyncRecv(void *tsdb, SOCKET socketFd) {
-  STsdbRepo *pRepo = (STsdbRepo *)tsdb;
-  SSyncH synch = {0};
-
-  pRepo->state = TSDB_STATE_OK;
-
-  tsdbInitSyncH(&synch, pRepo, socketFd);
-  tsem_wait(&(pRepo->readyToCommit));
-  tsdbStartFSTxn(pRepo, 0, 0);
-
-  if (tsdbSyncRecvMeta(&synch) < 0) {
-    tsdbError("vgId:%d, failed to recv metafile since %s", REPO_ID(pRepo), tstrerror(terrno));
-    goto _err;
-  }
-
-  if (tsdbSyncRecvDFileSetArray(&synch) < 0) {
-    tsdbError("vgId:%d, failed to recv filesets since %s", REPO_ID(pRepo), tstrerror(terrno));
-    goto _err;
-  }
-
-  tsdbEndFSTxn(pRepo);
-  tsem_post(&(pRepo->readyToCommit));
-  tsdbDestroySyncH(&synch);
-
-  // Reload file change
-  tsdbReload(pRepo, synch.mfChanged);
-
-  return 0;
-
-_err:
-  tsdbEndFSTxnWithError(REPO_FS(pRepo));
-  tsem_post(&(pRepo->readyToCommit));
-  tsdbDestroySyncH(&synch);
-  return -1;
-}
-
-static void tsdbInitSyncH(SSyncH *pSyncH, STsdbRepo *pRepo, SOCKET socketFd) {
-  pSyncH->pRepo = pRepo;
-  pSyncH->socketFd = socketFd;
-  tsdbGetRtnSnap(pRepo, &(pSyncH->rtn));
-}
-
-static void tsdbDestroySyncH(SSyncH *pSyncH) { taosTZfree(pSyncH->pBuf); }
-
-static int32_t tsdbSyncSendMeta(SSyncH *pSynch) {
-  STsdbRepo *pRepo = pSynch->pRepo;
-  bool       toSendMeta = false;
-  SMFile     mf;
-
-  // Send meta info to remote
-  tsdbInfo("vgId:%d, metainfo will be sent", REPO_ID(pRepo));
-  if (tsdbSendMetaInfo(pSynch) < 0) {
-    tsdbError("vgId:%d, failed to send metainfo since %s", REPO_ID(pRepo), tstrerror(terrno));
-    return -1;
-  }
-
-  if (pRepo->fs->cstatus->pmf == NULL) {
-    // No meta file, not need to wait to retrieve meta file
-    tsdbInfo("vgId:%d, metafile not exist, no need to send", REPO_ID(pRepo));
-    return 0;
-  }
-
-  if (tsdbRecvDecision(pSynch, &toSendMeta) < 0) {
-    tsdbError("vgId:%d, failed to recv decision while send meta since %s", REPO_ID(pRepo), tstrerror(terrno));
-    return -1;
-  }
-
-  if (toSendMeta) {
-    tsdbInitMFileEx(&mf, pRepo->fs->cstatus->pmf);
-    if (tsdbOpenMFile(&mf, O_RDONLY) < 0) {
-      tsdbError("vgId:%d, failed to open file while send metafile since %s", REPO_ID(pRepo), tstrerror(terrno));
-      return -1;
-    }
-
-    int64_t writeLen = mf.info.size;
-    tsdbInfo("vgId:%d, metafile:%s will be sent, size:%" PRId64, REPO_ID(pRepo), mf.f.aname, writeLen);
-
-    int64_t ret = taosSendFile(pSynch->socketFd, TSDB_FILE_FD(&mf), 0, writeLen);
-    if (ret != writeLen) {
-      terrno = TAOS_SYSTEM_ERROR(errno);
-      tsdbError("vgId:%d, failed to send metafile since %s, ret:%" PRId64 " writeLen:%" PRId64, REPO_ID(pRepo),
-                tstrerror(terrno), ret, writeLen);
-      tsdbCloseMFile(&mf);
-      return -1;
-    }
-
-    tsdbCloseMFile(&mf);
-    tsdbInfo("vgId:%d, metafile is sent", REPO_ID(pRepo));
-  } else {
-    tsdbInfo("vgId:%d, metafile is same, no need to send", REPO_ID(pRepo));
-  }
-
-  return 0;
-}
-
-static int32_t tsdbSyncRecvMeta(SSyncH *pSynch) {
-  STsdbRepo *pRepo = pSynch->pRepo;
-  SMFile *   pLMFile = pRepo->fs->cstatus->pmf;
-
-  // Recv meta info from remote
-  if (tsdbRecvMetaInfo(pSynch) < 0) {
-    tsdbError("vgId:%d, failed to recv metainfo since %s", REPO_ID(pRepo), tstrerror(terrno));
-    return -1;
-  }
-
-  // No meta file, do nothing (rm local meta file)
-  if (pSynch->pmf == NULL) {
-    if (pLMFile == NULL) {
-      pSynch->mfChanged = false;
-    } else {
-      pSynch->mfChanged = true;
-    }
-    tsdbInfo("vgId:%d, metafile not exist in remote, no need to recv", REPO_ID(pRepo));
-    return 0;
-  }
-
-  if (pLMFile == NULL || pSynch->pmf->info.size != pLMFile->info.size ||
-      pSynch->pmf->info.magic != pLMFile->info.magic || TSDB_FILE_IS_BAD(pLMFile)) {
-    // Local has no meta file or has a different meta file, need to copy from remote
-    pSynch->mfChanged = true;
-
-    if (tsdbSendDecision(pSynch, true) < 0) {
-      tsdbError("vgId:%d, failed to send decision while recv metafile since %s", REPO_ID(pRepo), tstrerror(terrno));
-      return -1;
-    }
-
-    tsdbInfo("vgId:%d, metafile will be received", REPO_ID(pRepo));
-
-    // Recv from remote
-    SMFile  mf;
-    SDiskID did = {.level = TFS_PRIMARY_LEVEL, .id = TFS_PRIMARY_ID};
-    tsdbInitMFile(&mf, did, REPO_ID(pRepo), FS_TXN_VERSION(REPO_FS(pRepo)));
-    if (tsdbCreateMFile(&mf, false) < 0) {
-      tsdbError("vgId:%d, failed to create file while recv metafile since %s", REPO_ID(pRepo), tstrerror(terrno));
-      return -1;
-    }
-
-    tsdbInfo("vgId:%d, metafile:%s is created", REPO_ID(pRepo), mf.f.aname);
-
-    int64_t readLen = pSynch->pmf->info.size;
-    int64_t ret = taosCopyFds(pSynch->socketFd, TSDB_FILE_FD(&mf), readLen);
-    if (ret != readLen) {
-      terrno = TAOS_SYSTEM_ERROR(errno);
-      tsdbError("vgId:%d, failed to recv metafile since %s, ret:%" PRId64 " readLen:%" PRId64, REPO_ID(pRepo),
-                tstrerror(terrno), ret, readLen);
-      tsdbCloseMFile(&mf);
-      tsdbRemoveMFile(&mf);
-      return -1;
-    }
-
-    tsdbInfo("vgId:%d, metafile is received, size:%" PRId64, REPO_ID(pRepo), readLen);
-
-    mf.info = pSynch->pmf->info;
-    tsdbCloseMFile(&mf);
-    tsdbUpdateMFile(REPO_FS(pRepo), &mf);
-  } else {
-    pSynch->mfChanged = false;
-    tsdbInfo("vgId:%d, metafile is same, no need to recv", REPO_ID(pRepo));
-    if (tsdbSendDecision(pSynch, false) < 0) {
-      tsdbError("vgId:%d, failed to send decision while recv metafile since %s", REPO_ID(pRepo), tstrerror(terrno));
-      return -1;
-    }
-    tsdbUpdateMFile(REPO_FS(pRepo), pLMFile);
-  }
-
-  return 0;
-}
-
-static int32_t tsdbSendMetaInfo(SSyncH *pSynch) {
-  STsdbRepo *pRepo = pSynch->pRepo;
-  uint32_t   tlen = 0;
-  SMFile *   pMFile = pRepo->fs->cstatus->pmf;
-
-  if (pMFile) {
-    tlen = tlen + tsdbEncodeSMFileEx(NULL, pMFile) + sizeof(TSCKSUM);
-  }
-
-  if (tsdbMakeRoom((void **)(&SYNC_BUFFER(pSynch)), tlen + sizeof(tlen)) < 0) {
-    tsdbError("vgId:%d, failed to makeroom while send metainfo since %s", REPO_ID(pRepo), tstrerror(terrno));
-    return -1;
-  }
-
-  void *ptr = SYNC_BUFFER(pSynch);
-  taosEncodeFixedU32(&ptr, tlen);
-  void *tptr = ptr;
-  if (pMFile) {
-    tsdbEncodeSMFileEx(&ptr, pMFile);
-    taosCalcChecksumAppend(0, (uint8_t *)tptr, tlen);
-  }
-
-  int32_t writeLen = tlen + sizeof(uint32_t);
-  int32_t ret = taosWriteMsg(pSynch->socketFd, SYNC_BUFFER(pSynch), writeLen);
-  if (ret != writeLen) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    tsdbError("vgId:%d, failed to send metainfo since %s, ret:%d writeLen:%d", REPO_ID(pRepo), tstrerror(terrno), ret,
-              writeLen);
-    return -1;
-  }
-
-  tsdbInfo("vgId:%d, metainfo is sent, tlen:%d, writeLen:%d", REPO_ID(pRepo), tlen, writeLen);
-  return 0;
-}
-
-static int32_t tsdbRecvMetaInfo(SSyncH *pSynch) {
-  STsdbRepo *pRepo = pSynch->pRepo;
-  uint32_t   tlen = 0;
-  char       buf[64] = {0};
-
-  int32_t readLen = sizeof(uint32_t);
-  int32_t ret = taosReadMsg(pSynch->socketFd, buf, readLen);
-  if (ret != readLen) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    tsdbError("vgId:%d, failed to recv metalen, ret:%d readLen:%d", REPO_ID(pRepo), ret, readLen);
-    return -1;
-  }
-
-  taosDecodeFixedU32(buf, &tlen);
-
-  tsdbInfo("vgId:%d, metalen is received, readLen:%d, tlen:%d", REPO_ID(pRepo), readLen, tlen);
-  if (tlen == 0) {
-    pSynch->pmf = NULL;
-    return 0;
-  }
-
-  if (tsdbMakeRoom((void **)(&SYNC_BUFFER(pSynch)), tlen) < 0) {
-    tsdbError("vgId:%d, failed to makeroom while recv metainfo since %s", REPO_ID(pRepo), tstrerror(terrno));
-    return -1;
-  }
-
-  ret = taosReadMsg(pSynch->socketFd, SYNC_BUFFER(pSynch), tlen);
-  if (ret != tlen) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    tsdbError("vgId:%d, failed to recv metainfo, ret:%d tlen:%d", REPO_ID(pRepo), ret, tlen);
-    return -1;
-  }
-
-  tsdbInfo("vgId:%d, metainfo is received, tlen:%d", REPO_ID(pRepo), tlen);
-  if (!taosCheckChecksumWhole((uint8_t *)SYNC_BUFFER(pSynch), tlen)) {
-    terrno = TSDB_CODE_TDB_MESSED_MSG;
-    tsdbError("vgId:%d, failed to checksum while recv metainfo since %s", REPO_ID(pRepo), tstrerror(terrno));
-    return -1;
-  }
-
-  pSynch->pmf = &(pSynch->mf);
-  tsdbDecodeSMFileEx(SYNC_BUFFER(pSynch), pSynch->pmf);
-
-  return 0;
-}
-
-static int32_t tsdbSendDecision(SSyncH *pSynch, bool toSend) {
-  STsdbRepo *pRepo = pSynch->pRepo;
-  uint8_t    decision = toSend;
-
-  int32_t writeLen = sizeof(uint8_t);
-  int32_t ret = taosWriteMsg(pSynch->socketFd, (void *)(&decision), writeLen);
-  if (ret != writeLen) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    tsdbError("vgId:%d, failed to send decison, ret:%d writeLen:%d", REPO_ID(pRepo), ret, writeLen);
-    return -1;
-  }
-
-  return 0;
-}
-
-static int32_t tsdbRecvDecision(SSyncH *pSynch, bool *toSend) {
-  STsdbRepo *pRepo = pSynch->pRepo;
-  uint8_t    decision = 0;
-
-  int32_t readLen = sizeof(uint8_t);
-  int32_t ret = taosReadMsg(pSynch->socketFd, (void *)(&decision), readLen);
-  if (ret != readLen) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    tsdbError("vgId:%d, failed to recv decison, ret:%d readLen:%d", REPO_ID(pRepo), ret, readLen);
-    return -1;
-  }
-
-  *toSend = decision;
-  return 0;
-}
-
-static int32_t tsdbSyncSendDFileSetArray(SSyncH *pSynch) {
-  STsdbRepo *pRepo = pSynch->pRepo;
-  STsdbFS *  pfs = REPO_FS(pRepo);
-  SFSIter    fsiter;
-  SDFileSet *pSet;
-
-  tsdbFSIterInit(&fsiter, pfs, TSDB_FS_ITER_FORWARD);
-
-  do {
-    pSet = tsdbFSIterNext(&fsiter);
-    if (tsdbSyncSendDFileSet(pSynch, pSet) < 0) {
-      tsdbError("vgId:%d, failed to send fileset:%d since %s", REPO_ID(pRepo), pSet ? pSet->fid : -1,
-                tstrerror(terrno));
-      return -1;
-    }
-
-    // No more file set to send, jut break
-    if (pSet == NULL) {
-      tsdbInfo("vgId:%d, no filesets any more", REPO_ID(pRepo));
-      break;
-    }
-  } while (true);
-
-  return 0;
-}
-
-static int32_t tsdbSyncRecvDFileSetArray(SSyncH *pSynch) {
-  STsdbRepo *pRepo = pSynch->pRepo;
-  STsdbFS *  pfs = REPO_FS(pRepo);
-  SFSIter    fsiter;
-  SDFileSet *pLSet;  // Local file set
-
-  tsdbFSIterInit(&fsiter, pfs, TSDB_FS_ITER_FORWARD);
-
-  pLSet = tsdbFSIterNext(&fsiter);
-  if (tsdbRecvDFileSetInfo(pSynch) < 0) {
-    tsdbError("vgId:%d, failed to recv fileset since %s", REPO_ID(pRepo), tstrerror(terrno));
-    return -1;
-  }
-
-  while (true) {
-    if (pLSet == NULL && pSynch->pdf == NULL) {
-      tsdbInfo("vgId:%d, all filesets is disposed", REPO_ID(pRepo));
-      break;
-    } else {
-      tsdbInfo("vgId:%d, fileset local:%d remote:%d, will be disposed", REPO_ID(pRepo), pLSet != NULL ? pLSet->fid : -1,
-               pSynch->pdf != NULL ? pSynch->pdf->fid : -1);
-    }
-
-    if (pLSet && (pSynch->pdf == NULL || pLSet->fid < pSynch->pdf->fid)) {
-      // remote not has pLSet->fid set, just remove local (do nothing to remote the fset)
-      tsdbInfo("vgId:%d, fileset:%d smaller than remote:%d, remove it", REPO_ID(pRepo), pLSet->fid,
-               pSynch->pdf != NULL ? pSynch->pdf->fid : -1);
-      pLSet = tsdbFSIterNext(&fsiter);
-    } else {
-      if (pLSet && pSynch->pdf && pLSet->fid == pSynch->pdf->fid && tsdbIsTowFSetSame(pLSet, pSynch->pdf) &&
-          tsdbFSetIsOk(pLSet)) {
-        // Just keep local files and notify remote not to send
-        tsdbInfo("vgId:%d, fileset:%d is same and no need to recv", REPO_ID(pRepo), pLSet->fid);
-
-        if (tsdbUpdateDFileSet(pfs, pLSet) < 0) {
-          tsdbError("vgId:%d, failed to update fileset since %s", REPO_ID(pRepo), tstrerror(terrno));
-          return -1;
-        }
-
-        if (tsdbSendDecision(pSynch, false) < 0) {
-          tsdbError("vgId:%d, failed to send decision since %s", REPO_ID(pRepo), tstrerror(terrno));
-          return -1;
-        }
-      } else {
-        // Need to copy from remote
-        int fidLevel = tsdbGetFidLevel(pSynch->pdf->fid, &(pSynch->rtn));
-        if (fidLevel < 0) {  // expired fileset
-          tsdbInfo("vgId:%d, fileset:%d will be skipped as expired", REPO_ID(pRepo), pSynch->pdf->fid);
-          if (tsdbSendDecision(pSynch, false) < 0) {
-            tsdbError("vgId:%d, failed to send decision since %s", REPO_ID(pRepo), tstrerror(terrno));
-            return -1;
-          }
-          // Move forward
-          if (tsdbRecvDFileSetInfo(pSynch) < 0) {
-            tsdbError("vgId:%d, failed to recv fileset since %s", REPO_ID(pRepo), tstrerror(terrno));
-            return -1;
-          }
-          if (pLSet) {
-            pLSet = tsdbFSIterNext(&fsiter);
-          }
-          // Next loop
-          continue;
-        } else {
-          tsdbInfo("vgId:%d, fileset:%d will be received", REPO_ID(pRepo), pSynch->pdf->fid);
-          // Notify remote to send there file here
-          if (tsdbSendDecision(pSynch, true) < 0) {
-            tsdbError("vgId:%d, failed to send decision since %s", REPO_ID(pRepo), tstrerror(terrno));
-            return -1;
-          }
-        }
-
-        // Create local files and copy from remote
-        SDiskID   did;
-        SDFileSet fset;
-
-        tfsAllocDisk(fidLevel, &(did.level), &(did.id));
-        if (did.level == TFS_UNDECIDED_LEVEL) {
-          terrno = TSDB_CODE_TDB_NO_AVAIL_DISK;
-          tsdbError("vgId:%d, failed allc disk since %s", REPO_ID(pRepo), tstrerror(terrno));
-          return -1;
-        }
-
-        tsdbInitDFileSet(&fset, did, REPO_ID(pRepo), pSynch->pdf->fid, FS_TXN_VERSION(pfs));
-
-        // Create new FSET
-        if (tsdbCreateDFileSet(&fset, false) < 0) {
-          tsdbError("vgId:%d, failed to create fileset since %s", REPO_ID(pRepo), tstrerror(terrno));
-          return -1;
-        }
-
-        for (TSDB_FILE_T ftype = 0; ftype < TSDB_FILE_MAX; ftype++) {
-          SDFile *pDFile = TSDB_DFILE_IN_SET(&fset, ftype);         // local file
-          SDFile *pRDFile = TSDB_DFILE_IN_SET(pSynch->pdf, ftype);  // remote file
-
-          tsdbInfo("vgId:%d, file:%s will be received, osize:%" PRIu64 " rsize:%" PRIu64, REPO_ID(pRepo),
-                   pDFile->f.aname, pDFile->info.size, pRDFile->info.size);
-
-          int64_t writeLen = pRDFile->info.size;
-          int64_t ret = taosCopyFds(pSynch->socketFd, pDFile->fd, writeLen);
-          if (ret != writeLen) {
-            terrno = TAOS_SYSTEM_ERROR(errno);
-            tsdbError("vgId:%d, failed to recv file:%s since %s, ret:%" PRId64 " writeLen:%" PRId64, REPO_ID(pRepo),
-                      pDFile->f.aname, tstrerror(terrno), ret, writeLen);
-            tsdbCloseDFileSet(&fset);
-            tsdbRemoveDFileSet(&fset);
-            return -1;
-          }
-
-          // Update new file info
-          pDFile->info = pRDFile->info;
-          tsdbInfo("vgId:%d, file:%s is received, size:%" PRId64, REPO_ID(pRepo), pDFile->f.aname, writeLen);
-        }
-
-        tsdbCloseDFileSet(&fset);
-        if (tsdbUpdateDFileSet(pfs, &fset) < 0) {
-          tsdbInfo("vgId:%d, fileset:%d failed to update since %s", REPO_ID(pRepo), fset.fid, tstrerror(terrno));
-          return -1;
-        }
-
-        tsdbInfo("vgId:%d, fileset:%d is received", REPO_ID(pRepo), pSynch->pdf->fid);
-      }
-
-      // Move forward
-      if (tsdbRecvDFileSetInfo(pSynch) < 0) {
-        tsdbError("vgId:%d, failed to recv fileset since %s", REPO_ID(pRepo), tstrerror(terrno));
-        return -1;
-      }
-
-      if (pLSet) {
-        pLSet = tsdbFSIterNext(&fsiter);
-      }
-    }
-
-#if 0
-    if (pLSet == NULL) {
-      // Copy from remote >>>>>>>>>>>
-    } else {
-      if (pSynch->pdf == NULL) {
-        // Remove local file, just ignore ++++++++++++++
-        pLSet = tsdbFSIterNext(&fsiter);
-      } else {
-        if (pLSet->fid < pSynch->pdf->fid) {
-          // Remove local file, just ignore ++++++++++++
-          pLSet = tsdbFSIterNext(&fsiter);
-        } else if (pLSet->fid > pSynch->pdf->fid){
-          // Copy from remote >>>>>>>>>>>>>>
-          if (tsdbRecvDFileSetInfo(pSynch) < 0) {
-            // TODO
-            return -1;
-          }
-        } else {
-          if (true/*TODO: is same fset*/) {
-            // No need to copy ---------------------
-          } else {
-            // copy from remote >>>>>>>>>>>>>.
-          }
-        }
-      }
-    }
-#endif
-  }
-
-  return 0;
-}
-
-static bool tsdbIsTowFSetSame(SDFileSet *pSet1, SDFileSet *pSet2) {
-  for (TSDB_FILE_T ftype = 0; ftype < TSDB_FILE_MAX; ftype++) {
-    SDFile *pDFile1 = TSDB_DFILE_IN_SET(pSet1, ftype);
-    SDFile *pDFile2 = TSDB_DFILE_IN_SET(pSet2, ftype);
-
-    if (pDFile1->info.size != pDFile2->info.size || pDFile1->info.magic != pDFile2->info.magic) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-static int32_t tsdbSyncSendDFileSet(SSyncH *pSynch, SDFileSet *pSet) {
-  STsdbRepo *pRepo = pSynch->pRepo;
-  bool toSend = false;
-
-  // skip expired fileset
-  if (pSet && tsdbGetFidLevel(pSet->fid, &(pSynch->rtn)) < 0) {
-    tsdbInfo("vgId:%d, don't sync send since fileset:%d smaller than minFid:%d", REPO_ID(pRepo), pSet->fid,
-             pSynch->rtn.minFid);
-    return 0;
-  }
-
-  if (tsdbSendDFileSetInfo(pSynch, pSet) < 0) {
-    tsdbError("vgId:%d, failed to send fileset:%d info since %s", REPO_ID(pRepo), pSet ? pSet->fid : -1, tstrerror(terrno));
-    return -1;
-  }
-
-  // No file any more, no need to send file, just return
-  if (pSet == NULL) {
-    return 0;
-  }
-
-  if (tsdbRecvDecision(pSynch, &toSend) < 0) {
-    tsdbError("vgId:%d, failed to recv decision while send fileset:%d since %s", REPO_ID(pRepo), pSet->fid,
-              tstrerror(terrno));
-    return -1;
-  }
-
-  if (toSend) {
-    tsdbInfo("vgId:%d, fileset:%d will be sent", REPO_ID(pRepo), pSet->fid);
-
-    for (TSDB_FILE_T ftype = 0; ftype < TSDB_FILE_MAX; ftype++) {
-      SDFile df = *TSDB_DFILE_IN_SET(pSet, ftype);
-      
-      if (tsdbOpenDFile(&df, O_RDONLY) < 0) {
-        tsdbError("vgId:%d, failed to file:%s since %s", REPO_ID(pRepo), df.f.aname, tstrerror(terrno));
-        return -1;
-      }
-
-      int64_t writeLen = df.info.size;
-      tsdbInfo("vgId:%d, file:%s will be sent, size:%" PRId64, REPO_ID(pRepo), df.f.aname, writeLen);
-
-      int64_t ret = taosSendFile(pSynch->socketFd, TSDB_FILE_FD(&df), 0, writeLen);
-      if (ret != writeLen) {
-        terrno = TAOS_SYSTEM_ERROR(errno);
-        tsdbError("vgId:%d, failed to send file:%s since %s, ret:%" PRId64 " writeLen:%" PRId64, REPO_ID(pRepo),
-                  df.f.aname, tstrerror(terrno), ret, writeLen);
-        tsdbCloseDFile(&df);
-        return -1;
-      }
-
-      tsdbInfo("vgId:%d, file:%s is sent", REPO_ID(pRepo), df.f.aname);
-      tsdbCloseDFile(&df);
-    }
-
-    tsdbInfo("vgId:%d, fileset:%d is sent", REPO_ID(pRepo), pSet->fid);
-  } else {
-    tsdbInfo("vgId:%d, fileset:%d is same, no need to send", REPO_ID(pRepo), pSet->fid);
-  }
-
-  return 0;
-}
-
-static int32_t tsdbSendDFileSetInfo(SSyncH *pSynch, SDFileSet *pSet) {
-  STsdbRepo *pRepo = pSynch->pRepo;
-  uint32_t   tlen = 0;
-
-  if (pSet) {
-    tlen = tsdbEncodeDFileSetEx(NULL, pSet) + sizeof(TSCKSUM);
-  }
-
-  if (tsdbMakeRoom((void **)(&SYNC_BUFFER(pSynch)), tlen + sizeof(tlen)) < 0) {
-    tsdbError("vgId:%d, failed to makeroom while send fileinfo since %s", REPO_ID(pRepo), tstrerror(terrno));
-    return -1;
-  }
-
-  void *ptr = SYNC_BUFFER(pSynch);
-  taosEncodeFixedU32(&ptr, tlen);
-  void *tptr = ptr;
-  if (pSet) {
-    tsdbEncodeDFileSetEx(&ptr, pSet);
-    taosCalcChecksumAppend(0, (uint8_t *)tptr, tlen);
-  }
-
-  int32_t writeLen = tlen + sizeof(uint32_t);
-  int32_t ret = taosWriteMsg(pSynch->socketFd, SYNC_BUFFER(pSynch), writeLen);
-  if (ret != writeLen) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    tsdbError("vgId:%d, failed to send fileinfo, ret:%d writeLen:%d", REPO_ID(pRepo), ret, writeLen);
-    return -1;
-  }
-
-  return 0;
-}
-
-static int32_t tsdbRecvDFileSetInfo(SSyncH *pSynch) {
-  STsdbRepo *pRepo = pSynch->pRepo;
-  uint32_t   tlen;
-  char       buf[64] = {0};
-
-  int32_t readLen = sizeof(uint32_t);
-  int32_t ret = taosReadMsg(pSynch->socketFd, buf, readLen);
-  if (ret != readLen) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    return -1;
-  }
-
-  taosDecodeFixedU32(buf, &tlen);
-
-  tsdbInfo("vgId:%d, fileinfo len:%d is received", REPO_ID(pRepo), tlen);
-  if (tlen == 0) {
-    pSynch->pdf = NULL;
-    return 0;
-  }
-
-  if (tsdbMakeRoom((void **)(&SYNC_BUFFER(pSynch)), tlen) < 0) {
-    tsdbError("vgId:%d, failed to makeroom while recv fileinfo since %s", REPO_ID(pRepo), tstrerror(terrno));
-    return -1;
-  }
-
-  ret = taosReadMsg(pSynch->socketFd, SYNC_BUFFER(pSynch), tlen);
-  if (ret != tlen) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    tsdbError("vgId:%d, failed to recv fileinfo, ret:%d readLen:%d", REPO_ID(pRepo), ret, tlen);
-    return -1;
-  }
-
-  if (!taosCheckChecksumWhole((uint8_t *)SYNC_BUFFER(pSynch), tlen)) {
-    terrno = TSDB_CODE_TDB_MESSED_MSG;
-    tsdbError("vgId:%d, failed to checksum while recv fileinfo since %s", REPO_ID(pRepo), tstrerror(terrno));
-    return -1;
-  }
-
-  pSynch->pdf = &(pSynch->df);
-  tsdbDecodeDFileSetEx(SYNC_BUFFER(pSynch), pSynch->pdf);
-
-  return 0;
-}
-
-static int tsdbReload(STsdbRepo *pRepo, bool isMfChanged) {
-  // TODO: may need to stop and restart stream
-  // if (isMfChanged) {
-  tsdbCloseMeta(pRepo);
-  tsdbFreeMeta(pRepo->tsdbMeta);
-  pRepo->tsdbMeta = tsdbNewMeta(REPO_CFG(pRepo));
-  tsdbOpenMeta(pRepo);
-  tsdbLoadMetaCache(pRepo, true);
-  // }
-
-  tsdbUnRefMemTable(pRepo, pRepo->mem);
-  tsdbUnRefMemTable(pRepo, pRepo->imem);
-  pRepo->mem = NULL;
-  pRepo->imem = NULL;
-
-  if (tsdbRestoreInfo(pRepo) < 0) {
-    tsdbError("vgId:%d failed to restore info from file since %s", REPO_ID(pRepo), tstrerror(terrno));
-    return -1;
-  }
-
-  return 0;
-}
\ No newline at end of file

source/libs/executor/CMakeLists.txt

@@ -13,7 +13,7 @@ add_library(executor STATIC ${EXECUTOR_SRC})
 #        INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_SOURCE_DIR}/include/libs/executor"
 #        )
 target_link_libraries(executor
-            PRIVATE os util common function parser planner qcom tsdb
+            PRIVATE os util common function parser planner qcom vnode
         )
 
 target_include_directories(

source/libs/executor/src/executorimpl.c

@@ -18,7 +18,6 @@
 #include "ttime.h"
 #include "exception.h"
 
-#include "../../../../contrib/cJson/cJSON.h"
 #include "executorimpl.h"
 #include "function.h"
 #include "tcompare.h"
@@ -7188,31 +7187,47 @@ static SExecTaskInfo* createExecTaskInfo(uint64_t queryId) {
 SOperatorInfo* doCreateOperatorTreeNode(SPhyNode* pPhyNode, SExecTaskInfo* pTaskInfo, void* param) {
   if (pPhyNode->pChildren == NULL || taosArrayGetSize(pPhyNode->pChildren) == 0) {
     if (pPhyNode->info.type == OP_TableScan) {
+      SScanPhyNode* pScanPhyNode = (SScanPhyNode*) pPhyNode;
       size_t numOfCols = taosArrayGetSize(pPhyNode->pTargets);
-      SOperatorInfo* pOperatorInfo = createTableScanOperator(param, TSDB_ORDER_ASC, numOfCols, 1, pTaskInfo);
+      SOperatorInfo* pOperatorInfo = createTableScanOperator(param, pScanPhyNode->order, numOfCols, pScanPhyNode->count, pTaskInfo);
       pTaskInfo->pRoot = pOperatorInfo;
+    } else {
+      assert(0);
     }
   }
 }
 
 int32_t doCreateExecTaskInfo(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, void* readerHandle) {
-  STsdbQueryCond cond = {.order = TSDB_ORDER_ASC, .numOfCols = 2, .loadExternalRows = false};
+  STsdbQueryCond cond = {.loadExternalRows = false};
   cond.twindow.skey = INT64_MIN;
   cond.twindow.ekey = INT64_MAX;
+
+  uint64_t uid = 0;
+  SPhyNode* pPhyNode = pPlan->pNode;
+  if (pPhyNode->info.type == OP_TableScan) {
+
+    SScanPhyNode* pScanNode = (SScanPhyNode*) pPhyNode;
+    uid            = pScanNode->uid;
+    cond.order     = pScanNode->order;
+    cond.numOfCols = taosArrayGetSize(pScanNode->node.pTargets);
     cond.colList   = calloc(cond.numOfCols, sizeof(SColumnInfo));
 
-  // todo set the correct table column info
-  cond.colList[0].type = TSDB_DATA_TYPE_TIMESTAMP;
-  cond.colList[0].bytes = sizeof(uint64_t);
-  cond.colList[0].colId = 1;
+    for(int32_t i = 0; i < cond.numOfCols; ++i) {
+      SExprInfo* pExprInfo = taosArrayGetP(pScanNode->node.pTargets, i);
+      assert(pExprInfo->pExpr->nodeType == TEXPR_COL_NODE);
 
-  cond.colList[1].type = TSDB_DATA_TYPE_INT;
-  cond.colList[1].bytes = sizeof(int32_t);
-  cond.colList[1].colId = 2;
+      SSchema* pSchema = pExprInfo->pExpr->pSchema;
+      cond.colList[i].type  = pSchema->type;
+      cond.colList[i].bytes = pSchema->bytes;
+      cond.colList[i].colId = pSchema->colId;
+    }
+  } else {
+    assert(0);
+  }
 
   STableGroupInfo group = {.numOfTables = 1, .pGroupList = taosArrayInit(1, POINTER_BYTES)};
   SArray*         pa = taosArrayInit(1, sizeof(STableKeyInfo));
-  STableKeyInfo   info = {.pTable = NULL, .lastKey = 0, .uid = 1};
+  STableKeyInfo   info = {.pTable = NULL, .lastKey = 0, .uid = uid};
   taosArrayPush(pa, &info);
 
   taosArrayPush(group.pGroupList, &pa);

source/libs/parser/inc/astToMsg.h

@@ -8,10 +8,10 @@
 SCreateUserReq* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
 SCreateAcctReq* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
 SDropUserReq* buildDropUserMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
-SShowReq* buildShowMsg(SShowInfo* pShowInfo, SParseBasicCtx* pParseCtx, char* msgBuf, int32_t msgLen);
-SCreateDbReq* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseBasicCtx *pCtx, SMsgBuf* pMsgBuf);
-SMCreateStbReq*   buildCreateStbMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf);
-SMDropStbReq* buildDropStableMsg(SSqlInfo* pInfo, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf);
+SShowReq* buildShowMsg(SShowInfo* pShowInfo, SParseContext* pParseCtx, char* msgBuf, int32_t msgLen);
+SCreateDbReq* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseContext *pCtx, SMsgBuf* pMsgBuf);
+SMCreateStbReq*   buildCreateStbMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf);
+SMDropStbReq* buildDropStableMsg(SSqlInfo* pInfo, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf);
 SCreateDnodeReq *buildCreateDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf);
 SDropDnodeReq *buildDropDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf);
 

source/libs/parser/inc/parserInt.h

@@ -51,7 +51,7 @@ void clearAllTableMetaInfo(SQueryStmtInfo* pQueryInfo, bool removeMeta, uint64_t
  * @param msgBufLen
  * @return
  */
-int32_t qParserValidateSqlNode(SParseBasicCtx *pCtx, SSqlInfo* pInfo, SQueryStmtInfo* pQueryInfo, char* msgBuf, int32_t msgBufLen);
+int32_t qParserValidateSqlNode(SParseContext *pCtx, SSqlInfo* pInfo, SQueryStmtInfo* pQueryInfo, char* msgBuf, int32_t msgBufLen);
 
 /**
  * validate the ddl ast, and convert the ast to the corresponding message format
@@ -60,7 +60,7 @@ int32_t qParserValidateSqlNode(SParseBasicCtx *pCtx, SSqlInfo* pInfo, SQueryStmt
  * @param type
  * @return
  */
-SDclStmtInfo* qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, char* msgBuf, int32_t msgBufLen);
+SDclStmtInfo* qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseContext* pCtx, char* msgBuf, int32_t msgBufLen);
 
 /**
  *
@@ -70,7 +70,7 @@ SDclStmtInfo* qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, c
  * @param msgBufLen
  * @return
  */
-SVnodeModifOpStmtInfo* qParserValidateCreateTbSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, char* msgBuf, int32_t msgBufLen);
+SVnodeModifOpStmtInfo* qParserValidateCreateTbSqlNode(SSqlInfo* pInfo, SParseContext* pCtx, char* msgBuf, int32_t msgBufLen);
 
 /**
  * Evaluate the numeric and timestamp arithmetic expression in the WHERE clause.
@@ -98,7 +98,7 @@ int32_t checkForInvalidExpr(SQueryStmtInfo* pQueryInfo, SMsgBuf* pMsgBuf);
  * @param msgBufLen
  * @return
  */
-int32_t qParserExtractRequestedMetaInfo(const SSqlInfo* pSqlInfo, SCatalogReq* pMetaInfo, SParseBasicCtx *pCtx, char* msg, int32_t msgBufLen);
+int32_t qParserExtractRequestedMetaInfo(const SSqlInfo* pSqlInfo, SCatalogReq* pMetaInfo, SParseContext *pCtx, char* msg, int32_t msgBufLen);
 
 /**
  * Destroy the meta data request structure.

source/libs/parser/inc/parserUtil.h

@@ -81,7 +81,7 @@ int32_t KvRowAppend(const void *value, int32_t len, void *param);
 typedef int32_t (*_row_append_fn_t)(const void *value, int32_t len, void *param);
 int32_t parseValueToken(char** end, SToken* pToken, SSchema* pSchema, int16_t timePrec, char* tmpTokenBuf, _row_append_fn_t func, void* param, SMsgBuf* pMsgBuf);
 
-int32_t createSName(SName* pName, SToken* pTableName, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf);
+int32_t createSName(SName* pName, SToken* pTableName, SParseContext* pParseCtx, SMsgBuf* pMsgBuf);
 
 #ifdef __cplusplus
 }

source/libs/parser/src/astToMsg.c

@@ -85,7 +85,7 @@ SDropUserReq* buildDropUserMsg(SSqlInfo* pInfo, int32_t *msgLen, int64_t id, cha
   return pMsg;
 }
 
-SShowReq* buildShowMsg(SShowInfo* pShowInfo, SParseBasicCtx *pCtx, char* msgBuf, int32_t msgLen) {
+SShowReq* buildShowMsg(SShowInfo* pShowInfo, SParseContext *pCtx, char* msgBuf, int32_t msgLen) {
   SShowReq* pShowMsg = calloc(1, sizeof(SShowReq));
 
   pShowMsg->type = pShowInfo->showType;
@@ -210,7 +210,7 @@ int32_t setDbOptions(SCreateDbReq* pCreateDbMsg, const SCreateDbInfo* pCreateDbS
   return TSDB_CODE_SUCCESS;
 }
 
-SCreateDbReq* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseBasicCtx *pCtx, SMsgBuf* pMsgBuf) {
+SCreateDbReq* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseContext *pCtx, SMsgBuf* pMsgBuf) {
   SCreateDbReq* pCreateMsg = calloc(1, sizeof(SCreateDbReq));
   if (setDbOptions(pCreateMsg, pCreateDbInfo, pMsgBuf) != TSDB_CODE_SUCCESS) {
     tfree(pCreateMsg);
@@ -230,7 +230,7 @@ SCreateDbReq* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseBasicCtx *pCt
   return pCreateMsg;
 }
 
-SMCreateStbReq* buildCreateStbMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf) {
+SMCreateStbReq* buildCreateStbMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf) {
   SSchema* pSchema;
 
   int32_t numOfTags = 0;
@@ -315,7 +315,7 @@ SMCreateStbReq* buildCreateStbMsg(SCreateTableSql* pCreateTableSql, int32_t* len
   return pCreateStbMsg;
 }
 
-SMDropStbReq* buildDropStableMsg(SSqlInfo* pInfo, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf) {
+SMDropStbReq* buildDropStableMsg(SSqlInfo* pInfo, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf) {
   SToken* tableName = taosArrayGet(pInfo->pMiscInfo->a, 0);
 
   SName name = {0};

source/libs/parser/src/astValidate.c

@@ -3628,7 +3628,7 @@ int32_t evaluateSqlNode(SSqlNode* pNode, int32_t tsPrecision, SMsgBuf* pMsgBuf)
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t setTableVgroupList(SParseBasicCtx *pCtx, SName* name, SVgroupsInfo **pVgList) {
+int32_t setTableVgroupList(SParseContext *pCtx, SName* name, SVgroupsInfo **pVgList) {
   SArray* vgroupList = NULL;
   int32_t code = catalogGetTableDistVgroup(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, name, &vgroupList);
   if (code != TSDB_CODE_SUCCESS) {
@@ -3655,7 +3655,7 @@ int32_t setTableVgroupList(SParseBasicCtx *pCtx, SName* name, SVgroupsInfo **pVg
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qParserValidateSqlNode(SParseBasicCtx *pCtx, SSqlInfo* pInfo, SQueryStmtInfo* pQueryInfo, char* msgBuf, int32_t msgBufLen) {
+int32_t qParserValidateSqlNode(SParseContext *pCtx, SSqlInfo* pInfo, SQueryStmtInfo* pQueryInfo, char* msgBuf, int32_t msgBufLen) {
   assert(pCtx != NULL && pInfo != NULL);
   int32_t code = 0;
 

source/libs/parser/src/dCDAstProcess.c

@@ -18,7 +18,7 @@ static bool has(SArray* pFieldList, int32_t startIndex, const char* name) {
   return false;
 }
 
-static int32_t setShowInfo(SShowInfo* pShowInfo, SParseBasicCtx* pCtx, void** output, int32_t* outputLen,
+static int32_t setShowInfo(SShowInfo* pShowInfo, SParseContext* pCtx, void** output, int32_t* outputLen,
                            SEpSet* pEpSet, void** pExtension, SMsgBuf* pMsgBuf) {
   const char* msg1 = "invalid name";
   const char* msg2 = "wildcard string should be less than %d characters";
@@ -396,7 +396,7 @@ static void destroyCreateTbReqBatch(SVgroupTablesBatch* pTbBatch) {
   taosArrayDestroy(pTbBatch->req.pArray);
 }
 
-static int32_t doCheckAndBuildCreateCTableReq(SCreateTableSql* pCreateTable, SParseBasicCtx* pCtx, SMsgBuf* pMsgBuf, SArray** pBufArray) {
+static int32_t doCheckAndBuildCreateCTableReq(SCreateTableSql* pCreateTable, SParseContext* pCtx, SMsgBuf* pMsgBuf, SArray** pBufArray) {
   const char* msg1 = "invalid table name";
   const char* msg2 = "tags number not matched";
   const char* msg3 = "tag value too long";
@@ -634,7 +634,7 @@ static int32_t doBuildSingleTableBatchReq(SName* pTableName, SArray* pColumns, S
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t doCheckAndBuildCreateTableReq(SCreateTableSql* pCreateTable, SParseBasicCtx* pCtx, SMsgBuf* pMsgBuf, char** pOutput, int32_t* len) {
+int32_t doCheckAndBuildCreateTableReq(SCreateTableSql* pCreateTable, SParseContext* pCtx, SMsgBuf* pMsgBuf, char** pOutput, int32_t* len) {
   SArray* pBufArray = NULL;
   int32_t code = 0;
 
@@ -703,7 +703,7 @@ SArray* doSerializeVgroupCreateTableInfo(SHashObj* pVgroupHashmap) {
   return pBufArray;
 }
 
-SDclStmtInfo* qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, char* msgBuf, int32_t msgBufLen) {
+SDclStmtInfo* qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseContext* pCtx, char* msgBuf, int32_t msgBufLen) {
   int32_t code = 0;
 
   SDclStmtInfo* pDcl = calloc(1, sizeof(SDclStmtInfo));
@@ -961,7 +961,7 @@ SDclStmtInfo* qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, c
     return NULL;
 }
 
-SVnodeModifOpStmtInfo* qParserValidateCreateTbSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, char* msgBuf, int32_t msgBufLen) {
+SVnodeModifOpStmtInfo* qParserValidateCreateTbSqlNode(SSqlInfo* pInfo, SParseContext* pCtx, char* msgBuf, int32_t msgBufLen) {
   SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo;
   assert(pCreateTable->type == TSDB_SQL_CREATE_TABLE);
 

source/libs/parser/src/insertParser.c

@@ -84,11 +84,11 @@ static int32_t buildName(SInsertParseContext* pCxt, SToken* pStname, char* fullD
 
   char* p = strnchr(pStname->z, TS_PATH_DELIMITER[0], pStname->n, false);
   if (NULL != p) { // db.table
-    int32_t n = sprintf(fullDbName, "%d.", pCxt->pComCxt->ctx.acctId);
+    int32_t n = sprintf(fullDbName, "%d.", pCxt->pComCxt->acctId);
     strncpy(fullDbName + n, pStname->z, p - pStname->z);
     strncpy(tableName, p + 1, pStname->n - (p - pStname->z) - 1);
   } else {
-    snprintf(fullDbName, TSDB_DB_FNAME_LEN, "%d.%s", pCxt->pComCxt->ctx.acctId, pCxt->pComCxt->ctx.db);
+    snprintf(fullDbName, TSDB_DB_FNAME_LEN, "%d.%s", pCxt->pComCxt->acctId, pCxt->pComCxt->db);
     strncpy(tableName, pStname->z, pStname->n);
   }
 
@@ -97,11 +97,11 @@ static int32_t buildName(SInsertParseContext* pCxt, SToken* pStname, char* fullD
 
 static int32_t getTableMeta(SInsertParseContext* pCxt, SToken* pTname) {
   SName name = {0};
-  createSName(&name, pTname, &pCxt->pComCxt->ctx, &pCxt->msg);
+  createSName(&name, pTname, pCxt->pComCxt, &pCxt->msg);
 
   char tableName[TSDB_TABLE_FNAME_LEN] = {0};
   tNameExtractFullName(&name, tableName);
-  SParseBasicCtx* pBasicCtx = &pCxt->pComCxt->ctx;
+  SParseContext* pBasicCtx = pCxt->pComCxt;
   CHECK_CODE(catalogGetTableMeta(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, &name, &pCxt->pTableMeta));
   SVgroupInfo vg;
   CHECK_CODE(catalogGetTableHashVgroup(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, &name, &vg));

source/libs/parser/src/parser.c

@@ -45,14 +45,14 @@ int32_t parseQuerySql(SParseContext* pCxt, SQueryNode** pQuery) {
 
   if (!isDqlSqlStatement(&info)) {
     if (info.type == TSDB_SQL_CREATE_TABLE) {
-      SVnodeModifOpStmtInfo * pModifStmtInfo = qParserValidateCreateTbSqlNode(&info, &pCxt->ctx, pCxt->pMsg, pCxt->msgLen);
+      SVnodeModifOpStmtInfo * pModifStmtInfo = qParserValidateCreateTbSqlNode(&info, pCxt, pCxt->pMsg, pCxt->msgLen);
       if (pModifStmtInfo == NULL) {
         return terrno;
       }
 
       *pQuery = (SQueryNode*)pModifStmtInfo;
     } else {
-      SDclStmtInfo* pDcl = qParserValidateDclSqlNode(&info, &pCxt->ctx, pCxt->pMsg, pCxt->msgLen);
+      SDclStmtInfo* pDcl = qParserValidateDclSqlNode(&info, pCxt, pCxt->pMsg, pCxt->msgLen);
       if (pDcl == NULL) {
         return terrno;
       }
@@ -67,7 +67,7 @@ int32_t parseQuerySql(SParseContext* pCxt, SQueryNode** pQuery) {
       return terrno;
     }
 
-    int32_t code = qParserValidateSqlNode(&pCxt->ctx, &info, pQueryInfo, pCxt->pMsg, pCxt->msgLen);
+    int32_t code = qParserValidateSqlNode(pCxt, &info, pQueryInfo, pCxt->pMsg, pCxt->msgLen);
     if (code == TSDB_CODE_SUCCESS) {
       *pQuery = (SQueryNode*)pQueryInfo;
     } else {
@@ -92,7 +92,7 @@ int32_t qParserConvertSql(const char* pStr, size_t length, char** pConvertSql) {
   return 0;
 }
 
-static int32_t getTableNameFromSqlNode(SSqlNode* pSqlNode, SArray* tableNameList, SParseBasicCtx *pCtx, SMsgBuf* pMsgBuf);
+static int32_t getTableNameFromSqlNode(SSqlNode* pSqlNode, SArray* tableNameList, SParseContext *pCtx, SMsgBuf* pMsgBuf);
 
 static int32_t tnameComparFn(const void* p1, const void* p2) {
   SName* pn1 = (SName*)p1;
@@ -116,7 +116,7 @@ static int32_t tnameComparFn(const void* p1, const void* p2) {
   }
 }
 
-static int32_t getTableNameFromSubquery(SSqlNode* pSqlNode, SArray* tableNameList, SParseBasicCtx *pCtx, SMsgBuf* pMsgBuf) {
+static int32_t getTableNameFromSubquery(SSqlNode* pSqlNode, SArray* tableNameList, SParseContext *pCtx, SMsgBuf* pMsgBuf) {
   int32_t numOfSub = (int32_t)taosArrayGetSize(pSqlNode->from->list);
 
   for (int32_t j = 0; j < numOfSub; ++j) {
@@ -139,7 +139,7 @@ static int32_t getTableNameFromSubquery(SSqlNode* pSqlNode, SArray* tableNameLis
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t getTableNameFromSqlNode(SSqlNode* pSqlNode, SArray* tableNameList, SParseBasicCtx *pParseCtx, SMsgBuf* pMsgBuf) {
+int32_t getTableNameFromSqlNode(SSqlNode* pSqlNode, SArray* tableNameList, SParseContext *pParseCtx, SMsgBuf* pMsgBuf) {
   const char* msg1 = "invalid table name";
 
   int32_t numOfTables = (int32_t) taosArrayGetSize(pSqlNode->from->list);
@@ -173,7 +173,7 @@ static void freePtrElem(void* p) {
   tfree(*(char**)p);
 }
 
-int32_t qParserExtractRequestedMetaInfo(const SSqlInfo* pSqlInfo, SCatalogReq* pMetaInfo, SParseBasicCtx *pCtx, char* msg, int32_t msgBufLen) {
+int32_t qParserExtractRequestedMetaInfo(const SSqlInfo* pSqlInfo, SCatalogReq* pMetaInfo, SParseContext *pCtx, char* msg, int32_t msgBufLen) {
   int32_t code  = TSDB_CODE_SUCCESS;
   SMsgBuf msgBuf = {.buf = msg, .len = msgBufLen};
 

source/libs/parser/src/parserUtil.c

@@ -1943,7 +1943,7 @@ int32_t KvRowAppend(const void *value, int32_t len, void *param) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t createSName(SName* pName, SToken* pTableName, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf) {
+int32_t createSName(SName* pName, SToken* pTableName, SParseContext* pParseCtx, SMsgBuf* pMsgBuf) {
   const char* msg1 = "name too long";
 
   int32_t  code = TSDB_CODE_SUCCESS;

source/libs/parser/src/queryInfoUtil.c

@@ -160,11 +160,14 @@ void addExprInfo(SArray* pExprList, int32_t index, SExprInfo* pExprInfo, int32_t
     taosArrayInsert(pExprList, index, &pExprInfo);
   }
 
+#if 0
   if (pExprInfo->pExpr->nodeType == TEXPR_FUNCTION_NODE) {
     printf("add function: %s, level:%d, total:%ld\n", pExprInfo->pExpr->_function.functionName, level, taosArrayGetSize(pExprList));
   } else {
     printf("add operator: %s, level:%d, total:%ld\n", pExprInfo->base.resSchema.name, level, taosArrayGetSize(pExprList));
   }
+#endif
+
 }
 
 void updateExprInfo(SExprInfo* pExprInfo, int16_t functionId, int32_t colId, int16_t srcColumnIndex, int16_t resType, int16_t resSize) {

source/libs/parser/test/insertParserTest.cpp

@@ -43,8 +43,8 @@ protected:
 
   void bind(const char* sql) {
     reset();
-    cxt_.ctx.acctId = atoi(acctId_.c_str());
-    cxt_.ctx.db = (char*) db_.c_str();
+    cxt_.acctId = atoi(acctId_.c_str());
+    cxt_.db = (char*) db_.c_str();
     strcpy(sqlBuf_, sql);
     cxt_.sqlLen = strlen(sql);
     sqlBuf_[cxt_.sqlLen] = '\0';

source/libs/parser/test/parserTests.cpp

@@ -77,7 +77,7 @@ void sqlCheck(const char* sql, bool valid) {
   buf.len = 128;
   buf.buf = msg;
 
-  SParseBasicCtx ctx = {0};
+  SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.sub.node), 0);
@@ -122,7 +122,7 @@ TEST(testCase, validateAST_test) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-   SParseBasicCtx ctx = {0};
+   SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
@@ -184,7 +184,7 @@ TEST(testCase, function_Test) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-   SParseBasicCtx ctx = {0};
+   SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
@@ -234,7 +234,7 @@ TEST(testCase, function_Test2) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-   SParseBasicCtx ctx = {0};
+   SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
@@ -284,7 +284,7 @@ TEST(testCase, function_Test3) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-   SParseBasicCtx ctx = {0};
+   SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
@@ -333,7 +333,7 @@ TEST(testCase, function_Test4) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-   SParseBasicCtx ctx = {0};
+   SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
@@ -385,7 +385,7 @@ TEST(testCase, function_Test5) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-   SParseBasicCtx ctx = {0};
+   SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
@@ -474,7 +474,7 @@ TEST(testCase, function_Test6) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-  SParseBasicCtx ctx = {0};
+  SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
@@ -556,7 +556,7 @@ TEST(testCase, function_Test6) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-   SParseBasicCtx ctx = {0};
+   SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
@@ -622,7 +622,7 @@ TEST(testCase, function_Test6) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-   SParseBasicCtx ctx = {0};
+   SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
@@ -705,7 +705,7 @@ TEST(testCase, function_Test6) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-   SParseBasicCtx ctx = {0};
+   SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
@@ -756,7 +756,7 @@ TEST(testCase, show_user_Test) {
   SSqlInfo info1 = doGenerateAST(sql1);
   ASSERT_EQ(info1.valid, true);
 
-  SParseBasicCtx ct= {.requestId = 1, .acctId = 1, .db = "abc", .pTransporter = NULL};
+  SParseContext ct= {.requestId = 1, .acctId = 1, .db = "abc", .pTransporter = NULL};
   SDclStmtInfo* output = qParserValidateDclSqlNode(&info1, &ct, msg, buf.len);
   ASSERT_NE(output, nullptr);
 
@@ -776,7 +776,7 @@ TEST(testCase, create_user_Test) {
   ASSERT_EQ(info1.valid, true);
   ASSERT_EQ(isDclSqlStatement(&info1), true);
 
-  SParseBasicCtx ct= {.requestId = 1, .acctId = 1, .db = "abc"};
+  SParseContext ct= {.requestId = 1, .acctId = 1, .db = "abc"};
   SDclStmtInfo* output = qParserValidateDclSqlNode(&info1, &ct, msg, buf.len);
   ASSERT_NE(output, nullptr);
 

source/libs/parser/test/plannerTest.cpp

@@ -81,7 +81,7 @@ void generateLogicplan(const char* sql) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-  SParseBasicCtx  ctx = {0};
+  SParseContext  ctx = {0};
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
   ASSERT_EQ(ret, 0);
   ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
@@ -122,7 +122,7 @@ TEST(testCase, planner_test) {
   ASSERT_EQ(code, 0);
 
   SCatalogReq req = {0};
-  SParseBasicCtx  ctx = {0};
+  SParseContext  ctx = {0};
 
   int32_t  ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);
   ASSERT_EQ(ret, 0);

source/libs/parser/test/tokenizerTest.cpp

@@ -711,7 +711,7 @@ TEST(testCase, extractMeta_test) {
   char msg[128] = {0};
   SCatalogReq req  = {0};
 
-  SParseBasicCtx ctx = {0};
+  SParseContext ctx = {0};
   ctx.db = "db1";
   ctx.acctId = 1;
   int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, &ctx, msg, 128);

source/libs/planner/src/logicPlan.c

@@ -38,10 +38,10 @@ int32_t optimizeQueryPlan(struct SQueryPlanNode* pQueryNode) {
 }
 
 static int32_t createModificationOpPlan(const SQueryNode* pNode, SQueryPlanNode** pQueryPlan) {
-  SVnodeModifOpStmtInfo* pInsert = (SVnodeModifOpStmtInfo*)pNode;
+  SVnodeModifOpStmtInfo* pModifStmtInfo = (SVnodeModifOpStmtInfo*)pNode;
 
   *pQueryPlan = calloc(1, sizeof(SQueryPlanNode));
-  SArray* blocks = taosArrayInit(taosArrayGetSize(pInsert->pDataBlocks), POINTER_BYTES);
+  SArray* blocks = taosArrayInit(taosArrayGetSize(pModifStmtInfo->pDataBlocks), POINTER_BYTES);
 
   SDataPayloadInfo* pPayload = calloc(1, sizeof(SDataPayloadInfo));
   if (NULL == *pQueryPlan || NULL == blocks || NULL == pPayload) {
@@ -49,7 +49,7 @@ static int32_t createModificationOpPlan(const SQueryNode* pNode, SQueryPlanNode*
   }
 
   (*pQueryPlan)->info.type = QNODE_MODIFY;
-  taosArrayAddAll(blocks, pInsert->pDataBlocks);
+  taosArrayAddAll(blocks, pModifStmtInfo->pDataBlocks);
 
   if (pNode->type == TSDB_SQL_INSERT) {
     pPayload->msgType = TDMT_VND_SUBMIT;

source/libs/planner/src/physicalPlan.c

@@ -156,9 +156,14 @@ static SPhyNode* initPhyNode(SQueryPlanNode* pPlanNode, int32_t type, int32_t si
 }
 
 static SPhyNode* initScanNode(SQueryPlanNode* pPlanNode, SQueryTableInfo* pTable, int32_t type, int32_t size) {
-  SScanPhyNode* node = (SScanPhyNode*)initPhyNode(pPlanNode, type, size);
-  node->uid = pTable->pMeta->pTableMeta->uid;
-  node->tableType = pTable->pMeta->pTableMeta->tableType;
+  SScanPhyNode* node = (SScanPhyNode*) initPhyNode(pPlanNode, type, size);
+
+  STableMeta *pTableMeta = pTable->pMeta->pTableMeta;
+  node->uid       = pTableMeta->uid;
+  node->count     = 1;
+  node->order     = TSDB_ORDER_ASC;
+  node->tableType = pTableMeta->tableType;
+
   return (SPhyNode*)node;
 }
 
@@ -176,10 +181,10 @@ static uint8_t getScanFlag(SQueryPlanNode* pPlanNode, SQueryTableInfo* pTable) {
   return MAIN_SCAN;
 }
 
-static SPhyNode* createUserTableScanNode(SQueryPlanNode* pPlanNode, SQueryTableInfo* pTable, int32_t op) {
-  STableScanPhyNode* node = (STableScanPhyNode*)initScanNode(pPlanNode, pTable, op, sizeof(STableScanPhyNode));
-  node->scanFlag = getScanFlag(pPlanNode, pTable);
-  node->window = pTable->window;
+static SPhyNode* createUserTableScanNode(SQueryPlanNode* pPlanNode, SQueryTableInfo* pQueryTableInfo, int32_t op) {
+  STableScanPhyNode* node = (STableScanPhyNode*)initScanNode(pPlanNode, pQueryTableInfo, op, sizeof(STableScanPhyNode));
+  node->scanFlag = getScanFlag(pPlanNode, pQueryTableInfo);
+  node->window = pQueryTableInfo->window;
   // todo tag cond
   return (SPhyNode*)node;
 }

source/libs/planner/src/physicalPlanJson.c

@@ -136,7 +136,7 @@ static const cJSON* getArray(const cJSON* json, const char* name, int32_t* size)
 
 static bool fromItem(const cJSON* jArray, FFromJson func, void* array, int32_t itemSize, int32_t size) {
   for (int32_t i = 0; i < size; ++i) {
-    if (!func(cJSON_GetArrayItem(jArray, i), (char*)array + itemSize)) {
+    if (!func(cJSON_GetArrayItem(jArray, i), (char*)array + itemSize * i)) {
       return false;
     }
   }
@@ -165,9 +165,7 @@ static bool fromRawArray(const cJSON* json, const char* name, FFromJson func, vo
 
 static char* getString(const cJSON* json, const char* name) {
   char* p = cJSON_GetStringValue(cJSON_GetObjectItem(json, name));
-  char* res = calloc(1, strlen(p) + 1);
-  strcpy(res, p);
-  return res;
+  return strdup(p);
 }
 
 static void copyString(const cJSON* json, const char* name, char* dst) {
@@ -530,13 +528,25 @@ static bool timeWindowFromJson(const cJSON* json, void* obj) {
 
 static const char* jkScanNodeTableId = "TableId";
 static const char* jkScanNodeTableType = "TableType";
+static const char* jkScanNodeTableOrder = "Order";
+static const char* jkScanNodeTableCount = "Count";
 
 static bool scanNodeToJson(const void* obj, cJSON* json) {
   const SScanPhyNode* scan = (const SScanPhyNode*)obj;
   bool res = cJSON_AddNumberToObject(json, jkScanNodeTableId, scan->uid);
+
   if (res) {
     res = cJSON_AddNumberToObject(json, jkScanNodeTableType, scan->tableType);
   }
+
+  if (res) {
+    res = cJSON_AddNumberToObject(json, jkScanNodeTableOrder, scan->order);
+  }
+
+  if (res) {
+    res = cJSON_AddNumberToObject(json, jkScanNodeTableCount, scan->count);
+  }
+
   return res;
 }
 
@@ -544,6 +554,8 @@ static bool scanNodeFromJson(const cJSON* json, void* obj) {
   SScanPhyNode* scan = (SScanPhyNode*)obj;
   scan->uid = getNumber(json, jkScanNodeTableId);
   scan->tableType = getNumber(json, jkScanNodeTableType);
+  scan->count = getNumber(json, jkScanNodeTableCount);
+  scan->order = getNumber(json, jkScanNodeTableOrder);
   return true;
 }
 
@@ -748,9 +760,11 @@ static bool phyNodeToJson(const void* obj, cJSON* jNode) {
 }
 
 static bool phyNodeFromJson(const cJSON* json, void* obj) {
-  SPhyNode* node = (SPhyNode*)obj;
+  SPhyNode* node = (SPhyNode*) obj;
+
   node->info.name = getString(json, jkPnodeName);
   node->info.type = opNameToOpType(node->info.name);
+
   bool res = fromArray(json, jkPnodeTargets, exprInfoFromJson, &node->pTargets, sizeof(SExprInfo));
   if (res) {
     res = fromArray(json, jkPnodeConditions, exprInfoFromJson, &node->pConditions, sizeof(SExprInfo));
@@ -896,7 +910,8 @@ static SSubplan* subplanFromJson(const cJSON* json) {
   }
   bool res = fromObject(json, jkSubplanId, subplanIdFromJson, &subplan->id, true);
   if (res) {
-    res = fromObjectWithAlloc(json, jkSubplanNode, phyNodeFromJson, (void**)&subplan->pNode, sizeof(SPhyNode), false);
+    size_t size = MAX(sizeof(SPhyNode), sizeof(SScanPhyNode));
+    res = fromObjectWithAlloc(json, jkSubplanNode, phyNodeFromJson, (void**)&subplan->pNode, size, false);
   }
   if (res) {
     res = fromObjectWithAlloc(json, jkSubplanDataSink, dataSinkFromJson, (void**)&subplan->pDataSink, sizeof(SDataSink), false);
@@ -925,8 +940,8 @@ int32_t subPlanToString(const SSubplan* subplan, char** str, int32_t* len) {
   }
 
   *str = cJSON_Print(json);
-
-  printf("%s\n", *str);
+//  printf("====Physical plan:====\n")
+//  printf("%s\n", *str);
   *len = strlen(*str) + 1;
   return TSDB_CODE_SUCCESS;
 }

source/libs/planner/src/planner.c

@@ -65,9 +65,9 @@ int32_t qCreateQueryDag(const struct SQueryNode* pNode, struct SQueryDag** pDag,
   }
 
   if (pLogicPlan->info.type != QNODE_MODIFY) {
-    char* str = NULL;
-    queryPlanToString(pLogicPlan, &str);
-    printf("%s\n", str);
+//    char* str = NULL;
+//    queryPlanToString(pLogicPlan, &str);
+//    printf("%s\n", str);
   }
 
   code = optimizeQueryPlan(pLogicPlan);

source/libs/planner/test/phyPlanTests.cpp

@@ -135,9 +135,9 @@ private:
     _sql = sql;
     memset(_msg, 0, _msgMaxLen);
   
-    pCxt->ctx.acctId = 1;
-    pCxt->ctx.db = _db.c_str();
-    pCxt->ctx.requestId = 1;
+    pCxt->acctId = 1;
+    pCxt->db = _db.c_str();
+    pCxt->requestId = 1;
     pCxt->pSql = _sql.c_str();
     pCxt->sqlLen = _sql.length();
     pCxt->pMsg = _msg;

source/libs/scheduler/src/scheduler.c

@@ -50,6 +50,10 @@ void schFreeTask(SSchTask* pTask) {
   if (pTask->parents) {
     taosArrayDestroy(pTask->parents);
   }
+
+  if (pTask->execAddrs) {
+    taosArrayDestroy(pTask->execAddrs);
+  }
 }
 
 
@@ -798,7 +802,7 @@ int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t msgType, ch
         SQueryTableRsp *rsp = (SQueryTableRsp *)msg;
         
         if (rspCode != TSDB_CODE_SUCCESS || NULL == msg || rsp->code != TSDB_CODE_SUCCESS) {
-          SCH_ERR_RET(schProcessOnTaskFailure(pJob, pTask, rsp->code));
+          SCH_ERR_RET(schProcessOnTaskFailure(pJob, pTask, rspCode));
         }
         
         SCH_ERR_JRET(schBuildAndSendMsg(pJob, pTask, NULL, TDMT_VND_RES_READY));
@@ -1364,16 +1368,10 @@ int32_t scheduleAsyncExecJob(void *transport, SArray *nodeList, SQueryDag* pDag,
     SCH_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
   }
 
-  SSchJob *job = NULL;
-
-  SCH_ERR_RET(schExecJobImpl(transport, nodeList, pDag, &job, false));
-
-  *pJob = job;
-
+  SCH_ERR_RET(schExecJobImpl(transport, nodeList, pDag, pJob, false));
   return TSDB_CODE_SUCCESS;
 }
 
-
 int32_t scheduleFetchRows(SSchJob *pJob, void** pData) {
   if (NULL == pJob || NULL == pData) {
     SCH_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);

source/libs/scheduler/test/schedulerTests.cpp

@@ -239,8 +239,6 @@ void *schtSendRsp(void *param) {
 }
 
 struct SSchJob *pInsertJob = NULL;
-
-
 }
 
 TEST(queryTest, normalCase) {

source/libs/tfs/src/tfs.c

@@ -85,19 +85,19 @@ int tfsInit(SDiskCfg *pDiskCfg, int ndisk) {
                           taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
   if (pfs->map == NULL) {
     terrno = TSDB_CODE_FS_OUT_OF_MEMORY;
-    tfsDestroy();
+    tfsCleanup();
     return -1;
   }
 
   for (int idisk = 0; idisk < ndisk; idisk++) {
     if (tfsMount(pDiskCfg + idisk) < 0) {
-      tfsDestroy();
+      tfsCleanup();
       return -1;
     }
   }
 
   if (tfsCheck() < 0) {
-    tfsDestroy();
+    tfsCleanup();
     return -1;
   }
 
@@ -109,7 +109,7 @@ int tfsInit(SDiskCfg *pDiskCfg, int ndisk) {
   return 0;
 }
 
-void tfsDestroy() {
+void tfsCleanup() {
   taosHashCleanup(pfs->map);
   pfs->map = NULL;
 

source/libs/tkv/CMakeLists.txt

 aux_source_directory(src TKV_SRC)
 add_library(tkv STATIC ${TKV_SRC})
+# target_include_directories(
+#     tkv
+#     PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/tkv"
+#     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+# )
 target_include_directories(
     tkv
-    PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/tkv"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+    PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+    PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/src/inc"
 )
 target_link_libraries(
     tkv
     PUBLIC os
+    PUBLIC util
 )
\ No newline at end of file

source/libs/tkv/inc/tkv.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_TKV_H_
+#define _TD_TKV_H_
+
+#include "os.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declaration
+typedef struct TDB     TDB;
+typedef struct TDB_ENV TDB_ENV;
+
+// SKey
+typedef struct {
+  void *   bdata;
+  uint32_t size;
+} TDB_KEY, TDB_VALUE;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_TKV_H_*/
\ No newline at end of file

source/libs/tkv/src/inc/tkvBufPool.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_TKV_BUF_POOL_H_
+#define _TD_TKV_BUF_POOL_H_
+
+#include "tkvPage.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct STkvBufPool STkvBufPool;
+
+int       tbpOpen(STkvBufPool **ppTkvBufPool);
+int       tbpClose(STkvBufPool *pTkvBufPool);
+STkvPage *tbpNewPage(STkvBufPool *pTkvBufPool);
+int       tbpDelPage(STkvBufPool *pTkvBufPool);
+STkvPage *tbpFetchPage(STkvBufPool *pTkvBufPool, pgid_t pgid);
+int       tbpUnpinPage(STkvBufPool *pTkvBufPool, pgid_t pgid);
+void      tbpFlushPages(STkvBufPool *pTkvBufPool);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_TKV_BUF_POOL_H_*/
\ No newline at end of file

source/libs/tkv/src/inc/tkvDB.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_TKV_DB_H_
+#define _TD_TKV_DB_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct TDB {
+  // TODO
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_TKV_DB_H_*/
\ No newline at end of file

source/libs/tkv/inc/tkvDef.h → source/libs/tkv/src/inc/tkvDef.h

@@ -26,6 +26,15 @@ extern "C" {
 typedef int32_t pgid_t;
 #define TKV_IVLD_PGID ((pgid_t)-1)
 
+// framd_id_t
+typedef int32_t frame_id_t;
+
+// pgsize_t
+typedef int32_t pgsize_t;
+#define TKV_MIN_PGSIZE 512
+#define TKV_MAX_PGSIZE 16384
+#define TKV_IS_PGSIZE_VLD(s) (((s) >= TKV_MIN_PGSIZE) && (TKV_MAX_PGSIZE <= TKV_MAX_PGSIZE))
+
 #ifdef __cplusplus
 }
 #endif

source/libs/tkv/inc/tDiskMgr.h → source/libs/tkv/src/inc/tkvDiskMgr.h

@@ -24,13 +24,14 @@ extern "C" {
 
 #include "tkvDef.h"
 
-typedef struct SDiskMgr SDiskMgr;
-
-int     tdmOpen(SDiskMgr **ppDiskMgr, const char *fname, uint16_t pgsize);
-int     tdmClose(SDiskMgr *pDiskMgr);
-int     tdmReadPage(SDiskMgr *pDiskMgr, pgid_t pgid, void *pData);
-int     tdmWritePage(SDiskMgr *pDiskMgr, pgid_t pgid, const void *pData);
-int32_t tdmAllocPage(SDiskMgr *pDiskMgr);
+typedef struct STkvDiskMgr STkvDiskMgr;
+
+int    tdmOpen(STkvDiskMgr **ppDiskMgr, const char *fname, uint16_t pgsize);
+int    tdmClose(STkvDiskMgr *pDiskMgr);
+int    tdmReadPage(STkvDiskMgr *pDiskMgr, pgid_t pgid, void *pData);
+int    tdmWritePage(STkvDiskMgr *pDiskMgr, pgid_t pgid, const void *pData);
+int    tdmFlush(STkvDiskMgr *pDiskMgr);
+pgid_t tdmAllocPage(STkvDiskMgr *pDiskMgr);
 
 #ifdef __cplusplus
 }

source/libs/tkv/src/inc/tkvEnv.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_TKV_ENV_H_
+#define _TD_TKV_ENV_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct TDB_ENV {
+  char *homeDir;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_TKV_ENV_H_*/
\ No newline at end of file

source/libs/tkv/inc/tPage.h → source/libs/tkv/src/inc/tkvPage.h

@@ -17,22 +17,30 @@
 #define _TD_TKV_PAGE_H_
 
 #include "os.h"
+#include "tkvDef.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+typedef struct STkvPage {
+  pgid_t  pgid;
+  int32_t pinCount;
+  bool    idDirty;
+  char*   pData;
+} STkvPage;
+
 typedef struct {
   uint16_t dbver;
   uint16_t pgsize;
   uint32_t cksm;
-} SPgHdr;
+} STkvPgHdr;
 
-typedef struct {
-  SPgHdr   chdr;
-  uint16_t used;     // number of used slots
-  uint16_t loffset;  // the offset of the starting location of the last slot used
-} SSlottedPgHdr;
+// typedef struct {
+//   SPgHdr   chdr;
+//   uint16_t used;     // number of used slots
+//   uint16_t loffset;  // the offset of the starting location of the last slot used
+// } SSlottedPgHdr;
 
 #ifdef __cplusplus
 }

source/libs/tkv/src/tDiskMgr.c

@@ -13,37 +13,62 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "tDiskMgr.h"
+#include "tkvDiskMgr.h"
 
-struct SDiskMgr {
-  const char *fname;
+struct STkvDiskMgr {
+  char *   fname;
   uint16_t pgsize;
   FileFd   fd;
-  int32_t     npgid;
+  pgid_t   npgid;
 };
 
 #define PAGE_OFFSET(PGID, PGSIZE) ((PGID) * (PGSIZE))
 
-int tdmOpen(SDiskMgr **ppDiskMgr, const char *fname, uint16_t pgsize) {
-  // TODO
+int tdmOpen(STkvDiskMgr **ppDiskMgr, const char *fname, uint16_t pgsize) {
+  STkvDiskMgr *pDiskMgr;
+
+  pDiskMgr = malloc(sizeof(*pDiskMgr));
+  if (pDiskMgr == NULL) {
+    return -1;
+  }
+
+  pDiskMgr->fname = strdup(fname);
+  if (pDiskMgr->fname == NULL) {
+    free(pDiskMgr);
+    return -1;
+  }
+  pDiskMgr->pgsize = pgsize;
+  pDiskMgr->fd = open(fname, O_CREAT | O_RDWR, 0755);
+  if (pDiskMgr->fd < 0) {
+    free(pDiskMgr->fname);
+    free(pDiskMgr);
+    return -1;
+  }
+
+  *ppDiskMgr = pDiskMgr;
+
   return 0;
 }
 
-int tdmClose(SDiskMgr *pDiskMgr) {
-  // TODO
+int tdmClose(STkvDiskMgr *pDiskMgr) {
+  close(pDiskMgr->fd);
+  free(pDiskMgr->fname);
+  free(pDiskMgr);
   return 0;
 }
 
-int tdmReadPage(SDiskMgr *pDiskMgr, pgid_t pgid, void *pData) {
+int tdmReadPage(STkvDiskMgr *pDiskMgr, pgid_t pgid, void *pData) {
   taosLSeekFile(pDiskMgr->fd, PAGE_OFFSET(pgid, pDiskMgr->pgsize), SEEK_SET);
   taosReadFile(pDiskMgr->fd, pData, pDiskMgr->pgsize);
   return 0;
 }
 
-int tdmWritePage(SDiskMgr *pDiskMgr, pgid_t pgid, const void *pData) {
+int tdmWritePage(STkvDiskMgr *pDiskMgr, pgid_t pgid, const void *pData) {
   taosLSeekFile(pDiskMgr->fd, PAGE_OFFSET(pgid, pDiskMgr->pgsize), SEEK_SET);
   taosWriteFile(pDiskMgr->fd, pData, pDiskMgr->pgsize);
   return 0;
 }
 
-int32_t tdmAllocPage(SDiskMgr *pDiskMgr) { return pDiskMgr->npgid++; }
+int tdmFlush(STkvDiskMgr *pDiskMgr) { return taosFsyncFile(pDiskMgr->fd); }
\ No newline at end of file
+
+int32_t tdmAllocPage(STkvDiskMgr *pDiskMgr) { return pDiskMgr->npgid++; }
\ No newline at end of file

source/libs/tkv/src/tkvBufPool.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "thash.h"
+#include "tlist.h"
+
+#include "tkvBufPool.h"
+#include "tkvDiskMgr.h"
+#include "tkvPage.h"
+
+struct SFrameIdWrapper {
+  TD_SLIST_NODE(SFrameIdWrapper);
+  frame_id_t id;
+};
+
+struct STkvBufPool {
+  STkvPage*    pages;
+  STkvDiskMgr* pDiskMgr;
+  SHashObj*    pgTb;  // page_id_t --> frame_id_t
+  TD_SLIST(SFrameIdWrapper) freeList;
+  pthread_mutex_t mutex;
+};
+
+typedef struct STkvLRUReplacer {
+} STkvLRUReplacer;
+
+typedef struct STkvLFUReplacer {
+} STkvLFUReplacer;
+
+typedef struct STkvCLKReplacer {
+} STkvCLKReplacer;
+
+typedef enum { TKV_LRU_REPLACER = 0, TKV_LFU_REPLACER, TVK_CLK_REPLACER } tkv_replacer_t;
+
+typedef struct STkvReplacer {
+  tkv_replacer_t type;
+  union {
+    STkvLRUReplacer lruRep;
+    STkvLFUReplacer lfuRep;
+    STkvCLKReplacer clkRep;
+  };
+} STkvReplacer;
\ No newline at end of file

source/libs/transport/CMakeLists.txt

@@ -13,3 +13,18 @@ target_link_libraries(
     PUBLIC util
     PUBLIC common
 )
+if (${BUILD_WITH_UV}) 
+  target_include_directories(
+    transport    
+    PUBLIC "${CMAKE_SOURCE_DIR}/contrib/libuv/include"
+  )
+
+#LINK_DIRECTORIES("${CMAKE_SOURCE_DIR}/debug/contrib/libuv")
+  target_link_libraries(
+    transport    
+    PUBLIC uv_a
+  )
+  add_definitions(-DUSE_UV) 
+endif(${BUILD_WITH_UV})  
+
+  

source/libs/transport/inc/rpcCache.h

@@ -16,6 +16,8 @@
 #ifndef TDENGINE_RPC_CACHE_H
 #define TDENGINE_RPC_CACHE_H
 
+#include <stdint.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif

source/libs/transport/inc/rpcHead.h

@@ -16,33 +16,38 @@
 #ifndef TDENGINE_RPCHEAD_H
 #define TDENGINE_RPCHEAD_H
 
+#include <tdef.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#ifdef USE_UV
+
+#else
+
 #define RPC_CONN_TCP 2
 
 extern int tsRpcOverhead;
 
 typedef struct {
-  void    *msg;
+  void*    msg;
   int      msgLen;
   uint32_t ip;
   uint16_t port;
   int      connType;
-  void    *shandle;
-  void    *thandle;
-  void    *chandle;
+  void*    shandle;
+  void*    thandle;
+  void*    chandle;
 } SRecvInfo;
 
 #pragma pack(push, 1)
 
 typedef struct {
-  char     version:4; // RPC version
-  char     comp:4;    // compression algorithm, 0:no compression 1:lz4
-  char     resflag:2; // reserved bits
-  char     spi:3;     // security parameter index
-  char     encrypt:3; // encrypt algorithm, 0: no encryption
+  char     version : 4;         // RPC version
+  char     comp : 4;            // compression algorithm, 0:no compression 1:lz4
+  char     resflag : 2;         // reserved bits
+  char     spi : 3;             // security parameter index
+  char     encrypt : 3;         // encrypt algorithm, 0: no encryption
   uint16_t tranId;              // transcation ID
   uint32_t linkUid;             // for unique connection ID assigned by client
   uint64_t ahandle;             // ahandle assigned by client
@@ -70,11 +75,10 @@ typedef struct {
 } SRpcDigest;
 
 #pragma pack(pop)
-
+#endif
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif  // TDENGINE_RPCHEAD_H
-

source/libs/transport/inc/rpcTcp.h

@@ -15,11 +15,14 @@
 
 #ifndef _rpc_tcp_header_
 #define _rpc_tcp_header_
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#ifdef USE_UV
+#else
 void *taosInitTcpServer(uint32_t ip, uint16_t port, char *label, int numOfThreads, void *fp, void *shandle);
 void  taosStopTcpServer(void *param);
 void  taosCleanUpTcpServer(void *param);
@@ -32,6 +35,8 @@ void *taosOpenTcpClientConnection(void *shandle, void *thandle, uint32_t ip, uin
 void taosCloseTcpConnection(void *chandle);
 int  taosSendTcpData(uint32_t ip, uint16_t port, void *data, int len, void *chandle);
 
+#endif
+
 #ifdef __cplusplus
 }
 #endif

source/libs/transport/inc/transportInt.h

@@ -20,6 +20,11 @@
 extern "C" {
 #endif
 
+#ifdef USE_UV
+
+#else
+
+#endif
 #ifdef __cplusplus
 }
 #endif

source/libs/transport/src/rpcCache.c

@@ -13,27 +13,30 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "rpcCache.h"
 #include "os.h"
+#include "rpcLog.h"
 #include "taosdef.h"
 #include "tglobal.h"
 #include "tmempool.h"
 #include "ttimer.h"
 #include "tutil.h"
-#include "rpcLog.h"
-#include "rpcCache.h"
 
+#ifdef USE_UV
+
+#else
 typedef struct SConnHash {
   char              fqdn[TSDB_FQDN_LEN];
   uint16_t          port;
   char              connType;
   struct SConnHash *prev;
   struct SConnHash *next;
-  void             *data;
+  void *            data;
   uint64_t          time;
 } SConnHash;
 
 typedef struct {
-  SConnHash     **connHashList;
+  SConnHash **    connHashList;
   mpool_h         connHashMemPool;
   int             maxSessions;
   int             total;
@@ -41,8 +44,8 @@ typedef struct {
   int64_t         keepTimer;
   pthread_mutex_t mutex;
   void (*cleanFp)(void *);
-  void           *tmrCtrl;
-  void           *pTimer;
+  void *   tmrCtrl;
+  void *   pTimer;
   int64_t *lockedBy;
 } SConnCache;
 
@@ -134,7 +137,7 @@ void rpcAddConnIntoCache(void *handle, void *data, char *fqdn, uint16_t port, in
   pNode->prev = NULL;
   pNode->time = time;
 
-  rpcLockCache(pCache->lockedBy+hash);
+  rpcLockCache(pCache->lockedBy + hash);
 
   pNode->next = pCache->connHashList[hash];
   if (pCache->connHashList[hash] != NULL) (pCache->connHashList[hash])->prev = pNode;
@@ -143,10 +146,11 @@ void rpcAddConnIntoCache(void *handle, void *data, char *fqdn, uint16_t port, in
   pCache->count[hash]++;
   rpcRemoveExpiredNodes(pCache, pNode->next, hash, time);
 
-  rpcUnlockCache(pCache->lockedBy+hash);
+  rpcUnlockCache(pCache->lockedBy + hash);
 
   pCache->total++;
-  // tTrace("%p %s:%hu:%d:%d:%p added into cache, connections:%d", data, fqdn, port, connType, hash, pNode, pCache->count[hash]);
+  // tTrace("%p %s:%hu:%d:%d:%p added into cache, connections:%d", data, fqdn, port, connType, hash, pNode,
+  // pCache->count[hash]);
 
   return;
 }
@@ -163,7 +167,7 @@ void *rpcGetConnFromCache(void *handle, char *fqdn, uint16_t port, int8_t connTy
   uint64_t time = taosGetTimestampMs();
 
   hash = rpcHashConn(pCache, fqdn, port, connType);
-  rpcLockCache(pCache->lockedBy+hash);
+  rpcLockCache(pCache->lockedBy + hash);
 
   pNode = pCache->connHashList[hash];
   while (pNode) {
@@ -197,12 +201,14 @@ void *rpcGetConnFromCache(void *handle, char *fqdn, uint16_t port, int8_t connTy
     pCache->count[hash]--;
   }
 
-  rpcUnlockCache(pCache->lockedBy+hash);
+  rpcUnlockCache(pCache->lockedBy + hash);
 
   if (pData) {
-    //tTrace("%p %s:%hu:%d:%d:%p retrieved from cache, connections:%d", pData, fqdn, port, connType, hash, pNode, pCache->count[hash]);
+    // tTrace("%p %s:%hu:%d:%d:%p retrieved from cache, connections:%d", pData, fqdn, port, connType, hash, pNode,
+    // pCache->count[hash]);
   } else {
-    //tTrace("%s:%hu:%d:%d failed to retrieve conn from cache, connections:%d", fqdn, port, connType, hash, pCache->count[hash]);
+    // tTrace("%s:%hu:%d:%d failed to retrieve conn from cache, connections:%d", fqdn, port, connType, hash,
+    // pCache->count[hash]);
   }
 
   return pData;
@@ -221,10 +227,10 @@ static void rpcCleanConnCache(void *handle, void *tmrId) {
   uint64_t time = taosGetTimestampMs();
 
   for (hash = 0; hash < pCache->maxSessions; ++hash) {
-    rpcLockCache(pCache->lockedBy+hash);
+    rpcLockCache(pCache->lockedBy + hash);
     pNode = pCache->connHashList[hash];
     rpcRemoveExpiredNodes(pCache, pNode, hash, time);
-    rpcUnlockCache(pCache->lockedBy+hash);
+    rpcUnlockCache(pCache->lockedBy + hash);
   }
 
   // tTrace("timer, total connections in cache:%d", pCache->total);
@@ -233,7 +239,7 @@ static void rpcCleanConnCache(void *handle, void *tmrId) {
 }
 
 static void rpcRemoveExpiredNodes(SConnCache *pCache, SConnHash *pNode, int hash, uint64_t time) {
-  if (pNode == NULL || (time < pCache->keepTimer + pNode->time) ) return;
+  if (pNode == NULL || (time < pCache->keepTimer + pNode->time)) return;
 
   SConnHash *pPrev = pNode->prev, *pNext;
 
@@ -242,7 +248,8 @@ static void rpcRemoveExpiredNodes(SConnCache *pCache, SConnHash *pNode, int hash
     pNext = pNode->next;
     pCache->total--;
     pCache->count[hash]--;
-    //tTrace("%p %s:%hu:%d:%d:%p removed from cache, connections:%d", pNode->data, pNode->fqdn, pNode->port, pNode->connType, hash, pNode,
+    // tTrace("%p %s:%hu:%d:%d:%p removed from cache, connections:%d", pNode->data, pNode->fqdn, pNode->port,
+    // pNode->connType, hash, pNode,
     //         pCache->count[hash]);
     taosMemPoolFree(pCache->connHashMemPool, (char *)pNode);
     pNode = pNext;
@@ -257,7 +264,7 @@ static void rpcRemoveExpiredNodes(SConnCache *pCache, SConnHash *pNode, int hash
 static int rpcHashConn(void *handle, char *fqdn, uint16_t port, int8_t connType) {
   SConnCache *pCache = (SConnCache *)handle;
   int         hash = 0;
-  char       *temp = fqdn;
+  char *      temp = fqdn;
 
   while (*temp) {
     hash += *temp;
@@ -288,4 +295,4 @@ static void rpcUnlockCache(int64_t *lockedBy) {
     assert(false);
   }
 }
-
+#endif

source/libs/transport/src/rpcMain.c

@@ -13,31 +13,27 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifdef USE_UV
+#include <uv.h>
+#endif
+#include "lz4.h"
 #include "os.h"
+#include "rpcCache.h"
+#include "rpcHead.h"
+#include "rpcLog.h"
+#include "rpcTcp.h"
+#include "rpcUdp.h"
+#include "taoserror.h"
+#include "tglobal.h"
+#include "thash.h"
 #include "tidpool.h"
 #include "tmd5.h"
 #include "tmempool.h"
-#include "ttimer.h"
-#include "tutil.h"
-#include "lz4.h"
-#include "tref.h"
-#include "taoserror.h"
-#include "tglobal.h"
 #include "tmsg.h"
+#include "tref.h"
 #include "trpc.h"
-#include "thash.h"
-#include "rpcLog.h"
-#include "rpcUdp.h"
-#include "rpcCache.h"
-#include "rpcTcp.h"
-#include "rpcHead.h"
-
-#define RPC_MSG_OVERHEAD (sizeof(SRpcReqContext) + sizeof(SRpcHead) + sizeof(SRpcDigest)) 
-#define rpcHeadFromCont(cont) ((SRpcHead *) ((char*)cont - sizeof(SRpcHead)))
-#define rpcContFromHead(msg) (msg + sizeof(SRpcHead))
-#define rpcMsgLenFromCont(contLen) (contLen + sizeof(SRpcHead))
-#define rpcContLenFromMsg(msgLen) (msgLen - sizeof(SRpcHead))
-#define rpcIsReq(type) (type & 1U)
+#include "ttimer.h"
+#include "tutil.h"
 
 typedef struct {
   int      sessions;      // number of sessions allowed
@@ -54,28 +50,242 @@ typedef struct {
   char secret[TSDB_PASSWORD_LEN];  // secret for the link
   char ckey[TSDB_PASSWORD_LEN];    // ciphering key
 
-  void   (*cfp)(void *parent, SRpcMsg *, SEpSet *);
-  int    (*afp)(void *parent, char *user, char *spi, char *encrypt, char *secret, char *ckey); 
+  void (*cfp)(void* parent, SRpcMsg*, SEpSet*);
+  int (*afp)(void* parent, char* user, char* spi, char* encrypt, char* secret, char* ckey);
 
   int32_t          refCount;
-  void     *parent;
-  void     *idPool;   // handle to ID pool
-  void     *tmrCtrl;  // handle to timer
-  SHashObj *hash;     // handle returned by hash utility
-  void     *tcphandle;// returned handle from TCP initialization
-  void     *udphandle;// returned handle from UDP initialization
-  void     *pCache;   // connection cache
+  void*            parent;
+  void*            idPool;     // handle to ID pool
+  void*            tmrCtrl;    // handle to timer
+  SHashObj*        hash;       // handle returned by hash utility
+  void*            tcphandle;  // returned handle from TCP initialization
+  void*            udphandle;  // returned handle from UDP initialization
+  void*            pCache;     // connection cache
   pthread_mutex_t  mutex;
-  struct SRpcConn *connList;  // connection list
+  struct SRpcConn* connList;  // connection list
 } SRpcInfo;
 
+#ifdef USE_UV
+
+#define container_of(ptr, type, member) ((type*)((char*)(ptr)-offsetof(type, member)))
+
+typedef struct SThreadObj {
+  pthread_t   thread;
+  uv_pipe_t*  pipe;
+  uv_loop_t*  loop;
+  uv_async_t* workerAsync;  //
+  int         fd;
+} SThreadObj;
+
+typedef struct SServerObj {
+  uv_tcp_t     server;
+  uv_loop_t*   loop;
+  int          workerIdx;
+  int          numOfThread;
+  SThreadObj** pThreadObj;
+  uv_pipe_t**  pipe;
+} SServerObj;
+
+typedef struct SConnCtx {
+  uv_tcp_t*   pClient;
+  uv_timer_t* pTimer;
+  uv_async_t* pWorkerAsync;
+  int         ref;
+} SConnCtx;
+
+static void  allocBuffer(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf);
+static void  onTimeout(uv_timer_t* handle);
+static void  onRead(uv_stream_t* cli, ssize_t nread, const uv_buf_t* buf);
+static void  onWrite(uv_write_t* req, int status);
+static void  onAccept(uv_stream_t* stream, int status);
+void         onConnection(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf);
+static void  workerAsyncCB(uv_async_t* handle);
+static void* workerThread(void* arg);
+
+int32_t rpcInit() { return -1; }
+void    rpcCleanup() { return; };
+void*   rpcOpen(const SRpcInit* pInit) {
+  SRpcInfo* pRpc = calloc(1, sizeof(SRpcInfo));
+  if (pRpc == NULL) {
+    return NULL;
+  }
+  if (pInit->label) {
+    tstrncpy(pRpc->label, pInit->label, sizeof(pRpc->label));
+  }
+  pRpc->numOfThreads = pInit->numOfThreads > TSDB_MAX_RPC_THREADS ? TSDB_MAX_RPC_THREADS : pInit->numOfThreads;
+
+  SServerObj* srv = calloc(1, sizeof(SServerObj));
+  srv->loop = (uv_loop_t*)malloc(sizeof(uv_loop_t));
+  srv->numOfThread = pRpc->numOfThreads;
+  srv->workerIdx = 0;
+  srv->pThreadObj = (SThreadObj**)calloc(srv->numOfThread, sizeof(SThreadObj*));
+  srv->pipe = (uv_pipe_t**)calloc(srv->numOfThread, sizeof(uv_pipe_t*));
+  uv_loop_init(srv->loop);
+
+  for (int i = 0; i < srv->numOfThread; i++) {
+    srv->pThreadObj[i] = (SThreadObj*)calloc(1, sizeof(SThreadObj));
+    srv->pipe[i] = (uv_pipe_t*)calloc(2, sizeof(uv_pipe_t));
+    int fds[2];
+    if (uv_socketpair(AF_UNIX, SOCK_STREAM, fds, UV_NONBLOCK_PIPE, UV_NONBLOCK_PIPE) != 0) {
+      return NULL;
+    }
+    uv_pipe_init(srv->loop, &(srv->pipe[i][0]), 1);
+    uv_pipe_open(&(srv->pipe[i][0]), fds[1]);  // init write
+
+    srv->pThreadObj[i]->fd = fds[0];
+    srv->pThreadObj[i]->pipe = &(srv->pipe[i][1]);  // init read
+    int err = pthread_create(&(srv->pThreadObj[i]->thread), NULL, workerThread, (void*)(srv->pThreadObj[i]));
+    if (err == 0) {
+      tError("sucess to create worker thread %d", i);
+      // printf("thread %d create\n", i);
+    } else {
+      tError("failed to create worker thread %d", i);
+      return NULL;
+    }
+  }
+  uv_tcp_init(srv->loop, &srv->server);
+  struct sockaddr_in bind_addr;
+  uv_ip4_addr("0.0.0.0", pInit->localPort, &bind_addr);
+  uv_tcp_bind(&srv->server, (const struct sockaddr*)&bind_addr, 0);
+  int err = 0;
+  if ((err = uv_listen((uv_stream_t*)&srv->server, 128, onAccept)) != 0) {
+    tError("Listen error %s\n", uv_err_name(err));
+    return NULL;
+  }
+  uv_run(srv->loop, UV_RUN_DEFAULT);
+
+  return pRpc;
+}
+void  rpcClose(void* arg) { return; }
+void* rpcMallocCont(int contLen) { return NULL; }
+void  rpcFreeCont(void* cont) { return; }
+void* rpcReallocCont(void* ptr, int contLen) { return NULL; }
+
+void rpcSendRequest(void* thandle, const SEpSet* pEpSet, SRpcMsg* pMsg, int64_t* rid) { return; }
+
+void rpcSendResponse(const SRpcMsg* pMsg) {}
+
+void rpcSendRedirectRsp(void* pConn, const SEpSet* pEpSet) {}
+int  rpcGetConnInfo(void* thandle, SRpcConnInfo* pInfo) { return -1; }
+void rpcSendRecv(void* shandle, SEpSet* pEpSet, SRpcMsg* pReq, SRpcMsg* pRsp) { return; }
+int  rpcReportProgress(void* pConn, char* pCont, int contLen) { return -1; }
+void rpcCancelRequest(int64_t rid) { return; }
+
+void allocBuffer(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
+  buf->base = malloc(suggested_size);
+  buf->len = suggested_size;
+}
+
+void onTimeout(uv_timer_t* handle) {
+  // opt
+  tDebug("time out");
+}
+void onRead(uv_stream_t* cli, ssize_t nread, const uv_buf_t* buf) {
+  // opt
+  tDebug("data already was read on a stream");
+}
+
+void onWrite(uv_write_t* req, int status) {
+  // opt
+  if (req) tDebug("data already was written on stream");
+}
+
+void workerAsyncCB(uv_async_t* handle) {
+  // opt
+  SThreadObj* pObj = container_of(handle, SThreadObj, workerAsync);
+}
+void onAccept(uv_stream_t* stream, int status) {
+  if (status == -1) {
+    return;
+  }
+  SServerObj* pObj = container_of(stream, SServerObj, server);
+  tDebug("new conntion accepted by main server, dispatch to one worker thread");
+
+  uv_tcp_t* cli = (uv_tcp_t*)malloc(sizeof(uv_tcp_t));
+  uv_tcp_init(pObj->loop, cli);
+  if (uv_accept(stream, (uv_stream_t*)cli) == 0) {
+    uv_write_t* wr = (uv_write_t*)malloc(sizeof(uv_write_t));
+
+    uv_buf_t buf = uv_buf_init("a", 1);
+    // despatch to worker thread
+    pObj->workerIdx = (pObj->workerIdx + 1) % pObj->numOfThread;
+    uv_write2(wr, (uv_stream_t*)&(pObj->pipe[pObj->workerIdx][0]), &buf, 1, (uv_stream_t*)cli, onWrite);
+  } else {
+    uv_close((uv_handle_t*)cli, NULL);
+  }
+}
+void onConnection(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) {
+  if (nread < 0) {
+    if (nread != UV_EOF) {
+      tError("read error %s", uv_err_name(nread));
+    }
+    // TODO(log other failure reason)
+    uv_close((uv_handle_t*)q, NULL);
+    return;
+  }
+  SThreadObj* pObj = (SThreadObj*)container_of(q, struct SThreadObj, pipe);
+
+  uv_pipe_t* pipe = (uv_pipe_t*)q;
+  if (!uv_pipe_pending_count(pipe)) {
+    tError("No pending count");
+    return;
+  }
+  uv_handle_type pending = uv_pipe_pending_type(pipe);
+  assert(pending == UV_TCP);
+
+  SConnCtx* pConn = malloc(sizeof(SConnCtx));
+  /* init conn timer*/
+  pConn->pTimer = malloc(sizeof(uv_timer_t));
+  uv_timer_init(pObj->loop, pConn->pTimer);
+
+  pConn->pClient = (uv_tcp_t*)malloc(sizeof(uv_tcp_t));
+  pConn->pWorkerAsync = pObj->workerAsync;  // thread safty
+  uv_tcp_init(pObj->loop, pConn->pClient);
+
+  if (uv_accept(q, (uv_stream_t*)(pConn->pClient)) == 0) {
+    uv_os_fd_t fd;
+    uv_fileno((const uv_handle_t*)pConn->pClient, &fd);
+    tDebug("new connection created: %d", fd);
+    uv_timer_start(pConn->pTimer, onTimeout, 10, 0);
+    uv_read_start((uv_stream_t*)(pConn->pClient), allocBuffer, onRead);
+  } else {
+    uv_timer_stop(pConn->pTimer);
+    free(pConn->pTimer);
+    uv_close((uv_handle_t*)pConn->pClient, NULL);
+    free(pConn->pClient);
+    free(pConn);
+  }
+}
+
+void* workerThread(void* arg) {
+  SThreadObj* pObj = (SThreadObj*)arg;
+  int         fd = pObj->fd;
+  pObj->loop = (uv_loop_t*)malloc(sizeof(uv_loop_t));
+  uv_loop_init(pObj->loop);
+
+  uv_pipe_init(pObj->loop, pObj->pipe, 1);
+  uv_pipe_open(pObj->pipe, fd);
+
+  pObj->workerAsync = malloc(sizeof(uv_async_t));
+  uv_async_init(pObj->loop, pObj->workerAsync, workerAsyncCB);
+  uv_read_start((uv_stream_t*)pObj->pipe, allocBuffer, onConnection);
+}
+#else
+
+#define RPC_MSG_OVERHEAD (sizeof(SRpcReqContext) + sizeof(SRpcHead) + sizeof(SRpcDigest))
+#define rpcHeadFromCont(cont) ((SRpcHead*)((char*)cont - sizeof(SRpcHead)))
+#define rpcContFromHead(msg) (msg + sizeof(SRpcHead))
+#define rpcMsgLenFromCont(contLen) (contLen + sizeof(SRpcHead))
+#define rpcContLenFromMsg(msgLen) (msgLen - sizeof(SRpcHead))
+#define rpcIsReq(type) (type & 1U)
+
 typedef struct {
-  SRpcInfo *pRpc;       // associated SRpcInfo
+  SRpcInfo *       pRpc;      // associated SRpcInfo
   SEpSet           epSet;     // ip list provided by app
-  void     *ahandle;    // handle provided by app
+  void *           ahandle;   // handle provided by app
   struct SRpcConn *pConn;     // pConn allocated
   tmsg_t           msgType;   // message type
-  uint8_t  *pCont;      // content provided by app
+  uint8_t *        pCont;     // content provided by app
   int32_t          contLen;   // content length
   int32_t          code;      // error code
   int16_t          numOfTry;  // number of try for different servers
@@ -83,14 +293,14 @@ typedef struct {
   int8_t           redirect;  // flag to indicate redirect
   int8_t           connType;  // connection type
   int64_t          rid;       // refId returned by taosAddRef
-  SRpcMsg  *pRsp;       // for synchronous API
-  tsem_t   *pSem;       // for synchronous API
-  SEpSet   *pSet;      // for synchronous API 
+  SRpcMsg *        pRsp;      // for synchronous API
+  tsem_t *         pSem;      // for synchronous API
+  SEpSet *         pSet;      // for synchronous API
   char             msg[0];    // RpcHead starts from here
 } SRpcReqContext;
 
 typedef struct SRpcConn {
-  char      info[48];// debug info: label + pConn + ahandle
+  char            info[48];                   // debug info: label + pConn + ahandle
   int             sid;                        // session ID
   uint32_t        ownId;                      // own link ID
   uint32_t        peerId;                     // peer link ID
@@ -110,17 +320,17 @@ typedef struct SRpcConn {
   uint16_t        inTranId;                   // transcation ID for incoming msg
   tmsg_t          outType;                    // message type for outgoing request
   tmsg_t          inType;                     // message type for incoming request
-  void     *chandle;  // handle passed by TCP/UDP connection layer
-  void     *ahandle;  // handle provided by upper app layter
+  void *          chandle;                    // handle passed by TCP/UDP connection layer
+  void *          ahandle;                    // handle provided by upper app layter
   int             retry;                      // number of retry for sending request
   int             tretry;                     // total retry
-  void     *pTimer;   // retry timer to monitor the response
-  void     *pIdleTimer; // idle timer
-  char     *pRspMsg;    // response message including header
+  void *          pTimer;                     // retry timer to monitor the response
+  void *          pIdleTimer;                 // idle timer
+  char *          pRspMsg;                    // response message including header
   int             rspMsgLen;                  // response messag length
-  char     *pReqMsg;    // request message including header
+  char *          pReqMsg;                    // request message including header
   int             reqMsgLen;                  // request message length
-  SRpcInfo *pRpc;       // the associated SRpcInfo
+  SRpcInfo *      pRpc;                       // the associated SRpcInfo
   int8_t          connType;                   // connection type
   int64_t         lockedBy;                   // lock for connection
   SRpcReqContext *pContext;                   // request context
@@ -137,7 +347,7 @@ int tsRpcOverhead;
 
 static int     tsRpcRefId = -1;
 static int32_t tsRpcNum = 0;
-//static pthread_once_t tsRpcInit = PTHREAD_ONCE_INIT;
+// static pthread_once_t tsRpcInit = PTHREAD_ONCE_INIT;
 
 // server:0 client:1  tcp:2 udp:0
 #define RPC_CONN_UDPS 0
@@ -146,18 +356,10 @@ static int32_t tsRpcNum = 0;
 #define RPC_CONN_TCPC 3
 
 void *(*taosInitConn[])(uint32_t ip, uint16_t port, char *label, int threads, void *fp, void *shandle) = {
-    taosInitUdpConnection,
-    taosInitUdpConnection,
-    taosInitTcpServer, 
-    taosInitTcpClient
-};
+    taosInitUdpConnection, taosInitUdpConnection, taosInitTcpServer, taosInitTcpClient};
 
-void (*taosCleanUpConn[])(void *thandle) = {
-    taosCleanUpUdpConnection, 
-    taosCleanUpUdpConnection, 
-    taosCleanUpTcpServer,
-    taosCleanUpTcpClient
-};
+void (*taosCleanUpConn[])(void *thandle) = {taosCleanUpUdpConnection, taosCleanUpUdpConnection, taosCleanUpTcpServer,
+                                            taosCleanUpTcpClient};
 
 void (*taosStopConn[])(void *thandle) = {
     taosStopUdpConnection,
@@ -167,11 +369,7 @@ void (*taosStopConn[])(void *thandle) = {
 };
 
 int (*taosSendData[])(uint32_t ip, uint16_t port, void *data, int len, void *chandle) = {
-    taosSendUdpData, 
-    taosSendUdpData, 
-    taosSendTcpData, 
-    taosSendTcpData
-};
+    taosSendUdpData, taosSendUdpData, taosSendTcpData, taosSendTcpData};
 
 void *(*taosOpenConn[])(void *shandle, void *thandle, uint32_t ip, uint16_t port) = {
     taosOpenUdpConnection,
@@ -180,12 +378,7 @@ void *(*taosOpenConn[])(void *shandle, void *thandle, uint32_t ip, uint16_t port
     taosOpenTcpClientConnection,
 };
 
-void (*taosCloseConn[])(void *chandle) = {
-    NULL, 
-    NULL, 
-    taosCloseTcpConnection, 
-    taosCloseTcpConnection
-};
+void (*taosCloseConn[])(void *chandle) = {NULL, NULL, taosCloseTcpConnection, taosCloseTcpConnection};
 
 static SRpcConn *rpcOpenConn(SRpcInfo *pRpc, char *peerFqdn, uint16_t peerPort, int8_t connType);
 static void      rpcCloseConn(void *thandle);
@@ -208,7 +401,7 @@ static void  rpcProcessIdleTimer(void *param, void *tmrId);
 static void  rpcProcessProgressTimer(void *param, void *tmrId);
 
 static void      rpcFreeMsg(void *msg);
-static int32_t rpcCompressRpcMsg(char* pCont, int32_t contLen);
+static int32_t   rpcCompressRpcMsg(char *pCont, int32_t contLen);
 static SRpcHead *rpcDecompressRpcMsg(SRpcHead *pHead);
 static int       rpcAddAuthPart(SRpcConn *pConn, char *msg, int msgLen);
 static int       rpcCheckAuthentication(SRpcConn *pConn, char *msg, int msgLen);
@@ -244,22 +437,22 @@ void rpcCleanup(void) {
 void *rpcOpen(const SRpcInit *pInit) {
   SRpcInfo *pRpc;
 
-  //pthread_once(&tsRpcInit, rpcInit);
+  // pthread_once(&tsRpcInit, rpcInit);
 
   pRpc = (SRpcInfo *)calloc(1, sizeof(SRpcInfo));
   if (pRpc == NULL) return NULL;
 
-  if(pInit->label) tstrncpy(pRpc->label, pInit->label, sizeof(pRpc->label));
+  if (pInit->label) tstrncpy(pRpc->label, pInit->label, sizeof(pRpc->label));
   pRpc->connType = pInit->connType;
   if (pRpc->connType == TAOS_CONN_CLIENT) {
     pRpc->numOfThreads = pInit->numOfThreads;
   } else {
-    pRpc->numOfThreads = pInit->numOfThreads>TSDB_MAX_RPC_THREADS ? TSDB_MAX_RPC_THREADS:pInit->numOfThreads;
+    pRpc->numOfThreads = pInit->numOfThreads > TSDB_MAX_RPC_THREADS ? TSDB_MAX_RPC_THREADS : pInit->numOfThreads;
   }
   pRpc->idleTime = pInit->idleTime;
   pRpc->localPort = pInit->localPort;
   pRpc->afp = pInit->afp;
-  pRpc->sessions = pInit->sessions+1;
+  pRpc->sessions = pInit->sessions + 1;
   if (pInit->user) tstrncpy(pRpc->user, pInit->user, sizeof(pRpc->user));
   if (pInit->secret) memcpy(pRpc->secret, pInit->secret, sizeof(pRpc->secret));
   if (pInit->ckey) tstrncpy(pRpc->ckey, pInit->ckey, sizeof(pRpc->ckey));
@@ -279,14 +472,14 @@ void *rpcOpen(const SRpcInit *pInit) {
     return NULL;
   }
 
-  pRpc->idPool = taosInitIdPool(pRpc->sessions-1);
+  pRpc->idPool = taosInitIdPool(pRpc->sessions - 1);
   if (pRpc->idPool == NULL) {
     tError("%s failed to init ID pool", pRpc->label);
     rpcClose(pRpc);
     return NULL;
   }
 
-  pRpc->tmrCtrl = taosTmrInit(pRpc->sessions*2 + 1, 50, 10000, pRpc->label);
+  pRpc->tmrCtrl = taosTmrInit(pRpc->sessions * 2 + 1, 50, 10000, pRpc->label);
   if (pRpc->tmrCtrl == NULL) {
     tError("%s failed to init timers", pRpc->label);
     rpcClose(pRpc);
@@ -302,7 +495,7 @@ void *rpcOpen(const SRpcInit *pInit) {
     }
   } else {
     pRpc->pCache = rpcOpenConnCache(pRpc->sessions, rpcCloseConn, pRpc->tmrCtrl, pRpc->idleTime * 20);
-    if ( pRpc->pCache == NULL ) {
+    if (pRpc->pCache == NULL) {
       tError("%s failed to init connection cache", pRpc->label);
       rpcClose(pRpc);
       return NULL;
@@ -311,10 +504,10 @@ void *rpcOpen(const SRpcInit *pInit) {
 
   pthread_mutex_init(&pRpc->mutex, NULL);
 
-  pRpc->tcphandle = (*taosInitConn[pRpc->connType|RPC_CONN_TCP])(0, pRpc->localPort, pRpc->label, 
-                                                  pRpc->numOfThreads, rpcProcessMsgFromPeer, pRpc);
-  pRpc->udphandle = (*taosInitConn[pRpc->connType])(0, pRpc->localPort, pRpc->label, 
-                                                  pRpc->numOfThreads, rpcProcessMsgFromPeer, pRpc);
+  pRpc->tcphandle = (*taosInitConn[pRpc->connType | RPC_CONN_TCP])(0, pRpc->localPort, pRpc->label, pRpc->numOfThreads,
+                                                                   rpcProcessMsgFromPeer, pRpc);
+  pRpc->udphandle =
+      (*taosInitConn[pRpc->connType])(0, pRpc->localPort, pRpc->label, pRpc->numOfThreads, rpcProcessMsgFromPeer, pRpc);
 
   if (pRpc->tcphandle == NULL || pRpc->udphandle == NULL) {
     tError("%s failed to init network, port:%d", pRpc->label, pRpc->localPort);
@@ -375,7 +568,7 @@ void *rpcReallocCont(void *ptr, int contLen) {
   if (ptr == NULL) return rpcMallocCont(contLen);
 
   char *start = ((char *)ptr) - sizeof(SRpcReqContext) - sizeof(SRpcHead);
-  if (contLen == 0 ) {
+  if (contLen == 0) {
     free(start);
     return NULL;
   }
@@ -391,11 +584,11 @@ void *rpcReallocCont(void *ptr, int contLen) {
 }
 
 void rpcSendRequest(void *shandle, const SEpSet *pEpSet, SRpcMsg *pMsg, int64_t *pRid) {
-  SRpcInfo       *pRpc = (SRpcInfo *)shandle;
+  SRpcInfo *      pRpc = (SRpcInfo *)shandle;
   SRpcReqContext *pContext;
 
   int contLen = rpcCompressRpcMsg(pMsg->pCont, pMsg->contLen);
-  pContext = (SRpcReqContext *) ((char*)pMsg->pCont-sizeof(SRpcHead)-sizeof(SRpcReqContext));
+  pContext = (SRpcReqContext *)((char *)pMsg->pCont - sizeof(SRpcHead) - sizeof(SRpcReqContext));
   pContext->ahandle = pMsg->ahandle;
   pContext->pRpc = (SRpcInfo *)shandle;
   pContext->epSet = *pEpSet;
@@ -405,15 +598,14 @@ void rpcSendRequest(void *shandle, const SEpSet *pEpSet, SRpcMsg *pMsg, int64_t
   pContext->oldInUse = pEpSet->inUse;
 
   pContext->connType = RPC_CONN_UDPC;
-  if (contLen > tsRpcMaxUdpSize || tsRpcForceTcp ) pContext->connType = RPC_CONN_TCPC;
+  if (contLen > tsRpcMaxUdpSize || tsRpcForceTcp) pContext->connType = RPC_CONN_TCPC;
 
   // connection type is application specific.
   // for TDengine, all the query, show commands shall have TCP connection
   tmsg_t type = pMsg->msgType;
-  if (type == TDMT_VND_QUERY || type == TDMT_MND_SHOW_RETRIEVE
-    || type == TDMT_VND_FETCH || type == TDMT_MND_VGROUP_LIST
-    || type == TDMT_VND_TABLES_META || type == TDMT_VND_TABLE_META
-    || type == TDMT_MND_SHOW || type == TDMT_MND_STATUS || type == TDMT_VND_ALTER_TABLE)
+  if (type == TDMT_VND_QUERY || type == TDMT_MND_SHOW_RETRIEVE || type == TDMT_VND_FETCH ||
+      type == TDMT_MND_VGROUP_LIST || type == TDMT_VND_TABLES_META || type == TDMT_VND_TABLE_META ||
+      type == TDMT_MND_SHOW || type == TDMT_MND_STATUS || type == TDMT_VND_ALTER_TABLE)
     pContext->connType = RPC_CONN_TCPC;
 
   pContext->rid = taosAddRef(tsRpcRefId, pContext);
@@ -428,23 +620,23 @@ void rpcSendResponse(const SRpcMsg *pRsp) {
   int       msgLen = 0;
   SRpcConn *pConn = (SRpcConn *)pRsp->handle;
   SRpcMsg   rpcMsg = *pRsp;
-  SRpcMsg   *pMsg = &rpcMsg;
+  SRpcMsg * pMsg = &rpcMsg;
   SRpcInfo *pRpc = pConn->pRpc;
 
-  if ( pMsg->pCont == NULL ) {
+  if (pMsg->pCont == NULL) {
     pMsg->pCont = rpcMallocCont(0);
     pMsg->contLen = 0;
   }
 
   SRpcHead *pHead = rpcHeadFromCont(pMsg->pCont);
-  char      *msg = (char *)pHead;
+  char *    msg = (char *)pHead;
 
   pMsg->contLen = rpcCompressRpcMsg(pMsg->pCont, pMsg->contLen);
   msgLen = rpcMsgLenFromCont(pMsg->contLen);
 
   rpcLockConn(pConn);
 
-  if ( pConn->inType == 0 || pConn->user[0] == 0 ) {
+  if (pConn->inType == 0 || pConn->user[0] == 0) {
     tError("%s, connection is already released, rsp wont be sent", pConn->info);
     rpcUnlockConn(pConn);
     rpcFreeCont(pMsg->pCont);
@@ -454,7 +646,7 @@ void rpcSendResponse(const SRpcMsg *pRsp) {
 
   // set msg header
   pHead->version = 1;
-  pHead->msgType = pConn->inType+1;
+  pHead->msgType = pConn->inType + 1;
   pHead->spi = pConn->spi;
   pHead->encrypt = pConn->encrypt;
   pHead->tranId = pConn->inTranId;
@@ -463,7 +655,7 @@ void rpcSendResponse(const SRpcMsg *pRsp) {
   pHead->linkUid = pConn->linkUid;
   pHead->port = htons(pConn->localPort);
   pHead->code = htonl(pMsg->code);
-  pHead->ahandle = (uint64_t) pConn->ahandle;
+  pHead->ahandle = (uint64_t)pConn->ahandle;
 
   // set pConn parameters
   pConn->inType = 0;
@@ -482,8 +674,7 @@ void rpcSendResponse(const SRpcMsg *pRsp) {
   rpcSendMsgToPeer(pConn, msg, msgLen);
 
   // if not set to secured, set it expcet NOT_READY case, since client wont treat it as secured
-  if (pConn->secured == 0 && pMsg->code != TSDB_CODE_RPC_NOT_READY)
-    pConn->secured = 1; // connection shall be secured
+  if (pConn->secured == 0 && pMsg->code != TSDB_CODE_RPC_NOT_READY) pConn->secured = 1;  // connection shall be secured
 
   if (pConn->pReqMsg) rpcFreeCont(pConn->pReqMsg);
   pConn->pReqMsg = NULL;
@@ -527,7 +718,7 @@ int rpcGetConnInfo(void *thandle, SRpcConnInfo *pInfo) {
 
 void rpcSendRecv(void *shandle, SEpSet *pEpSet, SRpcMsg *pMsg, SRpcMsg *pRsp) {
   SRpcReqContext *pContext;
-  pContext = (SRpcReqContext *) ((char*)pMsg->pCont-sizeof(SRpcHead)-sizeof(SRpcReqContext));
+  pContext = (SRpcReqContext *)((char *)pMsg->pCont - sizeof(SRpcHead) - sizeof(SRpcReqContext));
 
   memset(pRsp, 0, sizeof(SRpcMsg));
 
@@ -567,7 +758,6 @@ int rpcReportProgress(void *handle, char *pCont, int contLen) {
 }
 
 void rpcCancelRequest(int64_t rid) {
-
   SRpcReqContext *pContext = taosAcquireRef(tsRpcRefId, rid);
   if (pContext == NULL) return;
 
@@ -577,7 +767,7 @@ void rpcCancelRequest(int64_t rid) {
 }
 
 static void rpcFreeMsg(void *msg) {
-  if ( msg ) {
+  if (msg) {
     char *temp = (char *)msg - sizeof(SRpcReqContext);
     free(temp);
     tTrace("free mem: %p", temp);
@@ -604,7 +794,7 @@ static SRpcConn *rpcOpenConn(SRpcInfo *pRpc, char *peerFqdn, uint16_t peerPort,
     pConn->connType = connType;
 
     if (taosOpenConn[connType]) {
-      void *shandle = (connType & RPC_CONN_TCP)? pRpc->tcphandle:pRpc->udphandle;
+      void *shandle = (connType & RPC_CONN_TCP) ? pRpc->tcphandle : pRpc->udphandle;
       pConn->chandle = (*taosOpenConn[connType])(shandle, pConn, pConn->peerIp, pConn->peerPort);
       if (pConn->chandle == NULL) {
         tError("failed to connect to:%s:%d", taosIpStr(pConn->peerIp), pConn->peerPort);
@@ -629,9 +819,10 @@ static void rpcReleaseConn(SRpcConn *pConn) {
   taosTmrStopA(&pConn->pTimer);
   taosTmrStopA(&pConn->pIdleTimer);
 
-  if ( pRpc->connType == TAOS_CONN_SERVER) {
+  if (pRpc->connType == TAOS_CONN_SERVER) {
     char   hashstr[40] = {0};
-    size_t size = snprintf(hashstr, sizeof(hashstr), "%x:%x:%x:%d", pConn->peerIp, pConn->linkUid, pConn->peerId, pConn->connType);
+    size_t size = snprintf(hashstr, sizeof(hashstr), "%x:%x:%x:%d", pConn->peerIp, pConn->linkUid, pConn->peerId,
+                           pConn->connType);
     taosHashRemove(pRpc->hash, hashstr, size);
     rpcFreeMsg(pConn->pRspMsg);  // it may have a response msg saved, but not request msg
     pConn->pRspMsg = NULL;
@@ -682,8 +873,7 @@ static void rpcCloseConn(void *thandle) {
 
   rpcLockConn(pConn);
 
-  if (pConn->user[0])
-    rpcReleaseConn(pConn);
+  if (pConn->user[0]) rpcReleaseConn(pConn);
 
   rpcUnlockConn(pConn);
 }
@@ -717,7 +907,8 @@ static SRpcConn *rpcAllocateServerConn(SRpcInfo *pRpc, SRecvInfo *pRecv) {
   char      hashstr[40] = {0};
   SRpcHead *pHead = (SRpcHead *)pRecv->msg;
 
-  size_t size = snprintf(hashstr, sizeof(hashstr), "%x:%x:%x:%d", pRecv->ip, pHead->linkUid, pHead->sourceId, pRecv->connType);
+  size_t size =
+      snprintf(hashstr, sizeof(hashstr), "%x:%x:%x:%d", pRecv->ip, pHead->linkUid, pHead->sourceId, pRecv->connType);
 
   // check if it is already allocated
   SRpcConn **ppConn = (SRpcConn **)(taosHashGet(pRpc->hash, hashstr, size));
@@ -767,7 +958,8 @@ static SRpcConn *rpcAllocateServerConn(SRpcInfo *pRpc, SRecvInfo *pRecv) {
     }
 
     taosHashPut(pRpc->hash, hashstr, size, (char *)&pConn, POINTER_BYTES);
-    tDebug("%s %p server connection is allocated, uid:0x%x sid:%d key:%s", pRpc->label, pConn, pConn->linkUid, sid, hashstr);
+    tDebug("%s %p server connection is allocated, uid:0x%x sid:%d key:%s", pRpc->label, pConn, pConn->linkUid, sid,
+           hashstr);
   }
 
   return pConn;
@@ -805,10 +997,11 @@ static SRpcConn *rpcGetConnObj(SRpcInfo *pRpc, int sid, SRecvInfo *pRecv) {
 static SRpcConn *rpcSetupConnToServer(SRpcReqContext *pContext) {
   SRpcConn *pConn;
   SRpcInfo *pRpc = pContext->pRpc;
-  SEpSet   *pEpSet = &pContext->epSet;
+  SEpSet *  pEpSet = &pContext->epSet;
 
-  pConn = rpcGetConnFromCache(pRpc->pCache, pEpSet->fqdn[pEpSet->inUse], pEpSet->port[pEpSet->inUse], pContext->connType);
-  if ( pConn == NULL || pConn->user[0] == 0) {
+  pConn =
+      rpcGetConnFromCache(pRpc->pCache, pEpSet->fqdn[pEpSet->inUse], pEpSet->port[pEpSet->inUse], pContext->connType);
+  if (pConn == NULL || pConn->user[0] == 0) {
     pConn = rpcOpenConn(pRpc, pEpSet->fqdn[pEpSet->inUse], pEpSet->port[pEpSet->inUse], pContext->connType);
   }
 
@@ -825,13 +1018,11 @@ static SRpcConn *rpcSetupConnToServer(SRpcReqContext *pContext) {
 }
 
 static int rpcProcessReqHead(SRpcConn *pConn, SRpcHead *pHead) {
-
   if (pConn->peerId == 0) {
     pConn->peerId = pHead->sourceId;
   } else {
     if (pConn->peerId != pHead->sourceId) {
-        tDebug("%s, source Id is changed, old:0x%08x new:0x%08x", pConn->info, 
-               pConn->peerId, pHead->sourceId);
+      tDebug("%s, source Id is changed, old:0x%08x new:0x%08x", pConn->info, pConn->peerId, pHead->sourceId);
       return TSDB_CODE_RPC_INVALID_VALUE;
     }
   }
@@ -856,8 +1047,7 @@ static int rpcProcessReqHead(SRpcConn *pConn, SRpcHead *pHead) {
   }
 
   if (pConn->inType != 0) {
-      tDebug("%s, last session is not finished, inTranId:%d tranId:%d", pConn->info, 
-              pConn->inTranId, pHead->tranId);
+    tDebug("%s, last session is not finished, inTranId:%d tranId:%d", pConn->info, pConn->inTranId, pHead->tranId);
     return TSDB_CODE_RPC_LAST_SESSION_NOT_FINISHED;
   }
 
@@ -961,18 +1151,22 @@ static SRpcConn *rpcProcessMsgHead(SRpcInfo *pRpc, SRecvInfo *pRecv, SRpcReqCont
 
   if (TMSG_INDEX(pHead->msgType) >= TDMT_MAX || TMSG_INDEX(pHead->msgType) <= 0) {
     tDebug("%s sid:%d, invalid message type:%d", pRpc->label, sid, pHead->msgType);
-    terrno = TSDB_CODE_RPC_INVALID_MSG_TYPE; return NULL;
+    terrno = TSDB_CODE_RPC_INVALID_MSG_TYPE;
+    return NULL;
   }
 
   if (sid < 0 || sid >= pRpc->sessions) {
-    tDebug("%s sid:%d, sid is out of range, max sid:%d, %s discarded", pRpc->label, sid,
-           pRpc->sessions, TMSG_INFO(pHead->msgType));
-    terrno = TSDB_CODE_RPC_INVALID_SESSION_ID; return NULL;
+    tDebug("%s sid:%d, sid is out of range, max sid:%d, %s discarded", pRpc->label, sid, pRpc->sessions,
+           TMSG_INFO(pHead->msgType));
+    terrno = TSDB_CODE_RPC_INVALID_SESSION_ID;
+    return NULL;
   }
 
   if (rpcIsReq(pHead->msgType) && htonl(pHead->msgVer) != tsVersion >> 8) {
-    tDebug("%s sid:%d, invalid client version:%x/%x %s", pRpc->label, sid, htonl(pHead->msgVer), tsVersion, TMSG_INFO(pHead->msgType));
-    terrno = TSDB_CODE_RPC_INVALID_VERSION; return NULL;
+    tDebug("%s sid:%d, invalid client version:%x/%x %s", pRpc->label, sid, htonl(pHead->msgVer), tsVersion,
+           TMSG_INFO(pHead->msgType));
+    terrno = TSDB_CODE_RPC_INVALID_VERSION;
+    return NULL;
   }
 
   pConn = rpcGetConnObj(pRpc, sid, pRecv);
@@ -1004,7 +1198,7 @@ static SRpcConn *rpcProcessMsgHead(SRpcInfo *pRpc, SRecvInfo *pRecv, SRpcReqCont
       // decrypt here
     }
 
-    if ( rpcIsReq(pHead->msgType) ) {
+    if (rpcIsReq(pHead->msgType)) {
       pConn->connType = pRecv->connType;
       terrno = rpcProcessReqHead(pConn, pHead);
 
@@ -1013,7 +1207,7 @@ static SRpcConn *rpcProcessMsgHead(SRpcInfo *pRpc, SRecvInfo *pRecv, SRpcReqCont
 
       // client shall send the request within tsRpcTime again for UDP, double it
       if (pConn->connType != RPC_CONN_TCPS)
-        pConn->pIdleTimer = taosTmrStart(rpcProcessIdleTimer, tsRpcTimer*2, pConn, pRpc->tmrCtrl);
+        pConn->pIdleTimer = taosTmrStart(rpcProcessIdleTimer, tsRpcTimer * 2, pConn, pRpc->tmrCtrl);
     } else {
       terrno = rpcProcessRspHead(pConn, pHead);
       *ppContext = pConn->pContext;
@@ -1026,7 +1220,7 @@ static SRpcConn *rpcProcessMsgHead(SRpcInfo *pRpc, SRecvInfo *pRecv, SRpcReqCont
 }
 
 static void doRpcReportBrokenLinkToServer(void *param, void *id) {
-   SRpcMsg *pRpcMsg = (SRpcMsg *)(param); 
+  SRpcMsg * pRpcMsg = (SRpcMsg *)(param);
   SRpcConn *pConn = (SRpcConn *)(pRpcMsg->handle);
   SRpcInfo *pRpc = pConn->pRpc;
   (*(pRpc->cfp))(pRpc->parent, pRpcMsg, NULL);
@@ -1100,13 +1294,13 @@ static void *rpcProcessMsgFromPeer(SRecvInfo *pRecv) {
   taosIpPort2String(pRecv->ip, pRecv->port, ipstr);
 
   if (TMSG_INDEX(pHead->msgType) >= 1 && TMSG_INDEX(pHead->msgType) < TDMT_MAX) {
-    tDebug("%s %p %p, %s received from %s, parse code:0x%x len:%d sig:0x%08x:0x%08x:%d code:0x%x", pRpc->label,
-           pConn, (void *)pHead->ahandle, TMSG_INFO(pHead->msgType), ipstr, terrno, pRecv->msgLen,
-           pHead->sourceId, pHead->destId, pHead->tranId, pHead->code);
+    tDebug("%s %p %p, %s received from %s, parse code:0x%x len:%d sig:0x%08x:0x%08x:%d code:0x%x", pRpc->label, pConn,
+           (void *)pHead->ahandle, TMSG_INFO(pHead->msgType), ipstr, terrno, pRecv->msgLen, pHead->sourceId,
+           pHead->destId, pHead->tranId, pHead->code);
   } else {
-    tDebug("%s %p %p, %d received from %s, parse code:0x%x len:%d sig:0x%08x:0x%08x:%d code:0x%x", pRpc->label,
-           pConn, (void *)pHead->ahandle, pHead->msgType, ipstr, terrno, pRecv->msgLen,
-           pHead->sourceId, pHead->destId, pHead->tranId, pHead->code);
+    tDebug("%s %p %p, %d received from %s, parse code:0x%x len:%d sig:0x%08x:0x%08x:%d code:0x%x", pRpc->label, pConn,
+           (void *)pHead->ahandle, pHead->msgType, ipstr, terrno, pRecv->msgLen, pHead->sourceId, pHead->destId,
+           pHead->tranId, pHead->code);
   }
 
   int32_t code = terrno;
@@ -1118,9 +1312,11 @@ static void *rpcProcessMsgFromPeer(SRecvInfo *pRecv) {
           rpcCloseConn(pConn);
         }
         if (TMSG_INDEX(pHead->msgType) + 1 > 1 && TMSG_INDEX(pHead->msgType) + 1 < TDMT_MAX) {
-          tDebug("%s %p %p, %s is sent with error code:0x%x", pRpc->label, pConn, (void *)pHead->ahandle, TMSG_INFO(pHead->msgType+1), code);
+          tDebug("%s %p %p, %s is sent with error code:0x%x", pRpc->label, pConn, (void *)pHead->ahandle,
+                 TMSG_INFO(pHead->msgType + 1), code);
         } else {
-          tError("%s %p %p, %s is sent with error code:0x%x", pRpc->label, pConn, (void *)pHead->ahandle, TMSG_INFO(pHead->msgType), code);
+          tError("%s %p %p, %s is sent with error code:0x%x", pRpc->label, pConn, (void *)pHead->ahandle,
+                 TMSG_INFO(pHead->msgType), code);
         }
       }
     } else {  // msg is passed to app only parsing is ok
@@ -1144,8 +1340,7 @@ static void rpcNotifyClient(SRpcReqContext *pContext, SRpcMsg *pMsg) {
   } else {
     // for asynchronous API
     SEpSet *pEpSet = NULL;
-    if (pContext->epSet.inUse != pContext->oldInUse || pContext->redirect) 
-      pEpSet = &pContext->epSet;
+    if (pContext->epSet.inUse != pContext->oldInUse || pContext->redirect) pEpSet = &pContext->epSet;
 
     (*pRpc->cfp)(pRpc->parent, pMsg, pEpSet);
   }
@@ -1155,7 +1350,6 @@ static void rpcNotifyClient(SRpcReqContext *pContext, SRpcMsg *pMsg) {
 }
 
 static void rpcProcessIncomingMsg(SRpcConn *pConn, SRpcHead *pHead, SRpcReqContext *pContext) {
-
   SRpcInfo *pRpc = pConn->pRpc;
   SRpcMsg   rpcMsg;
 
@@ -1180,14 +1374,15 @@ static void rpcProcessIncomingMsg(SRpcConn *pConn, SRpcHead *pHead, SRpcReqConte
 
     // for UDP, port may be changed by server, the port in epSet shall be used for cache
     if (pHead->code != TSDB_CODE_RPC_TOO_SLOW) {
-      rpcAddConnIntoCache(pRpc->pCache, pConn, pConn->peerFqdn, pContext->epSet.port[pContext->epSet.inUse], pConn->connType);    
+      rpcAddConnIntoCache(pRpc->pCache, pConn, pConn->peerFqdn, pContext->epSet.port[pContext->epSet.inUse],
+                          pConn->connType);
     } else {
       rpcCloseConn(pConn);
     }
 
     if (pHead->code == TSDB_CODE_RPC_REDIRECT) {
       pContext->numOfTry = 0;
-      SEpSet *pEpSet = (SEpSet*)pHead->content;
+      SEpSet *pEpSet = (SEpSet *)pHead->content;
       if (pEpSet->numOfEps > 0) {
         memcpy(&pContext->epSet, pHead->content, sizeof(pContext->epSet));
         tDebug("%s, redirect is received, numOfEps:%d inUse:%d", pConn->info, pContext->epSet.numOfEps,
@@ -1200,7 +1395,8 @@ static void rpcProcessIncomingMsg(SRpcConn *pConn, SRpcHead *pHead, SRpcReqConte
       }
       rpcSendReqToServer(pRpc, pContext);
       rpcFreeCont(rpcMsg.pCont);
-    } else if (pHead->code == TSDB_CODE_RPC_NOT_READY || pHead->code == TSDB_CODE_APP_NOT_READY || pHead->code == TSDB_CODE_DND_OFFLINE) {
+    } else if (pHead->code == TSDB_CODE_RPC_NOT_READY || pHead->code == TSDB_CODE_APP_NOT_READY ||
+               pHead->code == TSDB_CODE_DND_OFFLINE) {
       pContext->code = pHead->code;
       rpcProcessConnError(pContext, NULL);
       rpcFreeCont(rpcMsg.pCont);
@@ -1218,7 +1414,7 @@ static void rpcSendQuickRsp(SRpcConn *pConn, int32_t code) {
   memset(msg, 0, sizeof(SRpcHead));
   pHead = (SRpcHead *)msg;
   pHead->version = 1;
-  pHead->msgType = pConn->inType+1;
+  pHead->msgType = pConn->inType + 1;
   pHead->spi = pConn->spi;
   pHead->encrypt = 0;
   pHead->tranId = pConn->inTranId;
@@ -1258,7 +1454,7 @@ static void rpcSendReqHead(SRpcConn *pConn) {
 
 static void rpcSendErrorMsgToPeer(SRecvInfo *pRecv, int32_t code) {
   SRpcHead *pRecvHead, *pReplyHead;
-  char       msg[sizeof(SRpcHead) + sizeof(SRpcDigest) + sizeof(uint32_t) ];
+  char      msg[sizeof(SRpcHead) + sizeof(SRpcDigest) + sizeof(uint32_t)];
   uint32_t  timeStamp;
   int       msgLen;
 
@@ -1295,7 +1491,7 @@ static void rpcSendErrorMsgToPeer(SRecvInfo *pRecv, int32_t code) {
 
 static void rpcSendReqToServer(SRpcInfo *pRpc, SRpcReqContext *pContext) {
   SRpcHead *pHead = rpcHeadFromCont(pContext->pCont);
-  char      *msg = (char *)pHead;
+  char *    msg = (char *)pHead;
   int       msgLen = rpcMsgLenFromCont(pContext->contLen);
   tmsg_t    msgType = pContext->msgType;
 
@@ -1317,7 +1513,7 @@ static void rpcSendReqToServer(SRpcInfo *pRpc, SRpcReqContext *pContext) {
   pHead->msgType = msgType;
   pHead->encrypt = 0;
   pConn->tranId++;
-  if ( pConn->tranId == 0 ) pConn->tranId++;
+  if (pConn->tranId == 0) pConn->tranId++;
   pHead->tranId = pConn->tranId;
   pHead->sourceId = pConn->ownId;
   pHead->destId = pConn->peerId;
@@ -1346,18 +1542,16 @@ static void rpcSendMsgToPeer(SRpcConn *pConn, void *msg, int msgLen) {
 
   msgLen = rpcAddAuthPart(pConn, msg, msgLen);
 
-  if ( rpcIsReq(pHead->msgType)) {
-    tDebug("%s, %s is sent to %s:%hu, len:%d sig:0x%08x:0x%08x:%d",
-           pConn->info, TMSG_INFO(pHead->msgType), pConn->peerFqdn, pConn->peerPort, 
-           msgLen, pHead->sourceId, pHead->destId, pHead->tranId);
+  if (rpcIsReq(pHead->msgType)) {
+    tDebug("%s, %s is sent to %s:%hu, len:%d sig:0x%08x:0x%08x:%d", pConn->info, TMSG_INFO(pHead->msgType),
+           pConn->peerFqdn, pConn->peerPort, msgLen, pHead->sourceId, pHead->destId, pHead->tranId);
   } else {
     if (pHead->code == 0) pConn->secured = 1;  // for success response, set link as secured
-    tDebug("%s, %s is sent to 0x%x:%hu, code:0x%x len:%d sig:0x%08x:0x%08x:%d",
-           pConn->info, TMSG_INFO(pHead->msgType), pConn->peerIp, pConn->peerPort, 
-           htonl(pHead->code), msgLen, pHead->sourceId, pHead->destId, pHead->tranId);
+    tDebug("%s, %s is sent to 0x%x:%hu, code:0x%x len:%d sig:0x%08x:0x%08x:%d", pConn->info, TMSG_INFO(pHead->msgType),
+           pConn->peerIp, pConn->peerPort, htonl(pHead->code), msgLen, pHead->sourceId, pHead->destId, pHead->tranId);
   }
 
-  //tTrace("connection type is: %d", pConn->connType);
+  // tTrace("connection type is: %d", pConn->connType);
   writtenLen = (*taosSendData[pConn->connType])(pConn->peerIp, pConn->peerPort, pHead, msgLen, pConn->chandle);
 
   if (writtenLen != msgLen) {
@@ -1369,7 +1563,7 @@ static void rpcSendMsgToPeer(SRpcConn *pConn, void *msg, int msgLen) {
 
 static void rpcProcessConnError(void *param, void *id) {
   SRpcReqContext *pContext = (SRpcReqContext *)param;
-  SRpcInfo       *pRpc = pContext->pRpc;
+  SRpcInfo *      pRpc = pContext->pRpc;
   SRpcMsg         rpcMsg;
 
   if (pRpc == NULL) {
@@ -1379,7 +1573,7 @@ static void rpcProcessConnError(void *param, void *id) {
   tDebug("%s %p, connection error happens", pRpc->label, pContext->ahandle);
 
   if (pContext->numOfTry >= pContext->epSet.numOfEps || pContext->msgType == TDMT_VND_FETCH) {
-    rpcMsg.msgType = pContext->msgType+1;
+    rpcMsg.msgType = pContext->msgType + 1;
     rpcMsg.ahandle = pContext->ahandle;
     rpcMsg.code = pContext->code;
     rpcMsg.pCont = NULL;
@@ -1411,7 +1605,8 @@ static void rpcProcessRetryTimer(void *param, void *tmrId) {
       pConn->pTimer = taosTmrStart(rpcProcessRetryTimer, tsRpcTimer, pConn, pRpc->tmrCtrl);
     } else {
       // close the connection
-      tDebug("%s, failed to send msg:%s to %s:%hu", pConn->info, TMSG_INFO(pConn->outType), pConn->peerFqdn, pConn->peerPort);
+      tDebug("%s, failed to send msg:%s to %s:%hu", pConn->info, TMSG_INFO(pConn->outType), pConn->peerFqdn,
+             pConn->peerPort);
       if (pConn->pContext) {
         pConn->pContext->code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
         pConn->pContext->pConn = NULL;
@@ -1460,7 +1655,7 @@ static void rpcProcessProgressTimer(void *param, void *tmrId) {
   rpcUnlockConn(pConn);
 }
 
-static int32_t rpcCompressRpcMsg(char* pCont, int32_t contLen) {
+static int32_t rpcCompressRpcMsg(char *pCont, int32_t contLen) {
   SRpcHead *pHead = rpcHeadFromCont(pCont);
   int32_t   finalLen = 0;
   int       overhead = sizeof(SRpcComp);
@@ -1469,7 +1664,7 @@ static int32_t rpcCompressRpcMsg(char* pCont, int32_t contLen) {
     return contLen;
   }
 
-  char *buf = malloc (contLen + overhead + 8);  // 8 extra bytes
+  char *buf = malloc(contLen + overhead + 8);  // 8 extra bytes
   if (buf == NULL) {
     tError("failed to allocate memory for rpc msg compression, contLen:%d", contLen);
     return contLen;
@@ -1502,7 +1697,7 @@ static int32_t rpcCompressRpcMsg(char* pCont, int32_t contLen) {
 static SRpcHead *rpcDecompressRpcMsg(SRpcHead *pHead) {
   int       overhead = sizeof(SRpcComp);
   SRpcHead *pNewHead = NULL;
-  uint8_t    *pCont = pHead->content;
+  uint8_t * pCont = pHead->content;
   SRpcComp *pComp = (SRpcComp *)pHead->content;
 
   if (pHead->comp) {
@@ -1516,7 +1711,7 @@ static SRpcHead *rpcDecompressRpcMsg(SRpcHead *pHead) {
 
     if (pNewHead) {
       int compLen = rpcContLenFromMsg(pHead->msgLen) - overhead;
-      int origLen = LZ4_decompress_safe((char*)(pCont + overhead), (char *)pNewHead->content, compLen, contLen);
+      int origLen = LZ4_decompress_safe((char *)(pCont + overhead), (char *)pNewHead->content, compLen, contLen);
       assert(origLen == contLen);
 
       memcpy(pNewHead, pHead, sizeof(SRpcHead));
@@ -1582,19 +1777,19 @@ static int rpcCheckAuthentication(SRpcConn *pConn, char *msg, int msgLen) {
   SRpcHead *pHead = (SRpcHead *)msg;
   int       code = 0;
 
-  if ((pConn->secured && pHead->spi == 0) || (pHead->spi == 0 && pConn->spi == 0)){
+  if ((pConn->secured && pHead->spi == 0) || (pHead->spi == 0 && pConn->spi == 0)) {
     // secured link, or no authentication
     pHead->msgLen = (int32_t)htonl((uint32_t)pHead->msgLen);
     // tTrace("%s, secured link, no auth is required", pConn->info);
     return 0;
   }
 
-  if ( !rpcIsReq(pHead->msgType) ) {
+  if (!rpcIsReq(pHead->msgType)) {
     // for response, if code is auth failure, it shall bypass the auth process
     code = htonl(pHead->code);
     if (code == TSDB_CODE_RPC_INVALID_TIME_STAMP || code == TSDB_CODE_RPC_AUTH_FAILURE ||
-        code == TSDB_CODE_RPC_INVALID_VERSION ||
-        code == TSDB_CODE_RPC_AUTH_REQUIRED || code == TSDB_CODE_MND_USER_NOT_EXIST || code == TSDB_CODE_RPC_NOT_READY) {
+        code == TSDB_CODE_RPC_INVALID_VERSION || code == TSDB_CODE_RPC_AUTH_REQUIRED ||
+        code == TSDB_CODE_MND_USER_NOT_EXIST || code == TSDB_CODE_RPC_NOT_READY) {
       pHead->msgLen = (int32_t)htonl((uint32_t)pHead->msgLen);
       // tTrace("%s, dont check authentication since code is:0x%x", pConn->info, code);
       return 0;
@@ -1613,12 +1808,12 @@ static int rpcCheckAuthentication(SRpcConn *pConn, char *msg, int msgLen) {
       tWarn("%s, time diff:%d is too big, msg discarded", pConn->info, delta);
       code = TSDB_CODE_RPC_INVALID_TIME_STAMP;
     } else {
-      if (rpcAuthenticateMsg(pHead, msgLen-TSDB_AUTH_LEN, pDigest->auth, pConn->secret) < 0) {
+      if (rpcAuthenticateMsg(pHead, msgLen - TSDB_AUTH_LEN, pDigest->auth, pConn->secret) < 0) {
         tDebug("%s, authentication failed, msg discarded", pConn->info);
         code = TSDB_CODE_RPC_AUTH_FAILURE;
       } else {
         pHead->msgLen = (int32_t)htonl((uint32_t)pHead->msgLen) - sizeof(SRpcDigest);
-        if ( !rpcIsReq(pHead->msgType) ) pConn->secured = 1;  // link is secured for client
+        if (!rpcIsReq(pHead->msgType)) pConn->secured = 1;  // link is secured for client
         // tTrace("%s, message is authenticated", pConn->info);
       }
     }
@@ -1647,13 +1842,9 @@ static void rpcUnlockConn(SRpcConn *pConn) {
   }
 }
 
-static void rpcAddRef(SRpcInfo *pRpc)
-{  
-   atomic_add_fetch_32(&pRpc->refCount, 1);
-}
+static void rpcAddRef(SRpcInfo *pRpc) { atomic_add_fetch_32(&pRpc->refCount, 1); }
 
-static void rpcDecRef(SRpcInfo *pRpc)
-{ 
+static void rpcDecRef(SRpcInfo *pRpc) {
   if (atomic_sub_fetch_32(&pRpc->refCount, 1) == 0) {
     rpcCloseConnCache(pRpc->pCache);
     taosHashCleanup(pRpc->hash);
@@ -1668,4 +1859,4 @@ static void rpcDecRef(SRpcInfo *pRpc)
     atomic_sub_fetch_32(&tsRpcNum, 1);
   }
 }
-
+#endif

source/libs/transport/src/rpcTcp.c

@@ -13,24 +13,30 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "rpcTcp.h"
+#ifdef USE_UV
+#include <uv.h>
+#endif
 #include "os.h"
-#include "tutil.h"
+#include "rpcHead.h"
+#include "rpcLog.h"
 #include "taosdef.h"
 #include "taoserror.h"
-#include "rpcLog.h"
-#include "rpcHead.h"
-#include "rpcTcp.h"
+#include "tutil.h"
 
+#ifdef USE_UV
+
+#else
 typedef struct SFdObj {
-  void              *signature;
+  void *             signature;
   SOCKET             fd;       // TCP socket FD
-  void              *thandle;     // handle from upper layer, like TAOS
+  void *             thandle;  // handle from upper layer, like TAOS
   uint32_t           ip;
   uint16_t           port;
   int16_t            closedByApp;  // 1: already closed by App
   struct SThreadObj *pThreadObj;
-  struct SFdObj     *prev;
-  struct SFdObj     *next;
+  struct SFdObj *    prev;
+  struct SFdObj *    next;
 } SFdObj;
 
 typedef struct SThreadObj {
@@ -43,7 +49,7 @@ typedef struct SThreadObj {
   int             numOfFds;
   int             threadId;
   char            label[TSDB_LABEL_LEN];
-  void           *shandle;  // handle passed by upper layer during server initialization
+  void *          shandle;  // handle passed by upper layer during server initialization
   void *(*processData)(SRecvInfo *pPacket);
 } SThreadObj;
 
@@ -67,11 +73,11 @@ typedef struct {
   pthread_t    thread;
 } SServerObj;
 
-static void   *taosProcessTcpData(void *param);
+static void *  taosProcessTcpData(void *param);
 static SFdObj *taosMallocFdObj(SThreadObj *pThreadObj, SOCKET fd);
 static void    taosFreeFdObj(SFdObj *pFdObj);
 static void    taosReportBrokenLink(SFdObj *pFdObj);
-static void   *taosAcceptTcpConnection(void *arg);
+static void *  taosAcceptTcpConnection(void *arg);
 
 void *taosInitTcpServer(uint32_t ip, uint16_t port, char *label, int numOfThreads, void *fp, void *shandle) {
   SServerObj *pServerObj;
@@ -110,7 +116,7 @@ void *taosInitTcpServer(uint32_t ip, uint16_t port, char *label, int numOfThread
     if (pThreadObj == NULL) {
       tError("TCP:%s no enough memory", label);
       terrno = TAOS_SYSTEM_ERROR(errno);
-      for (int j=0; j<i; ++j) free(pServerObj->pThreadObj[j]);
+      for (int j = 0; j < i; ++j) free(pServerObj->pThreadObj[j]);
       free(pServerObj->pThreadObj);
       free(pServerObj);
       return NULL;
@@ -172,8 +178,10 @@ void *taosInitTcpServer(uint32_t ip, uint16_t port, char *label, int numOfThread
   return (void *)pServerObj;
 }
 
-static void taosStopTcpThread(SThreadObj* pThreadObj) {
-  if (pThreadObj == NULL)  { return;}
+static void taosStopTcpThread(SThreadObj *pThreadObj) {
+  if (pThreadObj == NULL) {
+    return;
+  }
   // save thread into local variable and signal thread to stop
   pthread_t thread = pThreadObj->thread;
   if (!taosCheckPthreadValid(thread)) {
@@ -227,8 +235,8 @@ static void *taosAcceptTcpConnection(void *arg) {
   SOCKET             connFd = -1;
   struct sockaddr_in caddr;
   int                threadId = 0;
-  SThreadObj        *pThreadObj;
-  SServerObj        *pServerObj;
+  SThreadObj *       pThreadObj;
+  SServerObj *       pServerObj;
 
   pServerObj = (SServerObj *)arg;
   tDebug("%s TCP server is ready, ip:0x%x:%hu", pServerObj->label, pServerObj->ip, pServerObj->port);
@@ -253,7 +261,7 @@ static void *taosAcceptTcpConnection(void *arg) {
     }
 
     taosKeepTcpAlive(connFd);
-    struct timeval to={5, 0};
+    struct timeval to = {5, 0};
     int32_t        ret = taosSetSockOpt(connFd, SOL_SOCKET, SO_RCVTIMEO, &to, sizeof(to));
     if (ret != 0) {
       taosCloseSocket(connFd);
@@ -262,7 +270,6 @@ static void *taosAcceptTcpConnection(void *arg) {
       continue;
     }
 
-
     // pick up the thread to handle this connection
     pThreadObj = pServerObj->pThreadObj[threadId];
 
@@ -297,7 +304,7 @@ void *taosInitTcpClient(uint32_t ip, uint16_t port, char *label, int numOfThread
 
   tstrncpy(pClientObj->label, label, sizeof(pClientObj->label));
   pClientObj->numOfThreads = numOfThreads;
-  pClientObj->pThreadObj = (SThreadObj **)calloc(numOfThreads, sizeof(SThreadObj*));
+  pClientObj->pThreadObj = (SThreadObj **)calloc(numOfThreads, sizeof(SThreadObj *));
   if (pClientObj->pThreadObj == NULL) {
     tError("TCP:%s no enough memory", label);
     tfree(pClientObj);
@@ -314,7 +321,7 @@ void *taosInitTcpClient(uint32_t ip, uint16_t port, char *label, int numOfThread
     if (pThreadObj == NULL) {
       tError("TCP:%s no enough memory", label);
       terrno = TAOS_SYSTEM_ERROR(errno);
-      for (int j=0; j<i; ++j) free(pClientObj->pThreadObj[j]);
+      for (int j = 0; j < i; ++j) free(pClientObj->pThreadObj[j]);
       free(pClientObj);
       pthread_attr_destroy(&thattr);
       return NULL;
@@ -364,14 +371,14 @@ void taosStopTcpClient(void *chandle) {
 
   if (pClientObj == NULL) return;
 
-  tDebug ("%s TCP client is stopped", pClientObj->label);
+  tDebug("%s TCP client is stopped", pClientObj->label);
 }
 
 void taosCleanUpTcpClient(void *chandle) {
   SClientObj *pClientObj = chandle;
   if (pClientObj == NULL) return;
   for (int i = 0; i < pClientObj->numOfThreads; ++i) {
-    SThreadObj *pThreadObj= pClientObj->pThreadObj[i];
+    SThreadObj *pThreadObj = pClientObj->pThreadObj[i];
     taosStopTcpThread(pThreadObj);
   }
 
@@ -381,7 +388,7 @@ void taosCleanUpTcpClient(void *chandle) {
 }
 
 void *taosOpenTcpClientConnection(void *shandle, void *thandle, uint32_t ip, uint16_t port) {
-  SClientObj *    pClientObj = shandle;
+  SClientObj *pClientObj = shandle;
   int32_t     index = atomic_load_32(&pClientObj->index) % pClientObj->numOfThreads;
   atomic_store_32(&pClientObj->index, index + 1);
   SThreadObj *pThreadObj = pClientObj->pThreadObj[index];
@@ -396,8 +403,7 @@ void *taosOpenTcpClientConnection(void *shandle, void *thandle, uint32_t ip, uin
   struct sockaddr_in sin;
   uint16_t           localPort = 0;
   unsigned int       addrlen = sizeof(sin);
-  if (getsockname(fd, (struct sockaddr *)&sin, &addrlen) == 0 &&
-      sin.sin_family == AF_INET && addrlen == sizeof(sin)) {
+  if (getsockname(fd, (struct sockaddr *)&sin, &addrlen) == 0 && sin.sin_family == AF_INET && addrlen == sizeof(sin)) {
     localPort = (uint16_t)ntohs(sin.sin_port);
   }
 
@@ -407,8 +413,8 @@ void *taosOpenTcpClientConnection(void *shandle, void *thandle, uint32_t ip, uin
     pFdObj->thandle = thandle;
     pFdObj->port = port;
     pFdObj->ip = ip;
-    tDebug("%s %p TCP connection to 0x%x:%hu is created, localPort:%hu FD:%p numOfFds:%d",
-            pThreadObj->label, thandle, ip, port, localPort, pFdObj, pThreadObj->numOfFds);
+    tDebug("%s %p TCP connection to 0x%x:%hu is created, localPort:%hu FD:%p numOfFds:%d", pThreadObj->label, thandle,
+           ip, port, localPort, pFdObj, pThreadObj->numOfFds);
   } else {
     tError("%s failed to malloc client FdObj(%s)", pThreadObj->label, strerror(errno));
     taosCloseSocket(fd);
@@ -441,7 +447,6 @@ int taosSendTcpData(uint32_t ip, uint16_t port, void *data, int len, void *chand
 }
 
 static void taosReportBrokenLink(SFdObj *pFdObj) {
-
   SThreadObj *pThreadObj = pFdObj->pThreadObj;
 
   // notify the upper layer, so it will clean the associated context
@@ -466,7 +471,7 @@ static void taosReportBrokenLink(SFdObj *pFdObj) {
 static int taosReadTcpData(SFdObj *pFdObj, SRecvInfo *pInfo) {
   SRpcHead rpcHead;
   int32_t  msgLen, leftLen, retLen, headLen;
-  char       *buffer, *msg;
+  char *   buffer, *msg;
 
   SThreadObj *pThreadObj = pFdObj->pThreadObj;
 
@@ -483,7 +488,8 @@ static int taosReadTcpData(SFdObj *pFdObj, SRecvInfo *pInfo) {
     tError("%s %p TCP malloc(size:%d) fail", pThreadObj->label, pFdObj->thandle, msgLen);
     return -1;
   } else {
-    tTrace("%s %p read data, FD:%p fd:%d TCP malloc mem:%p", pThreadObj->label, pFdObj->thandle, pFdObj, pFdObj->fd, buffer);
+    tTrace("%s %p read data, FD:%p fd:%d TCP malloc mem:%p", pThreadObj->label, pFdObj->thandle, pFdObj, pFdObj->fd,
+           buffer);
   }
 
   msg = buffer + tsRpcOverhead;
@@ -491,8 +497,7 @@ static int taosReadTcpData(SFdObj *pFdObj, SRecvInfo *pInfo) {
   retLen = taosReadMsg(pFdObj->fd, msg + headLen, leftLen);
 
   if (leftLen != retLen) {
-    tError("%s %p read error, leftLen:%d retLen:%d FD:%p",
-            pThreadObj->label, pFdObj->thandle, leftLen, retLen, pFdObj);
+    tError("%s %p read error, leftLen:%d retLen:%d FD:%p", pThreadObj->label, pFdObj->thandle, leftLen, retLen, pFdObj);
     free(buffer);
     return -1;
   }
@@ -519,8 +524,8 @@ static int taosReadTcpData(SFdObj *pFdObj, SRecvInfo *pInfo) {
 #define maxEvents 10
 
 static void *taosProcessTcpData(void *param) {
-  SThreadObj        *pThreadObj = param;
-  SFdObj            *pFdObj;
+  SThreadObj *       pThreadObj = param;
+  SFdObj *           pFdObj;
   struct epoll_event events[maxEvents];
   SRecvInfo          recvInfo;
 
@@ -569,7 +574,7 @@ static void *taosProcessTcpData(void *param) {
     if (pThreadObj->stop) break;
   }
 
-  if (pThreadObj->pollFd >=0) {
+  if (pThreadObj->pollFd >= 0) {
     EpollClose(pThreadObj->pollFd);
     pThreadObj->pollFd = -1;
   }
@@ -620,7 +625,6 @@ static SFdObj *taosMallocFdObj(SThreadObj *pThreadObj, SOCKET fd) {
 }
 
 static void taosFreeFdObj(SFdObj *pFdObj) {
-
   if (pFdObj == NULL) return;
   if (pFdObj->signature != pFdObj) return;
 
@@ -638,8 +642,8 @@ static void taosFreeFdObj(SFdObj *pFdObj) {
 
   pThreadObj->numOfFds--;
   if (pThreadObj->numOfFds < 0)
-    tError("%s %p TCP thread:%d, number of FDs is negative!!!",
-            pThreadObj->label, pFdObj->thandle, pThreadObj->threadId);
+    tError("%s %p TCP thread:%d, number of FDs is negative!!!", pThreadObj->label, pFdObj->thandle,
+           pThreadObj->threadId);
 
   if (pFdObj->prev) {
     (pFdObj->prev)->next = pFdObj->next;
@@ -653,8 +657,10 @@ static void taosFreeFdObj(SFdObj *pFdObj) {
 
   pthread_mutex_unlock(&pThreadObj->mutex);
 
-  tDebug("%s %p TCP connection is closed, FD:%p fd:%d numOfFds:%d",
-          pThreadObj->label, pFdObj->thandle, pFdObj, pFdObj->fd, pThreadObj->numOfFds);
+  tDebug("%s %p TCP connection is closed, FD:%p fd:%d numOfFds:%d", pThreadObj->label, pFdObj->thandle, pFdObj,
+         pFdObj->fd, pThreadObj->numOfFds);
 
   tfree(pFdObj);
 }
+
+#endif

source/libs/transport/src/rpcUdp.c

@@ -13,15 +13,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "rpcUdp.h"
 #include "os.h"
-#include "ttimer.h"
-#include "tutil.h"
+#include "rpcHead.h"
+#include "rpcLog.h"
 #include "taosdef.h"
 #include "taoserror.h"
-#include "rpcLog.h"
-#include "rpcUdp.h"
-#include "rpcHead.h"
+#include "ttimer.h"
+#include "tutil.h"
 
+#ifdef USE_UV
+// no support upd currently
+#else
 #define RPC_MAX_UDP_CONNS 256
 #define RPC_MAX_UDP_PKTS 1000
 #define RPC_UDP_BUF_TIME 5  // mseconds
@@ -34,9 +37,9 @@ typedef struct {
   uint16_t  localPort;              // local port
   char      label[TSDB_LABEL_LEN];  // copy from udpConnSet;
   pthread_t thread;
-  void           *hash;
-  void           *shandle;  // handle passed by upper layer during server initialization
-  void           *pSet;
+  void *    hash;
+  void *    shandle;  // handle passed by upper layer during server initialization
+  void *    pSet;
   void *(*processData)(SRecvInfo *pRecv);
   char *buffer;  // buffer to receive data
 } SUdpConn;
@@ -46,7 +49,7 @@ typedef struct {
   int      server;
   uint32_t ip;       // local IP
   uint16_t port;     // local Port
-  void     *shandle;  // handle passed by upper layer during server initialization
+  void *   shandle;  // handle passed by upper layer during server initialization
   int      threads;
   char     label[TSDB_LABEL_LEN];
   void *(*fp)(SRecvInfo *pPacket);
@@ -56,7 +59,7 @@ typedef struct {
 static void *taosRecvUdpData(void *param);
 
 void *taosInitUdpConnection(uint32_t ip, uint16_t port, char *label, int threads, void *fp, void *shandle) {
-  SUdpConn    *pConn;
+  SUdpConn *   pConn;
   SUdpConnSet *pSet;
 
   int size = (int)sizeof(SUdpConnSet) + threads * (int)sizeof(SUdpConn);
@@ -98,8 +101,8 @@ void *taosInitUdpConnection(uint32_t ip, uint16_t port, char *label, int threads
 
     struct sockaddr_in sin;
     unsigned int       addrlen = sizeof(sin);
-    if (getsockname(pConn->fd, (struct sockaddr *)&sin, &addrlen) == 0 && 
-        sin.sin_family == AF_INET && addrlen == sizeof(sin)) {
+    if (getsockname(pConn->fd, (struct sockaddr *)&sin, &addrlen) == 0 && sin.sin_family == AF_INET &&
+        addrlen == sizeof(sin)) {
       pConn->localPort = (uint16_t)ntohs(sin.sin_port);
     }
 
@@ -130,14 +133,14 @@ void *taosInitUdpConnection(uint32_t ip, uint16_t port, char *label, int threads
 
 void taosStopUdpConnection(void *handle) {
   SUdpConnSet *pSet = (SUdpConnSet *)handle;
-  SUdpConn    *pConn;
+  SUdpConn *   pConn;
 
   if (pSet == NULL) return;
 
   for (int i = 0; i < pSet->threads; ++i) {
     pConn = pSet->udpConn + i;
-    if (pConn->fd >=0) shutdown(pConn->fd, SHUT_RDWR);
-    if (pConn->fd >=0) taosCloseSocket(pConn->fd);
+    if (pConn->fd >= 0) shutdown(pConn->fd, SHUT_RDWR);
+    if (pConn->fd >= 0) taosCloseSocket(pConn->fd);
     pConn->fd = -1;
   }
 
@@ -155,13 +158,13 @@ void taosStopUdpConnection(void *handle) {
 
 void taosCleanUpUdpConnection(void *handle) {
   SUdpConnSet *pSet = (SUdpConnSet *)handle;
-  SUdpConn    *pConn;
+  SUdpConn *   pConn;
 
   if (pSet == NULL) return;
 
   for (int i = 0; i < pSet->threads; ++i) {
     pConn = pSet->udpConn + i;
-    if (pConn->fd >=0) taosCloseSocket(pConn->fd);
+    if (pConn->fd >= 0) taosCloseSocket(pConn->fd);
   }
 
   tDebug("%s UDP is cleaned up", pSet->label);
@@ -182,7 +185,7 @@ void *taosOpenUdpConnection(void *shandle, void *thandle, uint32_t ip, uint16_t
 }
 
 static void *taosRecvUdpData(void *param) {
-  SUdpConn          *pConn = param;
+  SUdpConn *         pConn = param;
   struct sockaddr_in sourceAdd;
   ssize_t            dataLen;
   unsigned int       addLen;
@@ -218,7 +221,7 @@ static void *taosRecvUdpData(void *param) {
     }
 
     int32_t size = dataLen + tsRpcOverhead;
-    char *tmsg = malloc(size);
+    char *  tmsg = malloc(size);
     if (NULL == tmsg) {
       tError("%s failed to allocate memory, size:%" PRId64, pConn->label, (int64_t)dataLen);
       continue;
@@ -257,4 +260,4 @@ int taosSendUdpData(uint32_t ip, uint16_t port, void *data, int dataLen, void *c
 
   return ret;
 }
-
+#endif

source/util/src/terror.c

@@ -80,6 +80,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_CHECKSUM_ERROR,               "Checksum error")
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG,                  "Invalid config message")
 TAOS_DEFINE_ERROR(TSDB_CODE_MSG_NOT_PROCESSED,            "Message not processed")
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_PARA,                 "Invalid parameters")
+TAOS_DEFINE_ERROR(TSDB_CODE_REPEAT_INIT,                  "Repeat initialization")
+
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_NO_MEMORY,                "Ref out of memory")
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_FULL,                     "too many Ref Objs")
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_ID_REMOVED,               "Ref ID is removed")

src/inc/tfs.h

@@ -49,7 +49,7 @@ typedef struct {
 } STierMeta;
 
 int  tfsInit(SDiskCfg *pDiskCfg, int ndisk);
-void tfsDestroy();
+void tfsCleanup();
 void tfsUpdateInfo(SFSMeta *pFSMeta, STierMeta *tierMetas, int8_t numLevels);
 void tfsGetMeta(SFSMeta *pMeta);
 void tfsAllocDisk(int expLevel, int *level, int *id);

tests/test/c/create_table.c

@@ -30,6 +30,7 @@ int32_t createTable = 1;
 int32_t insertData = 0;
 int32_t batchNum = 100;
 int32_t numOfVgroups = 2;
+int32_t showTablesFlag = 0;
 
 typedef struct {
   int64_t   tableBeginIndex;
@@ -45,88 +46,9 @@ typedef struct {
   pthread_t thread;
 } SThreadInfo;
 
-void  parseArgument(int32_t argc, char *argv[]);
-void *threadFunc(void *param);
-void  createDbAndStb();
-
-int32_t main(int32_t argc, char *argv[]) {
-  parseArgument(argc, argv);
-  createDbAndStb();
-
-  pPrint("%d threads are spawned to create %d tables", numOfThreads, numOfThreads);
-
-  pthread_attr_t thattr;
-  pthread_attr_init(&thattr);
-  pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE);
-  SThreadInfo *pInfo = (SThreadInfo *)calloc(numOfThreads, sizeof(SThreadInfo));
-
-  //int64_t numOfTablesPerThread = numOfTables / numOfThreads;
-  //numOfTables = numOfTablesPerThread * numOfThreads;
-
-
-  if (numOfThreads < 1) {
-    numOfThreads = 1;
-  }
-  
-  int64_t a = numOfTables / numOfThreads;
-  if (a < 1) {
-  	  numOfThreads = numOfTables;
-  	  a = 1;
-  }
-  
-  int64_t b = 0;
-  b = numOfTables % numOfThreads;
-
-  int64_t tableFrom = 0;
-  for (int32_t i = 0; i < numOfThreads; ++i) {
-    pInfo[i].tableBeginIndex = tableFrom;
-    pInfo[i].tableEndIndex = i < b ? tableFrom + a : tableFrom + a - 1;
-    tableFrom = pInfo[i].tableEndIndex + 1;
-    pInfo[i].threadIndex = i;
-	pInfo[i].minDelay = INT64_MAX;
-    strcpy(pInfo[i].dbName, dbName);
-    strcpy(pInfo[i].stbName, stbName);
-    pthread_create(&(pInfo[i].thread), &thattr, threadFunc, (void *)(pInfo + i));
-  }
-
-  taosMsleep(300);
-  for (int32_t i = 0; i < numOfThreads; i++) {
-    pthread_join(pInfo[i].thread, NULL);
-  }
-
-  int64_t maxDelay = 0;
-  int64_t minDelay = INT64_MAX;
-
-  float createTableSpeed = 0;
-  for (int32_t i = 0; i < numOfThreads; ++i) {
-    createTableSpeed += pInfo[i].createTableSpeed;
-
-    if (pInfo[i].maxDelay > maxDelay) maxDelay = pInfo[i].maxDelay;
-    if (pInfo[i].minDelay < minDelay) minDelay = pInfo[i].minDelay;  
-  }
-
-  float insertDataSpeed = 0;
-  for (int32_t i = 0; i < numOfThreads; ++i) {
-    insertDataSpeed += pInfo[i].insertDataSpeed;
-  }
-
-  pPrint("%s total %" PRId64 " tables, %.1f tables/second, threads:%d, maxDelay: %" PRId64 "us, minDelay: %" PRId64 "us %s", 
-           GREEN, 
-           numOfTables, 
-           createTableSpeed, 
-           numOfThreads, 
-           maxDelay, 
-           minDelay,
-           NC);
-
-  if (insertData) {
-      pPrint("%s total %" PRId64 " tables, %.1f rows/second, threads:%d %s", GREEN, numOfTables, insertDataSpeed,
-         numOfThreads, NC);
-  }
-
-  pthread_attr_destroy(&thattr);
-  free(pInfo);
-}
+//void  parseArgument(int32_t argc, char *argv[]);
+//void *threadFunc(void *param);
+//void  createDbAndStb();
 
 void createDbAndStb() {
   pPrint("start to create db and stable");
@@ -188,6 +110,62 @@ void printInsertProgress(SThreadInfo *pInfo, int64_t t) {
          totalTables, seconds, speed);
 }
 
+static int64_t getResult(TAOS_RES *tres) {
+  TAOS_ROW row = taos_fetch_row(tres);
+  if (row == NULL) {
+    return 0;
+  }
+
+  int         num_fields = taos_num_fields(tres);
+  TAOS_FIELD *fields = taos_fetch_fields(tres);
+  int         precision = taos_result_precision(tres);
+
+  int64_t numOfRows = 0;
+  do {
+    numOfRows++;
+    row = taos_fetch_row(tres);
+  } while (row != NULL);
+
+  return numOfRows;
+}
+
+
+void showTables() {  
+  pPrint("start to show tables");
+  char qstr[32];
+
+  TAOS *con = taos_connect(NULL, "root", "taosdata", NULL, 0);
+  if (con == NULL) {
+    pError("failed to connect to DB, reason:%s", taos_errstr(NULL));
+    exit(1);
+  }
+
+  sprintf(qstr, "use %s", dbName);
+  TAOS_RES *pRes = taos_query(con, qstr);
+  int code = taos_errno(pRes);
+  if (code != 0) {
+    pError("failed to use db, code:%d reason:%s", taos_errno(pRes), taos_errstr(pRes));
+    exit(1);
+  }
+  taos_free_result(pRes);
+
+  sprintf(qstr, "show tables");
+  pRes = taos_query(con, qstr);
+  code = taos_errno(pRes);
+  if (code != 0) {
+    pError("failed to show tables, code:%d reason:%s", taos_errno(pRes), taos_errstr(pRes));
+    exit(0);
+  }
+
+  int64_t totalTableNum = getResult(pRes);
+  taos_free_result(pRes);
+
+  pPrint("%s database: %s, total %" PRId64 " tables %s", GREEN, dbName, totalTableNum, NC);  
+
+  taos_close(con);
+}
+
+
 void *threadFunc(void *param) {
   SThreadInfo *pInfo = (SThreadInfo *)param;
   char        *qstr = malloc(2000 * 1000);
@@ -298,6 +276,8 @@ void printHelp() {
   printf("%s%s%s%d\n", indent, indent, "insertData, default is ", insertData);
   printf("%s%s\n", indent, "-b");
   printf("%s%s%s%d\n", indent, indent, "batchNum, default is ", batchNum);
+  printf("%s%s\n", indent, "-w");
+  printf("%s%s%s%d\n", indent, indent, "showTablesFlag, default is ", showTablesFlag);
 
   exit(EXIT_SUCCESS);
 }
@@ -325,6 +305,8 @@ void parseArgument(int32_t argc, char *argv[]) {
       insertData = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-b") == 0) {
       batchNum = atoi(argv[++i]);
+    } else if (strcmp(argv[i], "-w") == 0) {
+      showTablesFlag = atoi(argv[++i]);
     } else {
     }
   }
@@ -338,6 +320,93 @@ void parseArgument(int32_t argc, char *argv[]) {
   pPrint("%s createTable:%d %s", GREEN, createTable, NC);
   pPrint("%s insertData:%d %s", GREEN, insertData, NC);
   pPrint("%s batchNum:%d %s", GREEN, batchNum, NC);
+  pPrint("%s showTablesFlag:%d %s", GREEN, showTablesFlag, NC);
 
   pPrint("%s start create table performace test %s", GREEN, NC);
 }
+
+int32_t main(int32_t argc, char *argv[]) {
+  parseArgument(argc, argv);
+
+  if (showTablesFlag) {
+      showTables();
+	  return 0;
+  }
+  
+  createDbAndStb();
+
+  pPrint("%d threads are spawned to create %d tables", numOfThreads, numOfThreads);
+
+  pthread_attr_t thattr;
+  pthread_attr_init(&thattr);
+  pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE);
+  SThreadInfo *pInfo = (SThreadInfo *)calloc(numOfThreads, sizeof(SThreadInfo));
+
+  //int64_t numOfTablesPerThread = numOfTables / numOfThreads;
+  //numOfTables = numOfTablesPerThread * numOfThreads;
+
+
+  if (numOfThreads < 1) {
+    numOfThreads = 1;
+  }
+  
+  int64_t a = numOfTables / numOfThreads;
+  if (a < 1) {
+  	  numOfThreads = numOfTables;
+  	  a = 1;
+  }
+  
+  int64_t b = 0;
+  b = numOfTables % numOfThreads;
+
+  int64_t tableFrom = 0;
+  for (int32_t i = 0; i < numOfThreads; ++i) {
+    pInfo[i].tableBeginIndex = tableFrom;
+    pInfo[i].tableEndIndex = i < b ? tableFrom + a : tableFrom + a - 1;
+    tableFrom = pInfo[i].tableEndIndex + 1;
+    pInfo[i].threadIndex = i;
+	pInfo[i].minDelay = INT64_MAX;
+    strcpy(pInfo[i].dbName, dbName);
+    strcpy(pInfo[i].stbName, stbName);
+    pthread_create(&(pInfo[i].thread), &thattr, threadFunc, (void *)(pInfo + i));
+  }
+
+  taosMsleep(300);
+  for (int32_t i = 0; i < numOfThreads; i++) {
+    pthread_join(pInfo[i].thread, NULL);
+  }
+
+  int64_t maxDelay = 0;
+  int64_t minDelay = INT64_MAX;
+
+  float createTableSpeed = 0;
+  for (int32_t i = 0; i < numOfThreads; ++i) {
+    createTableSpeed += pInfo[i].createTableSpeed;
+
+    if (pInfo[i].maxDelay > maxDelay) maxDelay = pInfo[i].maxDelay;
+    if (pInfo[i].minDelay < minDelay) minDelay = pInfo[i].minDelay;  
+  }
+
+  float insertDataSpeed = 0;
+  for (int32_t i = 0; i < numOfThreads; ++i) {
+    insertDataSpeed += pInfo[i].insertDataSpeed;
+  }
+
+  pPrint("%s total %" PRId64 " tables, %.1f tables/second, threads:%d, maxDelay: %" PRId64 "us, minDelay: %" PRId64 "us %s", 
+           GREEN, 
+           numOfTables, 
+           createTableSpeed, 
+           numOfThreads, 
+           maxDelay, 
+           minDelay,
+           NC);
+
+  if (insertData) {
+      pPrint("%s total %" PRId64 " tables, %.1f rows/second, threads:%d %s", GREEN, numOfTables, insertDataSpeed,
+         numOfThreads, NC);
+  }
+
+  pthread_attr_destroy(&thattr);
+  free(pInfo);
+}
+