[td-11818] merge 3.0

include/client/taos.h

@@ -193,6 +193,9 @@ DLL_EXPORT void taos_close_stream(TAOS_STREAM *tstr);
 DLL_EXPORT int taos_load_table_info(TAOS *taos, const char* tableNameList);
 DLL_EXPORT TAOS_RES* taos_schemaless_insert(TAOS* taos, char* lines[], int numLines, int protocol, int precision);
 
+
+DLL_EXPORT TAOS_RES *tmq_create_topic(TAOS* taos, const char* name, const char* sql, int sqlLen);
+
 #ifdef __cplusplus
 }
 #endif

include/common/tmsg.h

@@ -826,7 +826,7 @@ typedef struct SShowRsp {
 } SShowRsp;
 
 typedef struct {
-  char    ep[TSDB_FQDN_LEN];  // end point, hostname:port
+  char    fqdn[TSDB_FQDN_LEN];  // end point, hostname:port
   int32_t port;
 } SCreateDnodeMsg;
 
@@ -853,6 +853,18 @@ typedef struct {
   int32_t dnodeId;
 } SDropMnodeInMsg;
 
+typedef struct {
+  int32_t dnodeId;
+} SCreateQnodeInMsg, SDropQnodeInMsg;
+
+typedef struct {
+  int32_t dnodeId;
+} SCreateSnodeInMsg, SDropSnodeInMsg;
+
+typedef struct {
+  int32_t dnodeId;
+} SCreateBnodeInMsg, SDropBnodeInMsg;
+
 typedef struct {
   int32_t dnodeId;
   int32_t vgId;
@@ -1006,7 +1018,7 @@ typedef struct {
 } SUpdateTagValRsp;
 
 typedef struct SSubQueryMsg {
-  uint64_t schedulerId;
+  uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
   uint32_t contentLen;
@@ -1014,7 +1026,7 @@ typedef struct SSubQueryMsg {
 } SSubQueryMsg;
 
 typedef struct SResReadyMsg {
-  uint64_t schedulerId;
+  uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
 } SResReadyMsg;
@@ -1024,13 +1036,13 @@ typedef struct SResReadyRsp {
 } SResReadyRsp;
 
 typedef struct SResFetchMsg {
-  uint64_t schedulerId;
+  uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
 } SResFetchMsg;
 
 typedef struct SSchTasksStatusMsg {
-  uint64_t schedulerId;
+  uint64_t sId;
 } SSchTasksStatusMsg;
 
 typedef struct STaskStatus {
@@ -1045,7 +1057,7 @@ typedef struct SSchedulerStatusRsp {
 } SSchedulerStatusRsp;
 
 typedef struct STaskCancelMsg {
-  uint64_t schedulerId;
+  uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
 } STaskCancelMsg;
@@ -1055,7 +1067,7 @@ typedef struct STaskCancelRsp {
 } STaskCancelRsp;
 
 typedef struct STaskDropMsg {
-  uint64_t schedulerId;
+  uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
 } STaskDropMsg;
@@ -1064,6 +1076,27 @@ typedef struct STaskDropRsp {
   int32_t code;
 } STaskDropRsp;
 
+typedef struct {
+  int8_t  igExists;
+  char*   name;
+  char*   phyPlan;
+} SCMCreateTopicReq;
+
+static FORCE_INLINE int tSerializeSCMCreateTopicReq(void** buf, const SCMCreateTopicReq* pReq) {
+  int tlen = 0;
+  tlen += taosEncodeString(buf, pReq->name);
+  tlen += taosEncodeFixedI8(buf, pReq->igExists);
+  tlen += taosEncodeString(buf, pReq->phyPlan);
+  return tlen;
+}
+
+static FORCE_INLINE void* tDeserializeSCMCreateTopicReq(void* buf, SCMCreateTopicReq* pReq) {
+  buf = taosDecodeFixedI8(buf, &(pReq->igExists));
+  buf = taosDecodeString(buf, &(pReq->name));
+  buf = taosDecodeString(buf, &(pReq->phyPlan));
+  return buf;
+}
+
 typedef struct {
   char    name[TSDB_TOPIC_FNAME_LEN];
   int8_t  igExists;

include/dnode/bnode/bnode.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_BNODE_H_
+#define _TD_BNODE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ------------------------ TYPES EXPOSED ------------------------ */
+typedef struct SDnode SDnode;
+typedef struct SBnode SBnode;
+typedef void (*SendMsgToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
+typedef void (*SendMsgToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef void (*SendRedirectMsgFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+
+typedef struct {
+  int64_t numOfErrors;
+} SBnodeLoad;
+
+typedef struct {
+  int32_t sver;
+} SBnodeCfg;
+
+typedef struct {
+  int32_t           dnodeId;
+  int64_t           clusterId;
+  SBnodeCfg         cfg;
+  SDnode           *pDnode;
+  SendMsgToDnodeFp  sendMsgToDnodeFp;
+  SendMsgToMnodeFp  sendMsgToMnodeFp;
+  SendRedirectMsgFp sendRedirectMsgFp;
+} SBnodeOpt;
+
+/* ------------------------ SBnode ------------------------ */
+/**
+ * @brief Start one Bnode in Dnode.
+ *
+ * @param path Path of the bnode.
+ * @param pOption Option of the bnode.
+ * @return SBnode* The bnode object.
+ */
+SBnode *bndOpen(const char *path, const SBnodeOpt *pOption);
+
+/**
+ * @brief Stop Bnode in Dnode.
+ *
+ * @param pBnode The bnode object to close.
+ */
+void bndClose(SBnode *pBnode);
+
+/**
+ * @brief Get the statistical information of Bnode
+ *
+ * @param pBnode The bnode object.
+ * @param pLoad Statistics of the bnode.
+ * @return int32_t 0 for success, -1 for failure.
+ */
+int32_t bndGetLoad(SBnode *pBnode, SBnodeLoad *pLoad);
+
+/**
+ * @brief Process a query message.
+ *
+ * @param pBnode The bnode object.
+ * @param pMsgs The array of SRpcMsg
+ * @return int32_t 0 for success, -1 for failure
+ */
+int32_t bndProcessWMsgs(SBnode *pBnode, SArray *pMsgs);
+
+/**
+ * @brief Drop a bnode.
+ *
+ * @param path Path of the bnode.
+ */
+void bndDestroy(const char *path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_BNODE_H_*/
\ No newline at end of file

include/dnode/mgmt/dnode.h

@@ -29,6 +29,7 @@ typedef struct {
   int32_t  sver;
   int16_t  numOfCores;
   int16_t  numOfSupportVnodes;
+  int16_t  numOfCommitThreads;
   int8_t   enableTelem;
   int32_t  statusInterval;
   float    numOfThreadsPerCore;

include/dnode/mnode/mnode.h

@@ -147,28 +147,12 @@ void mndCleanupMsg(SMnodeMsg *pMsg);
 void mndSendRsp(SMnodeMsg *pMsg, int32_t code);
 
 /**
- * @brief Process the read request.
+ * @brief Process the read, write, sync request.
  *
  * @param pMsg The request msg.
  * @return int32_t 0 for success, -1 for failure.
  */
-void mndProcessReadMsg(SMnodeMsg *pMsg);
-
-/**
- * @brief Process the write request.
- *
- * @param pMsg The request msg.
- * @return int32_t 0 for success, -1 for failure.
- */
-void mndProcessWriteMsg(SMnodeMsg *pMsg);
-
-/**
- * @brief Process the sync request.
- *
- * @param pMsg The request msg.
- * @return int32_t 0 for success, -1 for failure.
- */
-void mndProcessSyncMsg(SMnodeMsg *pMsg);
+void mndProcessMsg(SMnodeMsg *pMsg);
 
 #ifdef __cplusplus
 }

include/dnode/qnode/qnode.h

@@ -19,52 +19,73 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "trpc.h"
+
+/* ------------------------ TYPES EXPOSED ------------------------ */
+typedef struct SDnode SDnode;
+typedef struct SQnode SQnode;
+typedef void (*SendMsgToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
+typedef void (*SendMsgToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef void (*SendRedirectMsgFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+
+typedef struct {
+  int64_t numOfStartTask;
+  int64_t numOfStopTask;
+  int64_t numOfRecvedFetch;
+  int64_t numOfSentHb;
+  int64_t numOfSentFetch;
+  int64_t numOfTaskInQueue;
+  int64_t numOfFetchInQueue;
+  int64_t numOfErrors;
+} SQnodeLoad;
 
 typedef struct {
-  uint64_t numOfStartTask;
-  uint64_t numOfStopTask;
-  uint64_t numOfRecvedFetch;
-  uint64_t numOfSentHb;
-  uint64_t numOfSentFetch;
-  uint64_t numOfTaskInQueue;
-  uint64_t numOfFetchInQueue;
-  uint64_t numOfErrors;
-} SQnodeStat;
+  int32_t sver;
+} SQnodeCfg;
 
+typedef struct {
+  int32_t           dnodeId;
+  int64_t           clusterId;
+  SQnodeCfg         cfg;
+  SDnode           *pDnode;
+  SendMsgToDnodeFp  sendMsgToDnodeFp;
+  SendMsgToMnodeFp  sendMsgToMnodeFp;
+  SendRedirectMsgFp sendRedirectMsgFp;
+} SQnodeOpt;
 
+/* ------------------------ SQnode ------------------------ */
 /**
- * Start one Qnode in Dnode.
- * @return Error Code.
+ * @brief Start one Qnode in Dnode.
+ *
+ * @param pOption Option of the qnode.
+ * @return SQnode* The qnode object.
  */
-int32_t qnodeStart();
+SQnode *qndOpen(const SQnodeOpt *pOption);
 
 /**
- * Stop Qnode in Dnode.
+ * @brief Stop Qnode in Dnode.
  *
- * @param qnodeId Qnode ID to stop, -1 for all Qnodes.
+ * @param pQnode The qnode object to close.
  */
-void qnodeStop(int64_t qnodeId);
+void qndClose(SQnode *pQnode);
 
- 
 /**
- * Get the statistical information of Qnode
+ * @brief Get the statistical information of Qnode
  *
- * @param qnodeId Qnode ID to get statistics, -1 for all 
- * @param stat Statistical information.
- * @return Error Code.
+ * @param pQnode The qnode object.
+ * @param pLoad Statistics of the qnode.
+ * @return int32_t 0 for success, -1 for failure.
  */
-int32_t qnodeGetStatistics(int64_t qnodeId, SQnodeStat *stat);
+int32_t qndGetLoad(SQnode *pQnode, SQnodeLoad *pLoad);
 
 /**
- * Interface for processing Qnode messages.
- * 
- * @param pMsg Message to be processed.
- * @return Error code
+ * @brief Process a query or fetch message.
+ *
+ * @param pQnode The qnode object.
+ * @param pMsg The request message
+ * @param pRsp The response message
+ * @return int32_t 0 for success, -1 for failure
  */
-void qnodeProcessReq(SRpcMsg *pMsg);
-
-
+int32_t qndProcessMsg(SQnode *pQnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
 
 #ifdef __cplusplus
 }

include/dnode/snode/snode.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_SNODE_H_
+#define _TD_SNODE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ------------------------ TYPES EXPOSED ------------------------ */
+typedef struct SDnode SDnode;
+typedef struct SSnode SSnode;
+typedef void (*SendMsgToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
+typedef void (*SendMsgToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef void (*SendRedirectMsgFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+
+typedef struct {
+  int64_t numOfErrors;
+} SSnodeLoad;
+
+typedef struct {
+  int32_t sver;
+} SSnodeCfg;
+
+typedef struct {
+  int32_t           dnodeId;
+  int64_t           clusterId;
+  SSnodeCfg         cfg;
+  SDnode           *pDnode;
+  SendMsgToDnodeFp  sendMsgToDnodeFp;
+  SendMsgToMnodeFp  sendMsgToMnodeFp;
+  SendRedirectMsgFp sendRedirectMsgFp;
+} SSnodeOpt;
+
+/* ------------------------ SSnode ------------------------ */
+/**
+ * @brief Start one Snode in Dnode.
+ *
+ * @param path Path of the snode.
+ * @param pOption Option of the snode.
+ * @return SSnode* The snode object.
+ */
+SSnode *sndOpen(const char *path, const SSnodeOpt *pOption);
+
+/**
+ * @brief Stop Snode in Dnode.
+ *
+ * @param pSnode The snode object to close.
+ */
+void sndClose(SSnode *pSnode);
+
+/**
+ * @brief Get the statistical information of Snode
+ *
+ * @param pSnode The snode object.
+ * @param pLoad Statistics of the snode.
+ * @return int32_t 0 for success, -1 for failure.
+ */
+int32_t sndGetLoad(SSnode *pSnode, SSnodeLoad *pLoad);
+
+/**
+ * @brief Process a query message.
+ *
+ * @param pSnode The snode object.
+ * @param pMsg The request message
+ * @param pRsp The response message
+ * @return int32_t 0 for success, -1 for failure
+ */
+int32_t sndProcessMsg(SSnode *pSnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
+
+/**
+ * @brief Drop a snode.
+ *
+ * @param path Path of the snode.
+ */
+void sndDestroy(const char *path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_SNODE_H_*/
\ No newline at end of file

include/dnode/vnode/tq/tq.h

@@ -251,6 +251,8 @@ typedef struct STqMetaStore {
   STqMetaList* bucket[TQ_BUCKET_SIZE];
   // a table head
   STqMetaList* unpersistHead;
+  // topics that are not connectted
+  STqMetaList*   unconnectTopic;
 
   // TODO:temporaral use, to be replaced by unified tfile
   int fileFd;

include/libs/parser/parser.h

@@ -43,7 +43,7 @@ int32_t qParseQuerySql(SParseContext* pContext, SQueryNode** pQuery);
 
 bool qIsDdlQuery(const SQueryNode* pQuery);
 
-void qDestoryQuery(SQueryNode* pQuery);
+void qDestroyQuery(SQueryNode* pQuery);
 
 /**
  * Convert a normal sql statement to only query tags information to enable that the subscribe client can be aware quickly of the true vgroup ids that
@@ -83,4 +83,4 @@ void addIntoSourceParam(SSourceParam* pSourceParam, tExprNode* pNode, SColumn* p
 }
 #endif
 
-#endif /*_TD_PARSER_H_*/
+#endif /*_TD_PARSER_H_*/
\ No newline at end of file

include/libs/planner/planner.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 #include "tmsg.h"
+#include "tarray.h"
 
 #define QUERY_TYPE_MERGE       1
 #define QUERY_TYPE_PARTIAL     2
@@ -131,7 +132,7 @@ typedef struct SSubplan {
 typedef struct SQueryDag {
   uint64_t queryId;
   int32_t  numOfSubplans;
-  SArray  *pSubplans; // Element is SArray*, and nested element is SSubplan. The execution level of subplan, starting from 0.
+  SArray  *pSubplans; // SArray*<SArray*<SSubplan*>>. The execution level of subplan, starting from 0.
 } SQueryDag;
 
 struct SQueryNode;
@@ -165,8 +166,11 @@ void qDestroySubplan(SSubplan* pSubplan);
  */
 void qDestroyQueryDag(SQueryDag* pDag);
 
+char* qDagToString(const SQueryDag* pDag);
+SQueryDag* qStringToDag(const char* pStr);
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_PLANNER_H_*/
+#endif /*_TD_PLANNER_H_*/
\ No newline at end of file

include/util/taoserror.h

@@ -69,6 +69,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_CHECKSUM_ERROR                TAOS_DEF_ERROR_CODE(0, 0x0107)
 #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_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)
@@ -256,9 +257,27 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_DND_MNODE_ID_NOT_FOUND        TAOS_DEF_ERROR_CODE(0, 0x0423)
 #define TSDB_CODE_DND_MNODE_READ_FILE_ERROR     TAOS_DEF_ERROR_CODE(0, 0x0424)
 #define TSDB_CODE_DND_MNODE_WRITE_FILE_ERROR    TAOS_DEF_ERROR_CODE(0, 0x0425)
-#define TSDB_CODE_DND_VNODE_TOO_MANY_VNODES     TAOS_DEF_ERROR_CODE(0, 0x0430)
-#define TSDB_CODE_DND_VNODE_READ_FILE_ERROR     TAOS_DEF_ERROR_CODE(0, 0x0431)
-#define TSDB_CODE_DND_VNODE_WRITE_FILE_ERROR    TAOS_DEF_ERROR_CODE(0, 0x0432)
+#define TSDB_CODE_DND_QNODE_ALREADY_DEPLOYED    TAOS_DEF_ERROR_CODE(0, 0x0430)
+#define TSDB_CODE_DND_QNODE_NOT_DEPLOYED        TAOS_DEF_ERROR_CODE(0, 0x0431)
+#define TSDB_CODE_DND_QNODE_ID_INVALID          TAOS_DEF_ERROR_CODE(0, 0x0432)
+#define TSDB_CODE_DND_QNODE_ID_NOT_FOUND        TAOS_DEF_ERROR_CODE(0, 0x0433)
+#define TSDB_CODE_DND_QNODE_READ_FILE_ERROR     TAOS_DEF_ERROR_CODE(0, 0x0434)
+#define TSDB_CODE_DND_QNODE_WRITE_FILE_ERROR    TAOS_DEF_ERROR_CODE(0, 0x0435)
+#define TSDB_CODE_DND_SNODE_ALREADY_DEPLOYED    TAOS_DEF_ERROR_CODE(0, 0x0440)
+#define TSDB_CODE_DND_SNODE_NOT_DEPLOYED        TAOS_DEF_ERROR_CODE(0, 0x0441)
+#define TSDB_CODE_DND_SNODE_ID_INVALID          TAOS_DEF_ERROR_CODE(0, 0x0442)
+#define TSDB_CODE_DND_SNODE_ID_NOT_FOUND        TAOS_DEF_ERROR_CODE(0, 0x0443)
+#define TSDB_CODE_DND_SNODE_READ_FILE_ERROR     TAOS_DEF_ERROR_CODE(0, 0x0444)
+#define TSDB_CODE_DND_SNODE_WRITE_FILE_ERROR    TAOS_DEF_ERROR_CODE(0, 0x0445)
+#define TSDB_CODE_DND_BNODE_ALREADY_DEPLOYED    TAOS_DEF_ERROR_CODE(0, 0x0450)
+#define TSDB_CODE_DND_BNODE_NOT_DEPLOYED        TAOS_DEF_ERROR_CODE(0, 0x0451)
+#define TSDB_CODE_DND_BNODE_ID_INVALID          TAOS_DEF_ERROR_CODE(0, 0x0452)
+#define TSDB_CODE_DND_BNODE_ID_NOT_FOUND        TAOS_DEF_ERROR_CODE(0, 0x0453)
+#define TSDB_CODE_DND_BNODE_READ_FILE_ERROR     TAOS_DEF_ERROR_CODE(0, 0x0454)
+#define TSDB_CODE_DND_BNODE_WRITE_FILE_ERROR    TAOS_DEF_ERROR_CODE(0, 0x0455)
+#define TSDB_CODE_DND_VNODE_TOO_MANY_VNODES     TAOS_DEF_ERROR_CODE(0, 0x0460)
+#define TSDB_CODE_DND_VNODE_READ_FILE_ERROR     TAOS_DEF_ERROR_CODE(0, 0x0461)
+#define TSDB_CODE_DND_VNODE_WRITE_FILE_ERROR    TAOS_DEF_ERROR_CODE(0, 0x0462)
 
 // vnode
 #define TSDB_CODE_VND_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0500)  //"Action in progress")
@@ -377,132 +396,6 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_WAL_FILE_CORRUPTED            TAOS_DEF_ERROR_CODE(0, 0x1001)  //"WAL file is corrupted")
 #define TSDB_CODE_WAL_SIZE_LIMIT                TAOS_DEF_ERROR_CODE(0, 0x1002)  //"WAL size exceeds limit")
 
-// http
-#define TSDB_CODE_HTTP_SERVER_OFFLINE           TAOS_DEF_ERROR_CODE(0, 0x1100)  //"http server is not onlin")
-#define TSDB_CODE_HTTP_UNSUPPORT_URL            TAOS_DEF_ERROR_CODE(0, 0x1101)  //"url is not support")
-#define TSDB_CODE_HTTP_INVALID_URL              TAOS_DEF_ERROR_CODE(0, 0x1102)  //invalid url format")
-#define TSDB_CODE_HTTP_NO_ENOUGH_MEMORY         TAOS_DEF_ERROR_CODE(0, 0x1103)  //"no enough memory")
-#define TSDB_CODE_HTTP_REQUSET_TOO_BIG          TAOS_DEF_ERROR_CODE(0, 0x1104)  //"request size is too big")
-#define TSDB_CODE_HTTP_NO_AUTH_INFO             TAOS_DEF_ERROR_CODE(0, 0x1105)  //"no auth info input")
-#define TSDB_CODE_HTTP_NO_MSG_INPUT             TAOS_DEF_ERROR_CODE(0, 0x1106)  //"request is empty")
-#define TSDB_CODE_HTTP_NO_SQL_INPUT             TAOS_DEF_ERROR_CODE(0, 0x1107)  //"no sql input")
-#define TSDB_CODE_HTTP_NO_EXEC_USEDB            TAOS_DEF_ERROR_CODE(0, 0x1108)  //"no need to execute use db cmd")
-#define TSDB_CODE_HTTP_SESSION_FULL             TAOS_DEF_ERROR_CODE(0, 0x1109)  //"session list was full")
-#define TSDB_CODE_HTTP_GEN_TAOSD_TOKEN_ERR      TAOS_DEF_ERROR_CODE(0, 0x110A)  //"generate taosd token error")
-#define TSDB_CODE_HTTP_INVALID_MULTI_REQUEST    TAOS_DEF_ERROR_CODE(0, 0x110B)  //"size of multi request is 0")
-#define TSDB_CODE_HTTP_CREATE_GZIP_FAILED       TAOS_DEF_ERROR_CODE(0, 0x110C)  //"failed to create gzip")
-#define TSDB_CODE_HTTP_FINISH_GZIP_FAILED       TAOS_DEF_ERROR_CODE(0, 0x110D)  //"failed to finish gzip")
-#define TSDB_CODE_HTTP_LOGIN_FAILED             TAOS_DEF_ERROR_CODE(0, 0x110E)  //"failed to login")
-
-#define TSDB_CODE_HTTP_INVALID_VERSION          TAOS_DEF_ERROR_CODE(0, 0x1120)  //"invalid http version")
-#define TSDB_CODE_HTTP_INVALID_CONTENT_LENGTH   TAOS_DEF_ERROR_CODE(0, 0x1121)  //"invalid content length")
-#define TSDB_CODE_HTTP_INVALID_AUTH_TYPE        TAOS_DEF_ERROR_CODE(0, 0x1122)  //"invalid type of Authorization")
-#define TSDB_CODE_HTTP_INVALID_AUTH_FORMAT      TAOS_DEF_ERROR_CODE(0, 0x1123)  //"invalid format of Authorization")
-#define TSDB_CODE_HTTP_INVALID_BASIC_AUTH       TAOS_DEF_ERROR_CODE(0, 0x1124)  //"invalid basic Authorization")
-#define TSDB_CODE_HTTP_INVALID_TAOSD_AUTH       TAOS_DEF_ERROR_CODE(0, 0x1125)  //"invalid taosd Authorization")
-#define TSDB_CODE_HTTP_PARSE_METHOD_FAILED      TAOS_DEF_ERROR_CODE(0, 0x1126)  //"failed to parse method")
-#define TSDB_CODE_HTTP_PARSE_TARGET_FAILED      TAOS_DEF_ERROR_CODE(0, 0x1127)  //"failed to parse target")
-#define TSDB_CODE_HTTP_PARSE_VERSION_FAILED     TAOS_DEF_ERROR_CODE(0, 0x1128)  //"failed to parse http version")
-#define TSDB_CODE_HTTP_PARSE_SP_FAILED          TAOS_DEF_ERROR_CODE(0, 0x1129)  //"failed to parse sp")
-#define TSDB_CODE_HTTP_PARSE_STATUS_FAILED      TAOS_DEF_ERROR_CODE(0, 0x112A)  //"failed to parse status")
-#define TSDB_CODE_HTTP_PARSE_PHRASE_FAILED      TAOS_DEF_ERROR_CODE(0, 0x112B)  //"failed to parse phrase")
-#define TSDB_CODE_HTTP_PARSE_CRLF_FAILED        TAOS_DEF_ERROR_CODE(0, 0x112C)  //"failed to parse crlf")
-#define TSDB_CODE_HTTP_PARSE_HEADER_FAILED      TAOS_DEF_ERROR_CODE(0, 0x112D)  //"failed to parse header")
-#define TSDB_CODE_HTTP_PARSE_HEADER_KEY_FAILED  TAOS_DEF_ERROR_CODE(0, 0x112E)  //"failed to parse header key")
-#define TSDB_CODE_HTTP_PARSE_HEADER_VAL_FAILED  TAOS_DEF_ERROR_CODE(0, 0x112F)  //"failed to parse header val")
-#define TSDB_CODE_HTTP_PARSE_CHUNK_SIZE_FAILED  TAOS_DEF_ERROR_CODE(0, 0x1130)  //"failed to parse chunk size")
-#define TSDB_CODE_HTTP_PARSE_CHUNK_FAILED       TAOS_DEF_ERROR_CODE(0, 0x1131)  //"failed to parse chunk")
-#define TSDB_CODE_HTTP_PARSE_END_FAILED         TAOS_DEF_ERROR_CODE(0, 0x1132)  //"failed to parse end section")
-#define TSDB_CODE_HTTP_PARSE_INVALID_STATE      TAOS_DEF_ERROR_CODE(0, 0x1134)  //"invalid parse state")
-#define TSDB_CODE_HTTP_PARSE_ERROR_STATE        TAOS_DEF_ERROR_CODE(0, 0x1135)  //"failed to parse error section")
-
-#define TSDB_CODE_HTTP_GC_QUERY_NULL            TAOS_DEF_ERROR_CODE(0, 0x1150)  //"query size is 0")
-#define TSDB_CODE_HTTP_GC_QUERY_SIZE            TAOS_DEF_ERROR_CODE(0, 0x1151)  //"query size can not more than 100")
-#define TSDB_CODE_HTTP_GC_REQ_PARSE_ERROR       TAOS_DEF_ERROR_CODE(0, 0x1152)  //"parse grafana json error")
-
-#define TSDB_CODE_HTTP_TG_DB_NOT_INPUT          TAOS_DEF_ERROR_CODE(0, 0x1160)  //"database name can not be null")
-#define TSDB_CODE_HTTP_TG_DB_TOO_LONG           TAOS_DEF_ERROR_CODE(0, 0x1161)  //"database name too long")
-#define TSDB_CODE_HTTP_TG_INVALID_JSON          TAOS_DEF_ERROR_CODE(0, 0x1162)  //"invalid telegraf json fromat")
-#define TSDB_CODE_HTTP_TG_METRICS_NULL          TAOS_DEF_ERROR_CODE(0, 0x1163)  //"metrics size is 0")
-#define TSDB_CODE_HTTP_TG_METRICS_SIZE          TAOS_DEF_ERROR_CODE(0, 0x1164)  //"metrics size can not more than 1K")
-#define TSDB_CODE_HTTP_TG_METRIC_NULL           TAOS_DEF_ERROR_CODE(0, 0x1165)  //"metric name not find")
-#define TSDB_CODE_HTTP_TG_METRIC_TYPE           TAOS_DEF_ERROR_CODE(0, 0x1166)  //"metric name type should be string")
-#define TSDB_CODE_HTTP_TG_METRIC_NAME_NULL      TAOS_DEF_ERROR_CODE(0, 0x1167)  //"metric name length is 0")
-#define TSDB_CODE_HTTP_TG_METRIC_NAME_LONG      TAOS_DEF_ERROR_CODE(0, 0x1168)  //"metric name length too long")
-#define TSDB_CODE_HTTP_TG_TIMESTAMP_NULL        TAOS_DEF_ERROR_CODE(0, 0x1169)  //"timestamp not find")
-#define TSDB_CODE_HTTP_TG_TIMESTAMP_TYPE        TAOS_DEF_ERROR_CODE(0, 0x116A)  //"timestamp type should be integer")
-#define TSDB_CODE_HTTP_TG_TIMESTAMP_VAL_NULL    TAOS_DEF_ERROR_CODE(0, 0x116B)  //"timestamp value smaller than 0")
-#define TSDB_CODE_HTTP_TG_TAGS_NULL             TAOS_DEF_ERROR_CODE(0, 0x116C)  //"tags not find")
-#define TSDB_CODE_HTTP_TG_TAGS_SIZE_0           TAOS_DEF_ERROR_CODE(0, 0x116D)  //"tags size is 0")
-#define TSDB_CODE_HTTP_TG_TAGS_SIZE_LONG        TAOS_DEF_ERROR_CODE(0, 0x116E)  //"tags size too long")
-#define TSDB_CODE_HTTP_TG_TAG_NULL              TAOS_DEF_ERROR_CODE(0, 0x116F)  //"tag is null")
-#define TSDB_CODE_HTTP_TG_TAG_NAME_NULL         TAOS_DEF_ERROR_CODE(0, 0x1170)  //"tag name is null")
-#define TSDB_CODE_HTTP_TG_TAG_NAME_SIZE         TAOS_DEF_ERROR_CODE(0, 0x1171)  //"tag name length too long")
-#define TSDB_CODE_HTTP_TG_TAG_VALUE_TYPE        TAOS_DEF_ERROR_CODE(0, 0x1172)  //"tag value type should be number or string")
-#define TSDB_CODE_HTTP_TG_TAG_VALUE_NULL        TAOS_DEF_ERROR_CODE(0, 0x1173)  //"tag value is null")
-#define TSDB_CODE_HTTP_TG_TABLE_NULL            TAOS_DEF_ERROR_CODE(0, 0x1174)  //"table is null")
-#define TSDB_CODE_HTTP_TG_TABLE_SIZE            TAOS_DEF_ERROR_CODE(0, 0x1175)  //"table name length too long")
-#define TSDB_CODE_HTTP_TG_FIELDS_NULL           TAOS_DEF_ERROR_CODE(0, 0x1176)  //"fields not find")
-#define TSDB_CODE_HTTP_TG_FIELDS_SIZE_0         TAOS_DEF_ERROR_CODE(0, 0x1177)  //"fields size is 0")
-#define TSDB_CODE_HTTP_TG_FIELDS_SIZE_LONG      TAOS_DEF_ERROR_CODE(0, 0x1178)  //"fields size too long")
-#define TSDB_CODE_HTTP_TG_FIELD_NULL            TAOS_DEF_ERROR_CODE(0, 0x1179)  //"field is null")
-#define TSDB_CODE_HTTP_TG_FIELD_NAME_NULL       TAOS_DEF_ERROR_CODE(0, 0x117A)  //"field name is null")
-#define TSDB_CODE_HTTP_TG_FIELD_NAME_SIZE       TAOS_DEF_ERROR_CODE(0, 0x117B)  //"field name length too long")
-#define TSDB_CODE_HTTP_TG_FIELD_VALUE_TYPE      TAOS_DEF_ERROR_CODE(0, 0x117C)  //"field value type should be number or string")
-#define TSDB_CODE_HTTP_TG_FIELD_VALUE_NULL      TAOS_DEF_ERROR_CODE(0, 0x117D)  //"field value is null")
-#define TSDB_CODE_HTTP_TG_HOST_NOT_STRING       TAOS_DEF_ERROR_CODE(0, 0x117E)  //"host type should be string")
-#define TSDB_CODE_HTTP_TG_STABLE_NOT_EXIST      TAOS_DEF_ERROR_CODE(0, 0x117F)  //"stable not exist")
-
-#define TSDB_CODE_HTTP_OP_DB_NOT_INPUT          TAOS_DEF_ERROR_CODE(0, 0x1190)  //"database name can not be null")
-#define TSDB_CODE_HTTP_OP_DB_TOO_LONG           TAOS_DEF_ERROR_CODE(0, 0x1191)  //"database name too long")
-#define TSDB_CODE_HTTP_OP_INVALID_JSON          TAOS_DEF_ERROR_CODE(0, 0x1192)  //"invalid opentsdb json fromat")
-#define TSDB_CODE_HTTP_OP_METRICS_NULL          TAOS_DEF_ERROR_CODE(0, 0x1193)  //"metrics size is 0")
-#define TSDB_CODE_HTTP_OP_METRICS_SIZE          TAOS_DEF_ERROR_CODE(0, 0x1194)  //"metrics size can not more than 10K")
-#define TSDB_CODE_HTTP_OP_METRIC_NULL           TAOS_DEF_ERROR_CODE(0, 0x1195)  //"metric name not find")
-#define TSDB_CODE_HTTP_OP_METRIC_TYPE           TAOS_DEF_ERROR_CODE(0, 0x1196)  //"metric name type should be string")
-#define TSDB_CODE_HTTP_OP_METRIC_NAME_NULL      TAOS_DEF_ERROR_CODE(0, 0x1197)  //"metric name length is 0")
-#define TSDB_CODE_HTTP_OP_METRIC_NAME_LONG      TAOS_DEF_ERROR_CODE(0, 0x1198)  //"metric name length can not more than 22")
-#define TSDB_CODE_HTTP_OP_TIMESTAMP_NULL        TAOS_DEF_ERROR_CODE(0, 0x1199)  //"timestamp not find")
-#define TSDB_CODE_HTTP_OP_TIMESTAMP_TYPE        TAOS_DEF_ERROR_CODE(0, 0x119A)  //"timestamp type should be integer")
-#define TSDB_CODE_HTTP_OP_TIMESTAMP_VAL_NULL    TAOS_DEF_ERROR_CODE(0, 0x119B)  //"timestamp value smaller than 0")
-#define TSDB_CODE_HTTP_OP_TAGS_NULL             TAOS_DEF_ERROR_CODE(0, 0x119C)  //"tags not find")
-#define TSDB_CODE_HTTP_OP_TAGS_SIZE_0           TAOS_DEF_ERROR_CODE(0, 0x119D)  //"tags size is 0")
-#define TSDB_CODE_HTTP_OP_TAGS_SIZE_LONG        TAOS_DEF_ERROR_CODE(0, 0x119E)  //"tags size too long")
-#define TSDB_CODE_HTTP_OP_TAG_NULL              TAOS_DEF_ERROR_CODE(0, 0x119F)  //"tag is null")
-#define TSDB_CODE_HTTP_OP_TAG_NAME_NULL         TAOS_DEF_ERROR_CODE(0, 0x11A0)  //"tag name is null")
-#define TSDB_CODE_HTTP_OP_TAG_NAME_SIZE         TAOS_DEF_ERROR_CODE(0, 0x11A1)  //"tag name length too long")
-#define TSDB_CODE_HTTP_OP_TAG_VALUE_TYPE        TAOS_DEF_ERROR_CODE(0, 0x11A2)  //"tag value type should be boolean number or string")
-#define TSDB_CODE_HTTP_OP_TAG_VALUE_NULL        TAOS_DEF_ERROR_CODE(0, 0x11A3)  //"tag value is null")
-#define TSDB_CODE_HTTP_OP_TAG_VALUE_TOO_LONG    TAOS_DEF_ERROR_CODE(0, 0x11A4)  //"tag value can not more than 64")
-#define TSDB_CODE_HTTP_OP_VALUE_NULL            TAOS_DEF_ERROR_CODE(0, 0x11A5)  //"value not find")
-#define TSDB_CODE_HTTP_OP_VALUE_TYPE            TAOS_DEF_ERROR_CODE(0, 0x11A6)  //"value type should be boolean number or string")
-
-#define TSDB_CODE_HTTP_REQUEST_JSON_ERROR       TAOS_DEF_ERROR_CODE(0, 0x1F00)  //"http request json error")
-
-// odbc
-#define TSDB_CODE_ODBC_OOM                      TAOS_DEF_ERROR_CODE(0, 0x2100)  //"out of memory")
-#define TSDB_CODE_ODBC_CONV_CHAR_NOT_NUM        TAOS_DEF_ERROR_CODE(0, 0x2101)  //"convertion not a valid literal input")
-#define TSDB_CODE_ODBC_CONV_UNDEF               TAOS_DEF_ERROR_CODE(0, 0x2102)  //"convertion undefined")
-#define TSDB_CODE_ODBC_CONV_TRUNC_FRAC          TAOS_DEF_ERROR_CODE(0, 0x2103)  //"convertion fractional truncated")
-#define TSDB_CODE_ODBC_CONV_TRUNC               TAOS_DEF_ERROR_CODE(0, 0x2104)  //"convertion truncated")
-#define TSDB_CODE_ODBC_CONV_NOT_SUPPORT         TAOS_DEF_ERROR_CODE(0, 0x2105)  //"convertion not supported")
-#define TSDB_CODE_ODBC_CONV_OOR                 TAOS_DEF_ERROR_CODE(0, 0x2106)  //"convertion numeric value out of range")
-#define TSDB_CODE_ODBC_OUT_OF_RANGE             TAOS_DEF_ERROR_CODE(0, 0x2107)  //"out of range")
-#define TSDB_CODE_ODBC_NOT_SUPPORT              TAOS_DEF_ERROR_CODE(0, 0x2108)  //"not supported yet")
-#define TSDB_CODE_ODBC_INVALID_HANDLE           TAOS_DEF_ERROR_CODE(0, 0x2109)  //"invalid handle")
-#define TSDB_CODE_ODBC_NO_RESULT                TAOS_DEF_ERROR_CODE(0, 0x210a)  //"no result set")
-#define TSDB_CODE_ODBC_NO_FIELDS                TAOS_DEF_ERROR_CODE(0, 0x210b)  //"no fields returned")
-#define TSDB_CODE_ODBC_INVALID_CURSOR           TAOS_DEF_ERROR_CODE(0, 0x210c)  //"invalid cursor")
-#define TSDB_CODE_ODBC_STATEMENT_NOT_READY      TAOS_DEF_ERROR_CODE(0, 0x210d)  //"statement not ready")
-#define TSDB_CODE_ODBC_CONNECTION_BUSY          TAOS_DEF_ERROR_CODE(0, 0x210e)  //"connection still busy")
-#define TSDB_CODE_ODBC_BAD_CONNSTR              TAOS_DEF_ERROR_CODE(0, 0x210f)  //"bad connection string")
-#define TSDB_CODE_ODBC_BAD_ARG                  TAOS_DEF_ERROR_CODE(0, 0x2110)  //"bad argument")
-#define TSDB_CODE_ODBC_CONV_NOT_VALID_TS        TAOS_DEF_ERROR_CODE(0, 0x2111)  //"not a valid timestamp")
-#define TSDB_CODE_ODBC_CONV_SRC_TOO_LARGE       TAOS_DEF_ERROR_CODE(0, 0x2112)  //"src too large")
-#define TSDB_CODE_ODBC_CONV_SRC_BAD_SEQ         TAOS_DEF_ERROR_CODE(0, 0x2113)  //"src bad sequence")
-#define TSDB_CODE_ODBC_CONV_SRC_INCOMPLETE      TAOS_DEF_ERROR_CODE(0, 0x2114)  //"src incomplete")
-#define TSDB_CODE_ODBC_CONV_SRC_GENERAL         TAOS_DEF_ERROR_CODE(0, 0x2115)  //"src general")
-
 // tfs
 #define TSDB_CODE_FS_OUT_OF_MEMORY              TAOS_DEF_ERROR_CODE(0, 0x2200)  //"tfs out of memory")
 #define TSDB_CODE_FS_INVLD_CFG                  TAOS_DEF_ERROR_CODE(0, 0x2201)  //"tfs invalid mount config")

source/client/src/clientEnv.c

@@ -227,7 +227,7 @@ void taos_init_imp(void) {
 
   rpcInit();
 
-  SCatalogCfg cfg = {.enableVgroupCache = true, .maxDBCacheNum = 100, .maxTblCacheNum = 100};
+  SCatalogCfg cfg = {.maxDBCacheNum = 100, .maxTblCacheNum = 100};
   catalogInit(&cfg);
 
   tscDebug("starting to initialize TAOS driver, local ep: %s", tsLocalEp);

source/client/src/clientImpl.c

@@ -230,6 +230,57 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag, void** pJob) {
   return scheduleAsyncExecJob(pRequest->pTscObj->pTransporter, NULL/*todo appInfo.xxx*/, pDag, pJob);
 }
 
+TAOS_RES *tmq_create_topic(TAOS* taos, const char* name, const char* sql, int sqlLen) {
+  STscObj* pTscObj = (STscObj*)taos;
+  SRequestObj* pRequest = NULL;
+  SQueryNode*  pQuery = NULL;
+  SQueryDag*   pDag = NULL;
+  char *dagStr = NULL;
+
+  terrno = TSDB_CODE_SUCCESS;
+
+  CHECK_CODE_GOTO(buildRequest(pTscObj, sql, sqlLen, &pRequest), _return);
+  CHECK_CODE_GOTO(parseSql(pRequest, &pQuery), _return);
+  //TODO: check sql valid
+
+  CHECK_CODE_GOTO(qCreateQueryDag(pQuery, &pDag), _return);
+
+  dagStr = qDagToString(pDag);
+  if(dagStr == NULL) {
+    //TODO
+  }
+
+  SCMCreateTopicReq req = {
+    .name = (char*)name,
+    .igExists = 0,
+    .phyPlan = dagStr,
+  };
+
+  void* buf = NULL;
+  int tlen = tSerializeSCMCreateTopicReq(&buf, &req);
+
+  pRequest->body.requestMsg = (SDataBuf){ .pData = buf, .len = tlen };
+
+  SMsgSendInfo* body = buildSendMsgInfoImpl(pRequest);
+  SEpSet* pEpSet = &pTscObj->pAppInfo->mgmtEp.epSet;
+
+  int64_t transporterId = 0;
+  asyncSendMsgToServer(pTscObj->pTransporter, pEpSet, &transporterId, body);
+
+  tsem_wait(&pRequest->body.rspSem);
+
+  destroySendMsgInfo(body);
+
+_return:
+  qDestroyQuery(pQuery);
+  qDestroyQueryDag(pDag); 
+  destroySendMsgInfo(body);
+  if (pRequest != NULL && terrno != TSDB_CODE_SUCCESS) {
+    pRequest->code = terrno;
+  }
+  return pRequest;
+}
+
 TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) {
   STscObj *pTscObj = (STscObj *)taos;
   if (sqlLen > (size_t) tsMaxSQLStringLen) {
@@ -257,7 +308,7 @@ TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) {
   }
 
 _return:
-  qDestoryQuery(pQuery);
+  qDestroyQuery(pQuery);
   qDestroyQueryDag(pDag);
   if (NULL != pRequest && TSDB_CODE_SUCCESS != terrno) {
     pRequest->code = terrno;

source/client/test/clientTests.cpp

@@ -399,6 +399,41 @@ TEST(testCase, drop_stable_Test) {
   taos_close(pConn);
 }
 
+TEST(testCase, create_topic_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "create database abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in use db, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create stable st1(ts timestamp, k int) tags(a int)");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create stable, reason:%s\n", taos_errstr(pRes));
+  }
+
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  ASSERT_TRUE(pFields == NULL);
+
+  int32_t numOfFields = taos_num_fields(pRes);
+  ASSERT_EQ(numOfFields, 0);
+
+  taos_free_result(pRes);
+  
+  char* sql = "select * from st1";
+  tmq_create_topic(pConn, "test_topic_1", sql, strlen(sql));
+  taos_close(pConn); 
+}
+
+
 //TEST(testCase, show_table_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);

source/dnode/CMakeLists.txt

 add_subdirectory(mnode)
 add_subdirectory(vnode)
 add_subdirectory(qnode)
+add_subdirectory(snode)
+add_subdirectory(bnode)
 add_subdirectory(mgmt)
\ No newline at end of file

source/dnode/bnode/CMakeLists.txt

+aux_source_directory(src BNODE_SRC)
+add_library(bnode ${BNODE_SRC})
+target_include_directories(
+    bnode
+    PUBLIC "${CMAKE_SOURCE_DIR}/include/dnode/bnode"
+    private "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+target_link_libraries(
+    bnode
+    PRIVATE transport
+    PRIVATE os
+    PRIVATE common
+    PRIVATE util
+)
\ No newline at end of file

source/dnode/bnode/inc/bndInt.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_BNODE_INT_H_
+#define _TD_BNODE_INT_H_
+
+#include "os.h"
+
+#include "tarray.h"
+#include "tlog.h"
+#include "tmsg.h"
+#include "trpc.h"
+
+#include "bnode.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SBnode {
+  int32_t           dnodeId;
+  int64_t           clusterId;
+  SBnodeCfg         cfg;
+  SendMsgToDnodeFp  sendMsgToDnodeFp;
+  SendMsgToMnodeFp  sendMsgToMnodeFp;
+  SendRedirectMsgFp sendRedirectMsgFp;
+} SBnode;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_BNODE_INT_H_*/
\ No newline at end of file

source/dnode/bnode/src/bnode.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 "bndInt.h"
+
+SBnode *bndOpen(const char *path, const SBnodeOpt *pOption) {
+  SBnode *pBnode = calloc(1, sizeof(SBnode));
+  return pBnode;
+}
+
+void bndClose(SBnode *pBnode) { free(pBnode); }
+
+int32_t bndGetLoad(SBnode *pBnode, SBnodeLoad *pLoad) { return 0; }
+
+int32_t bndProcessWMsgs(SBnode *pBnode, SArray *pMsgs) { return 0; }
+
+void bndDestroy(const char *path) {}

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

@@ -140,6 +140,7 @@ void dmnInitOption(SDnodeOpt *pOption) {
   pOption->sver = 30000000; //3.0.0.0
   pOption->numOfCores = tsNumOfCores;
   pOption->numOfSupportVnodes = 1;
+  pOption->numOfCommitThreads = 1;
   pOption->statusInterval = tsStatusInterval;
   pOption->numOfThreadsPerCore = tsNumOfThreadsPerCore;
   pOption->ratioOfQueryCores = tsRatioOfQueryCores;

source/dnode/mgmt/impl/CMakeLists.txt

@@ -5,6 +5,9 @@ target_link_libraries(
     PUBLIC cjson
     PUBLIC mnode
     PUBLIC vnode
+    PUBLIC qnode
+    PUBLIC snode
+    PUBLIC bnode
     PUBLIC wal
     PUBLIC sync
     PUBLIC taos

source/dnode/mgmt/impl/inc/dndBnode.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_BNODE_H_
+#define _TD_DND_BNODE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "dndInt.h"
+
+int32_t dndInitBnode(SDnode *pDnode);
+void    dndCleanupBnode(SDnode *pDnode);
+
+void    dndProcessBnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet);
+int32_t dndProcessCreateBnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg);
+int32_t dndProcessDropBnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_DND_BNODE_H_*/
\ No newline at end of file

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

@@ -20,8 +20,11 @@
 extern "C" {
 #endif
 
-#include "cJSON.h"
 #include "os.h"
+
+#include "cJSON.h"
+#include "tcache.h"
+#include "tcrc32c.h"
 #include "tep.h"
 #include "thash.h"
 #include "tlockfree.h"
@@ -34,7 +37,11 @@ extern "C" {
 #include "tworker.h"
 
 #include "dnode.h"
+
+#include "bnode.h"
 #include "mnode.h"
+#include "qnode.h"
+#include "snode.h"
 #include "vnode.h"
 
 extern int32_t dDebugFlag;
@@ -47,12 +54,26 @@ extern int32_t dDebugFlag;
 #define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); }}
 
 typedef enum { DND_STAT_INIT, DND_STAT_RUNNING, DND_STAT_STOPPED } EStat;
+typedef enum { DND_WORKER_SINGLE, DND_WORKER_MULTI } EWorkerType;
 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;
+  taos_queue     queue;
+  union {
+    SWorkerPool  pool;
+    SMWorkerPool mpool;
+  };
+} SDnodeWorker;
+
 typedef struct {
   char *dnode;
   char *mnode;
-  char *qnode;
   char *snode;
   char *bnode;
   char *vnodes;
@@ -76,23 +97,47 @@ typedef struct {
 } SDnodeMgmt;
 
 typedef struct {
-  int32_t     refCount;
-  int8_t      deployed;
-  int8_t      dropped;
-  int8_t      replica;
-  int8_t      selfIndex;
-  SReplica    replicas[TSDB_MAX_REPLICA];
-  char       *file;
-  SMnode     *pMnode;
-  SRWLatch    latch;
-  taos_queue  pReadQ;
-  taos_queue  pWriteQ;
-  taos_queue  pSyncQ;
-  SWorkerPool readPool;
-  SWorkerPool writePool;
-  SWorkerPool syncPool;
+  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;
@@ -117,6 +162,9 @@ typedef struct SDnode {
   FileFd      lockFd;
   SDnodeMgmt  dmgmt;
   SMnodeMgmt  mmgmt;
+  SQnodeMgmt  qmgmt;
+  SSnodeMgmt  smgmt;
+  SBnodeMgmt  bmgmt;
   SVnodesMgmt vmgmt;
   STransMgmt  tmgmt;
   SStartupMsg startup;

source/dnode/mgmt/impl/inc/dndQnode.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_QNODE_H_
+#define _TD_DND_QNODE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "dndInt.h"
+
+int32_t dndInitQnode(SDnode *pDnode);
+void    dndCleanupQnode(SDnode *pDnode);
+
+void    dndProcessQnodeQueryMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet);
+void    dndProcessQnodeFetchMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet);
+int32_t dndProcessCreateQnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg);
+int32_t dndProcessDropQnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_DND_QNODE_H_*/
\ No newline at end of file

source/dnode/mgmt/impl/inc/dndSnode.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_SNODE_H_
+#define _TD_DND_SNODE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "dndInt.h"
+
+int32_t dndInitSnode(SDnode *pDnode);
+void    dndCleanupSnode(SDnode *pDnode);
+
+void    dndProcessSnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet);
+int32_t dndProcessCreateSnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg);
+int32_t dndProcessDropSnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_DND_SNODE_H_*/
\ No newline at end of file

source/dnode/mgmt/impl/inc/dndWorker.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_WORKER_H_
+#define _TD_DND_WORKER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "dndInt.h"
+
+int32_t dndInitWorker(SDnode *pDnode, SDnodeWorker *pWorker, EWorkerType type, const char *name, int32_t minNum,
+                      int32_t maxNum, void *queueFp);
+void    dndCleanupWorker(SDnodeWorker *pWorker);
+int32_t dndWriteMsgToWorker(SDnodeWorker *pWorker, void *pCont, int32_t contLen);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_DND_WORKER_H_*/
\ No newline at end of file

source/dnode/mgmt/impl/src/dndBnode.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 "dndBnode.h"
+#include "dndDnode.h"
+#include "dndTransport.h"
+#include "dndWorker.h"
+
+static void dndProcessBnodeQueue(SDnode *pDnode, taos_qall qall, int32_t numOfMsgs);
+
+static SBnode *dndAcquireBnode(SDnode *pDnode) {
+  SBnodeMgmt *pMgmt = &pDnode->bmgmt;
+  SBnode     *pBnode = NULL;
+  int32_t     refCount = 0;
+
+  taosRLockLatch(&pMgmt->latch);
+  if (pMgmt->deployed && !pMgmt->dropped) {
+    refCount = atomic_add_fetch_32(&pMgmt->refCount, 1);
+    pBnode = pMgmt->pBnode;
+  } else {
+    terrno = TSDB_CODE_DND_BNODE_NOT_DEPLOYED;
+  }
+  taosRUnLockLatch(&pMgmt->latch);
+
+  if (pBnode != NULL) {
+    dTrace("acquire bnode, refCount:%d", refCount);
+  }
+  return pBnode;
+}
+
+static void dndReleaseBnode(SDnode *pDnode, SBnode *pBnode) {
+  SBnodeMgmt *pMgmt = &pDnode->bmgmt;
+  int32_t     refCount = 0;
+
+  taosRLockLatch(&pMgmt->latch);
+  if (pBnode != NULL) {
+    refCount = atomic_sub_fetch_32(&pMgmt->refCount, 1);
+  }
+  taosRUnLockLatch(&pMgmt->latch);
+
+  if (pBnode != NULL) {
+    dTrace("release bnode, refCount:%d", refCount);
+  }
+}
+
+static int32_t dndReadBnodeFile(SDnode *pDnode) {
+  SBnodeMgmt *pMgmt = &pDnode->bmgmt;
+  int32_t     code = TSDB_CODE_DND_BNODE_READ_FILE_ERROR;
+  int32_t     len = 0;
+  int32_t     maxLen = 4096;
+  char       *content = calloc(1, maxLen + 1);
+  cJSON      *root = NULL;
+
+  char file[PATH_MAX + 20];
+  snprintf(file, PATH_MAX + 20, "%s/bnode.json", pDnode->dir.dnode);
+
+  FILE *fp = fopen(file, "r");
+  if (fp == NULL) {
+    dDebug("file %s not exist", file);
+    code = 0;
+    goto PRASE_BNODE_OVER;
+  }
+
+  len = (int32_t)fread(content, 1, maxLen, fp);
+  if (len <= 0) {
+    dError("failed to read %s since content is null", file);
+    goto PRASE_BNODE_OVER;
+  }
+
+  content[len] = 0;
+  root = cJSON_Parse(content);
+  if (root == NULL) {
+    dError("failed to read %s since invalid json format", file);
+    goto PRASE_BNODE_OVER;
+  }
+
+  cJSON *deployed = cJSON_GetObjectItem(root, "deployed");
+  if (!deployed || deployed->type != cJSON_Number) {
+    dError("failed to read %s since deployed not found", file);
+    goto PRASE_BNODE_OVER;
+  }
+  pMgmt->deployed = deployed->valueint;
+
+  cJSON *dropped = cJSON_GetObjectItem(root, "dropped");
+  if (!dropped || dropped->type != cJSON_Number) {
+    dError("failed to read %s since dropped not found", file);
+    goto PRASE_BNODE_OVER;
+  }
+  pMgmt->dropped = dropped->valueint;
+
+  code = 0;
+  dDebug("succcessed to read file %s, deployed:%d dropped:%d", file, pMgmt->deployed, pMgmt->dropped);
+
+PRASE_BNODE_OVER:
+  if (content != NULL) free(content);
+  if (root != NULL) cJSON_Delete(root);
+  if (fp != NULL) fclose(fp);
+
+  terrno = code;
+  return code;
+}
+
+static int32_t dndWriteBnodeFile(SDnode *pDnode) {
+  SBnodeMgmt *pMgmt = &pDnode->bmgmt;
+
+  char file[PATH_MAX + 20];
+  snprintf(file, PATH_MAX + 20, "%s/bnode.json", pDnode->dir.dnode);
+
+  FILE *fp = fopen(file, "w");
+  if (fp == NULL) {
+    terrno = TSDB_CODE_DND_BNODE_WRITE_FILE_ERROR;
+    dError("failed to write %s since %s", file, terrstr());
+    return -1;
+  }
+
+  int32_t len = 0;
+  int32_t maxLen = 4096;
+  char   *content = calloc(1, maxLen + 1);
+
+  len += snprintf(content + len, maxLen - len, "{\n");
+  len += snprintf(content + len, maxLen - len, "  \"deployed\": %d,\n", pMgmt->deployed);
+  len += snprintf(content + len, maxLen - len, "  \"dropped\": %d\n", pMgmt->dropped);
+  len += snprintf(content + len, maxLen - len, "}\n");
+
+  fwrite(content, 1, len, fp);
+  taosFsyncFile(fileno(fp));
+  fclose(fp);
+  free(content);
+
+  char realfile[PATH_MAX + 20];
+  snprintf(realfile, PATH_MAX + 20, "%s/bnode.json", pDnode->dir.dnode);
+
+  if (taosRenameFile(file, realfile) != 0) {
+    terrno = TSDB_CODE_DND_BNODE_WRITE_FILE_ERROR;
+    dError("failed to rename %s since %s", file, terrstr());
+    return -1;
+  }
+
+  dInfo("successed to write %s, deployed:%d dropped:%d", realfile, pMgmt->deployed, pMgmt->dropped);
+  return 0;
+}
+
+static int32_t dndStartBnodeWorker(SDnode *pDnode) {
+  SBnodeMgmt *pMgmt = &pDnode->bmgmt;
+  if (dndInitWorker(pDnode, &pMgmt->writeWorker, DND_WORKER_MULTI, "bnode-write", 0, 1, dndProcessBnodeQueue) != 0) {
+    dError("failed to start bnode write worker since %s", terrstr());
+    return -1;
+  }
+
+  return 0;
+}
+
+static void dndStopBnodeWorker(SDnode *pDnode) {
+  SBnodeMgmt *pMgmt = &pDnode->bmgmt;
+
+  taosWLockLatch(&pMgmt->latch);
+  pMgmt->deployed = 0;
+  taosWUnLockLatch(&pMgmt->latch);
+
+  while (pMgmt->refCount > 1) {
+    taosMsleep(10);
+  }
+
+  dndCleanupWorker(&pMgmt->writeWorker);
+}
+
+static void dndBuildBnodeOption(SDnode *pDnode, SBnodeOpt *pOption) {
+  pOption->pDnode = pDnode;
+  pOption->sendMsgToDnodeFp = dndSendMsgToDnode;
+  pOption->sendMsgToMnodeFp = dndSendMsgToMnode;
+  pOption->sendRedirectMsgFp = dndSendRedirectMsg;
+  pOption->dnodeId = dndGetDnodeId(pDnode);
+  pOption->clusterId = dndGetClusterId(pDnode);
+  pOption->cfg.sver = pDnode->opt.sver;
+}
+
+static int32_t dndOpenBnode(SDnode *pDnode) {
+  SBnodeMgmt *pMgmt = &pDnode->bmgmt;
+  SBnodeOpt   option = {0};
+  dndBuildBnodeOption(pDnode, &option);
+
+  SBnode *pBnode = bndOpen(pDnode->dir.bnode, &option);
+  if (pBnode == NULL) {
+    dError("failed to open bnode since %s", terrstr());
+    return -1;
+  }
+
+  if (dndStartBnodeWorker(pDnode) != 0) {
+    dError("failed to start bnode worker since %s", terrstr());
+    bndClose(pBnode);
+    return -1;
+  }
+
+  pMgmt->deployed = 1;
+  if (dndWriteBnodeFile(pDnode) != 0) {
+    pMgmt->deployed = 0;
+    dError("failed to write bnode file since %s", terrstr());
+    dndStopBnodeWorker(pDnode);
+    bndClose(pBnode);
+    return -1;
+  }
+
+  taosWLockLatch(&pMgmt->latch);
+  pMgmt->pBnode = pBnode;
+  taosWUnLockLatch(&pMgmt->latch);
+
+  dInfo("bnode open successfully");
+  return 0;
+}
+
+static int32_t dndDropBnode(SDnode *pDnode) {
+  SBnodeMgmt *pMgmt = &pDnode->bmgmt;
+
+  SBnode *pBnode = dndAcquireBnode(pDnode);
+  if (pBnode == NULL) {
+    dError("failed to drop bnode since %s", terrstr());
+    return -1;
+  }
+
+  taosRLockLatch(&pMgmt->latch);
+  pMgmt->dropped = 1;
+  taosRUnLockLatch(&pMgmt->latch);
+
+  if (dndWriteBnodeFile(pDnode) != 0) {
+    taosRLockLatch(&pMgmt->latch);
+    pMgmt->dropped = 0;
+    taosRUnLockLatch(&pMgmt->latch);
+
+    dndReleaseBnode(pDnode, pBnode);
+    dError("failed to drop bnode since %s", terrstr());
+    return -1;
+  }
+
+  dndReleaseBnode(pDnode, pBnode);
+  dndStopBnodeWorker(pDnode);
+  pMgmt->deployed = 0;
+  dndWriteBnodeFile(pDnode);
+  bndClose(pBnode);
+  pMgmt->pBnode = NULL;
+  bndDestroy(pDnode->dir.bnode);
+
+  return 0;
+}
+
+int32_t dndProcessCreateBnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
+  SCreateBnodeInMsg *pMsg = pRpcMsg->pCont;
+  pMsg->dnodeId = htonl(pMsg->dnodeId);
+
+  if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
+    terrno = TSDB_CODE_DND_BNODE_ID_INVALID;
+    return -1;
+  } else {
+    return dndOpenBnode(pDnode);
+  }
+}
+
+int32_t dndProcessDropBnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
+  SDropBnodeInMsg *pMsg = pRpcMsg->pCont;
+  pMsg->dnodeId = htonl(pMsg->dnodeId);
+
+  if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
+    terrno = TSDB_CODE_DND_BNODE_ID_INVALID;
+    return -1;
+  } else {
+    return dndDropBnode(pDnode);
+  }
+}
+
+static void dndSendBnodeErrorRsp(SRpcMsg *pMsg, int32_t code) {
+  SRpcMsg rpcRsp = {.handle = pMsg->handle, .ahandle = pMsg->ahandle, .code = code};
+  rpcSendResponse(&rpcRsp);
+  rpcFreeCont(pMsg->pCont);
+  taosFreeQitem(pMsg);
+}
+
+static void dndSendBnodeErrorRsps(taos_qall qall, int32_t numOfMsgs, int32_t code) {
+  for (int32_t i = 0; i < numOfMsgs; ++i) {
+    SRpcMsg *pMsg = NULL;
+    taosGetQitem(qall, (void **)&pMsg);
+    dndSendBnodeErrorRsp(pMsg, code);
+  }
+}
+
+static void dndProcessBnodeQueue(SDnode *pDnode, taos_qall qall, int32_t numOfMsgs) {
+  SBnode *pBnode = dndAcquireBnode(pDnode);
+  if (pBnode == NULL) {
+    dndSendBnodeErrorRsps(qall, numOfMsgs, TSDB_CODE_OUT_OF_MEMORY);
+    return;
+  }
+
+  SArray *pArray = taosArrayInit(numOfMsgs, sizeof(SRpcMsg *));
+  if (pArray == NULL) {
+    dndReleaseBnode(pDnode, pBnode);
+    dndSendBnodeErrorRsps(qall, numOfMsgs, TSDB_CODE_OUT_OF_MEMORY);
+    return;
+  }
+
+  for (int32_t i = 0; i < numOfMsgs; ++i) {
+    SRpcMsg *pMsg = NULL;
+    taosGetQitem(qall, (void **)&pMsg);
+    void *ptr = taosArrayPush(pArray, &pMsg);
+    if (ptr == NULL) {
+      dndSendBnodeErrorRsp(pMsg, TSDB_CODE_OUT_OF_MEMORY);
+    }
+  }
+
+  bndProcessWMsgs(pBnode, pArray);
+
+  for (size_t i = 0; i < numOfMsgs; i++) {
+    SRpcMsg *pMsg = *(SRpcMsg **)taosArrayGet(pArray, i);
+    rpcFreeCont(pMsg->pCont);
+    taosFreeQitem(pMsg);
+  }
+  taosArrayDestroy(pArray);
+  dndReleaseBnode(pDnode, pBnode);
+}
+
+static void dndWriteBnodeMsgToWorker(SDnode *pDnode, SDnodeWorker *pWorker, SRpcMsg *pMsg) {
+  int32_t code = TSDB_CODE_DND_BNODE_NOT_DEPLOYED;
+
+  SBnode *pBnode = dndAcquireBnode(pDnode);
+  if (pBnode != NULL) {
+    code = dndWriteMsgToWorker(pWorker, pMsg, sizeof(SRpcMsg));
+  }
+  dndReleaseBnode(pDnode, pBnode);
+
+  if (code != 0) {
+    if (pMsg->msgType & 1u) {
+      SRpcMsg rsp = {.handle = pMsg->handle, .ahandle = pMsg->ahandle, .code = code};
+      rpcSendResponse(&rsp);
+    }
+    rpcFreeCont(pMsg->pCont);
+  }
+}
+
+void dndProcessBnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
+  dndWriteBnodeMsgToWorker(pDnode, &pDnode->bmgmt.writeWorker, pMsg);
+}
+
+int32_t dndInitBnode(SDnode *pDnode) {
+  SBnodeMgmt *pMgmt = &pDnode->bmgmt;
+  taosInitRWLatch(&pMgmt->latch);
+
+  if (dndReadBnodeFile(pDnode) != 0) {
+    return -1;
+  }
+
+  if (pMgmt->dropped) {
+    dInfo("bnode has been deployed and needs to be deleted");
+    bndDestroy(pDnode->dir.bnode);
+    return 0;
+  }
+
+  if (!pMgmt->deployed) return 0;
+
+  return dndOpenBnode(pDnode);
+}
+
+void dndCleanupBnode(SDnode *pDnode) {
+  SBnodeMgmt *pMgmt = &pDnode->bmgmt;
+  if (pMgmt->pBnode) {
+    dndStopBnodeWorker(pDnode);
+    bndClose(pMgmt->pBnode);
+    pMgmt->pBnode = NULL;
+  }
+}

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

@@ -17,6 +17,7 @@
 #include "dndDnode.h"
 #include "dndTransport.h"
 #include "dndVnodes.h"
+#include "dndMnode.h"
 
 static int32_t dndInitMgmtWorker(SDnode *pDnode);
 static void    dndCleanupMgmtWorker(SDnode *pDnode);
@@ -28,10 +29,10 @@ static int32_t dndReadDnodes(SDnode *pDnode);
 static int32_t dndWriteDnodes(SDnode *pDnode);
 static void   *dnodeThreadRoutine(void *param);
 
-static void dndProcessConfigDnodeReq(SDnode *pDnode, SRpcMsg *pMsg);
-static void dndProcessStatusRsp(SDnode *pDnode, SRpcMsg *pMsg);
-static void dndProcessAuthRsp(SDnode *pDnode, SRpcMsg *pMsg);
-static void dndProcessGrantRsp(SDnode *pDnode, SRpcMsg *pMsg);
+static int32_t dndProcessConfigDnodeReq(SDnode *pDnode, SRpcMsg *pMsg);
+static void    dndProcessStatusRsp(SDnode *pDnode, SRpcMsg *pMsg);
+static void    dndProcessAuthRsp(SDnode *pDnode, SRpcMsg *pMsg);
+static void    dndProcessGrantRsp(SDnode *pDnode, SRpcMsg *pMsg);
 
 int32_t dndGetDnodeId(SDnode *pDnode) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
@@ -458,13 +459,11 @@ static void dndProcessAuthRsp(SDnode *pDnode, SRpcMsg *pMsg) { assert(1); }
 
 static void dndProcessGrantRsp(SDnode *pDnode, SRpcMsg *pMsg) { assert(1); }
 
-static void dndProcessConfigDnodeReq(SDnode *pDnode, SRpcMsg *pMsg) {
+static int32_t dndProcessConfigDnodeReq(SDnode *pDnode, SRpcMsg *pMsg) {
   dError("config msg is received, but not supported yet");
   SCfgDnodeMsg *pCfg = pMsg->pCont;
 
-  int32_t code = TSDB_CODE_OPS_NOT_SUPPORT;
-  SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0, .code = code};
-  rpcSendResponse(&rspMsg);
+  return TSDB_CODE_OPS_NOT_SUPPORT;
 }
 
 void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pMsg) {
@@ -646,11 +645,8 @@ static void dndProcessMgmtQueue(SDnode *pDnode, SRpcMsg *pMsg) {
     case TDMT_DND_DROP_MNODE:
       code = dndProcessDropMnodeReq(pDnode, pMsg);
       break;
-    case TDMT_DND_NETWORK_TEST:
-      dndProcessStartupReq(pDnode, pMsg);
-      break;
     case TDMT_DND_CONFIG_DNODE:
-      dndProcessConfigDnodeReq(pDnode, pMsg);
+      code = dndProcessConfigDnodeReq(pDnode, pMsg);
       break;
     case TDMT_MND_STATUS_RSP:
       dndProcessStatusRsp(pDnode, pMsg);

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

@@ -17,42 +17,9 @@
 #include "dndMnode.h"
 #include "dndDnode.h"
 #include "dndTransport.h"
+#include "dndWorker.h"
 
-static int32_t dndInitMnodeReadWorker(SDnode *pDnode);
-static int32_t dndInitMnodeWriteWorker(SDnode *pDnode);
-static int32_t dndInitMnodeSyncWorker(SDnode *pDnode);
-static void    dndCleanupMnodeReadWorker(SDnode *pDnode);
-static void    dndCleanupMnodeWriteWorker(SDnode *pDnode);
-static void    dndCleanupMnodeSyncWorker(SDnode *pDnode);
-static void    dndCleanupMnodeMgmtWorker(SDnode *pDnode);
-static int32_t dndAllocMnodeReadQueue(SDnode *pDnode);
-static int32_t dndAllocMnodeWriteQueue(SDnode *pDnode);
-static int32_t dndAllocMnodeSyncQueue(SDnode *pDnode);
-static void    dndFreeMnodeReadQueue(SDnode *pDnode);
-static void    dndFreeMnodeWriteQueue(SDnode *pDnode);
-static void    dndFreeMnodeSyncQueue(SDnode *pDnode);
-static void    dndFreeMnodeMgmtQueue(SDnode *pDnode);
-
-static void    dndProcessMnodeReadQueue(SDnode *pDnode, SMnodeMsg *pMsg);
-static void    dndProcessMnodeWriteQueue(SDnode *pDnode, SMnodeMsg *pMsg);
-static void    dndProcessMnodeSyncQueue(SDnode *pDnode, SMnodeMsg *pMsg);
-static int32_t dndWriteMnodeMsgToQueue(SMnode *pMnode, taos_queue pQueue, SRpcMsg *pRpcMsg);
-void           dndProcessMnodeReadMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet);
-void           dndProcessMnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet);
-void           dndProcessMnodeSyncMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet);
-
-static int32_t dndStartMnodeWorker(SDnode *pDnode);
-static void    dndStopMnodeWorker(SDnode *pDnode);
-
-static SMnode *dndAcquireMnode(SDnode *pDnode);
-static void    dndReleaseMnode(SDnode *pDnode, SMnode *pMnode);
-
-static int32_t dndReadMnodeFile(SDnode *pDnode);
-static int32_t dndWriteMnodeFile(SDnode *pDnode);
-
-static int32_t dndOpenMnode(SDnode *pDnode, SMnodeOpt *pOption);
-static int32_t dndAlterMnode(SDnode *pDnode, SMnodeOpt *pOption);
-static int32_t dndDropMnode(SDnode *pDnode);
+static void dndProcessMnodeQueue(SDnode *pDnode, SMnodeMsg *pMsg);
 
 static SMnode *dndAcquireMnode(SDnode *pDnode) {
   SMnodeMgmt *pMgmt = &pDnode->mmgmt;
@@ -97,49 +64,52 @@ static int32_t dndReadMnodeFile(SDnode *pDnode) {
   char       *content = calloc(1, maxLen + 1);
   cJSON      *root = NULL;
 
-  FILE *fp = fopen(pMgmt->file, "r");
+  char file[PATH_MAX + 20];
+  snprintf(file, PATH_MAX + 20, "%s/mnode.json", pDnode->dir.dnode);
+
+  FILE *fp = fopen(file, "r");
   if (fp == NULL) {
-    dDebug("file %s not exist", pMgmt->file);
+    dDebug("file %s not exist", file);
     code = 0;
     goto PRASE_MNODE_OVER;
   }
 
   len = (int32_t)fread(content, 1, maxLen, fp);
   if (len <= 0) {
-    dError("failed to read %s since content is null", pMgmt->file);
+    dError("failed to read %s since content is null", file);
     goto PRASE_MNODE_OVER;
   }
 
   content[len] = 0;
   root = cJSON_Parse(content);
   if (root == NULL) {
-    dError("failed to read %s since invalid json format", pMgmt->file);
+    dError("failed to read %s since invalid json format", file);
     goto PRASE_MNODE_OVER;
   }
 
   cJSON *deployed = cJSON_GetObjectItem(root, "deployed");
   if (!deployed || deployed->type != cJSON_Number) {
-    dError("failed to read %s since deployed not found", pMgmt->file);
+    dError("failed to read %s since deployed not found", file);
     goto PRASE_MNODE_OVER;
   }
   pMgmt->deployed = deployed->valueint;
 
   cJSON *dropped = cJSON_GetObjectItem(root, "dropped");
   if (!dropped || dropped->type != cJSON_Number) {
-    dError("failed to read %s since dropped not found", pMgmt->file);
+    dError("failed to read %s since dropped not found", file);
     goto PRASE_MNODE_OVER;
   }
   pMgmt->dropped = dropped->valueint;
 
   cJSON *mnodes = cJSON_GetObjectItem(root, "mnodes");
   if (!mnodes || mnodes->type != cJSON_Array) {
-    dError("failed to read %s since nodes not found", pMgmt->file);
+    dError("failed to read %s since nodes not found", file);
     goto PRASE_MNODE_OVER;
   }
 
   pMgmt->replica = cJSON_GetArraySize(mnodes);
   if (pMgmt->replica <= 0 || pMgmt->replica > TSDB_MAX_REPLICA) {
-    dError("failed to read %s since mnodes size %d invalid", pMgmt->file, pMgmt->replica);
+    dError("failed to read %s since mnodes size %d invalid", file, pMgmt->replica);
     goto PRASE_MNODE_OVER;
   }
 
@@ -151,28 +121,28 @@ static int32_t dndReadMnodeFile(SDnode *pDnode) {
 
     cJSON *id = cJSON_GetObjectItem(node, "id");
     if (!id || id->type != cJSON_Number) {
-      dError("failed to read %s since id not found", pMgmt->file);
+      dError("failed to read %s since id not found", file);
       goto PRASE_MNODE_OVER;
     }
     pReplica->id = id->valueint;
 
     cJSON *fqdn = cJSON_GetObjectItem(node, "fqdn");
     if (!fqdn || fqdn->type != cJSON_String || fqdn->valuestring == NULL) {
-      dError("failed to read %s since fqdn not found", pMgmt->file);
+      dError("failed to read %s since fqdn not found", file);
       goto PRASE_MNODE_OVER;
     }
     tstrncpy(pReplica->fqdn, fqdn->valuestring, TSDB_FQDN_LEN);
 
     cJSON *port = cJSON_GetObjectItem(node, "port");
     if (!port || port->type != cJSON_Number) {
-      dError("failed to read %s since port not found", pMgmt->file);
+      dError("failed to read %s since port not found", file);
       goto PRASE_MNODE_OVER;
     }
     pReplica->port = port->valueint;
   }
 
   code = 0;
-  dDebug("succcessed to read file %s, deployed:%d dropped:%d", pMgmt->file, pMgmt->deployed, pMgmt->dropped);
+  dDebug("succcessed to read file %s, deployed:%d dropped:%d", file, pMgmt->deployed, pMgmt->dropped);
 
 PRASE_MNODE_OVER:
   if (content != NULL) free(content);
@@ -186,8 +156,8 @@ PRASE_MNODE_OVER:
 static int32_t dndWriteMnodeFile(SDnode *pDnode) {
   SMnodeMgmt *pMgmt = &pDnode->mmgmt;
 
-  char file[PATH_MAX + 20] = {0};
-  snprintf(file, sizeof(file), "%s.bak", pMgmt->file);
+  char file[PATH_MAX + 20];
+  snprintf(file, PATH_MAX + 20, "%s/mnode.json.bak", pDnode->dir.dnode);
 
   FILE *fp = fopen(file, "w");
   if (fp == NULL) {
@@ -223,47 +193,36 @@ static int32_t dndWriteMnodeFile(SDnode *pDnode) {
   fclose(fp);
   free(content);
 
-  if (taosRenameFile(file, pMgmt->file) != 0) {
+  char realfile[PATH_MAX + 20];
+  snprintf(realfile, PATH_MAX + 20, "%s/mnode.json", pDnode->dir.dnode);
+
+  if (taosRenameFile(file, realfile) != 0) {
     terrno = TSDB_CODE_DND_MNODE_WRITE_FILE_ERROR;
-    dError("failed to rename %s since %s", pMgmt->file, terrstr());
+    dError("failed to rename %s since %s", file, terrstr());
     return -1;
   }
 
-  dInfo("successed to write %s, deployed:%d dropped:%d", pMgmt->file, pMgmt->deployed, pMgmt->dropped);
+  dInfo("successed to write %s, deployed:%d dropped:%d", realfile, pMgmt->deployed, pMgmt->dropped);
   return 0;
 }
 
 static int32_t dndStartMnodeWorker(SDnode *pDnode) {
-  if (dndInitMnodeReadWorker(pDnode) != 0) {
+  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
+  if (dndInitWorker(pDnode, &pMgmt->readWorker, DND_WORKER_SINGLE, "mnode-read", 0, 1, dndProcessMnodeQueue) != 0) {
     dError("failed to start mnode read worker since %s", terrstr());
     return -1;
   }
 
-  if (dndInitMnodeWriteWorker(pDnode) != 0) {
+  if (dndInitWorker(pDnode, &pMgmt->writeWorker, DND_WORKER_SINGLE, "mnode-write", 0, 1, dndProcessMnodeQueue) != 0) {
     dError("failed to start mnode write worker since %s", terrstr());
     return -1;
   }
 
-  if (dndInitMnodeSyncWorker(pDnode) != 0) {
+  if (dndInitWorker(pDnode, &pMgmt->syncWorker, DND_WORKER_SINGLE, "mnode-sync", 0, 1, dndProcessMnodeQueue) != 0) {
     dError("failed to start mnode sync worker since %s", terrstr());
     return -1;
   }
 
-  if (dndAllocMnodeReadQueue(pDnode) != 0) {
-    dError("failed to alloc mnode read queue since %s", terrstr());
-    return -1;
-  }
-
-  if (dndAllocMnodeWriteQueue(pDnode) != 0) {
-    dError("failed to alloc mnode write queue since %s", terrstr());
-    return -1;
-  }
-
-  if (dndAllocMnodeSyncQueue(pDnode) != 0) {
-    dError("failed to alloc mnode sync queue since %s", terrstr());
-    return -1;
-  }
-
   return 0;
 }
 
@@ -274,18 +233,13 @@ static void dndStopMnodeWorker(SDnode *pDnode) {
   pMgmt->deployed = 0;
   taosWUnLockLatch(&pMgmt->latch);
 
-  while (pMgmt->refCount > 1) taosMsleep(10);
-  while (!taosQueueEmpty(pMgmt->pReadQ)) taosMsleep(10);
-  while (!taosQueueEmpty(pMgmt->pWriteQ)) taosMsleep(10);
-  while (!taosQueueEmpty(pMgmt->pSyncQ)) taosMsleep(10);
-
-  dndCleanupMnodeReadWorker(pDnode);
-  dndCleanupMnodeWriteWorker(pDnode);
-  dndCleanupMnodeSyncWorker(pDnode);
+  while (pMgmt->refCount > 1) {
+    taosMsleep(10);
+  }
 
-  dndFreeMnodeReadQueue(pDnode);
-  dndFreeMnodeWriteQueue(pDnode);
-  dndFreeMnodeSyncQueue(pDnode);
+  dndCleanupWorker(&pMgmt->readWorker);
+  dndCleanupWorker(&pMgmt->writeWorker);
+  dndCleanupWorker(&pMgmt->syncWorker);
 }
 
 static bool dndNeedDeployMnode(SDnode *pDnode) {
@@ -383,28 +337,21 @@ static int32_t dndOpenMnode(SDnode *pDnode, SMnodeOpt *pOption) {
     dError("failed to open mnode since %s", terrstr());
     return -1;
   }
-  pMgmt->deployed = 1;
 
-  int32_t code = dndWriteMnodeFile(pDnode);
-  if (code != 0) {
-    dError("failed to write mnode file since %s", terrstr());
-    code = terrno;
-    pMgmt->deployed = 0;
+  if (dndStartMnodeWorker(pDnode) != 0) {
+    dError("failed to start mnode worker since %s", terrstr());
     mndClose(pMnode);
     mndDestroy(pDnode->dir.mnode);
-    terrno = code;
     return -1;
   }
 
-  code = dndStartMnodeWorker(pDnode);
-  if (code != 0) {
-    dError("failed to start mnode worker since %s", terrstr());
-    code = terrno;
+  pMgmt->deployed = 1;
+  if (dndWriteMnodeFile(pDnode) != 0) {
+    dError("failed to write mnode file since %s", terrstr());
     pMgmt->deployed = 0;
     dndStopMnodeWorker(pDnode);
     mndClose(pMnode);
     mndDestroy(pDnode->dir.mnode);
-    terrno = code;
     return -1;
   }
 
@@ -461,6 +408,7 @@ static int32_t dndDropMnode(SDnode *pDnode) {
 
   dndReleaseMnode(pDnode, pMnode);
   dndStopMnodeWorker(pDnode);
+  pMgmt->deployed = 0;
   dndWriteMnodeFile(pDnode);
   mndClose(pMnode);
   pMgmt->pMnode = NULL;
@@ -528,13 +476,12 @@ int32_t dndProcessDropMnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
   }
 }
 
-
-static void dndProcessMnodeReadQueue(SDnode *pDnode, SMnodeMsg *pMsg) {
+static void dndProcessMnodeQueue(SDnode *pDnode, SMnodeMsg *pMsg) {
   SMnodeMgmt *pMgmt = &pDnode->mmgmt;
 
   SMnode *pMnode = dndAcquireMnode(pDnode);
   if (pMnode != NULL) {
-    mndProcessReadMsg(pMsg);
+    mndProcessMsg(pMsg);
     dndReleaseMnode(pDnode, pMnode);
   } else {
     mndSendRsp(pMsg, terrno);
@@ -543,208 +490,43 @@ static void dndProcessMnodeReadQueue(SDnode *pDnode, SMnodeMsg *pMsg) {
   mndCleanupMsg(pMsg);
 }
 
-static void dndProcessMnodeWriteQueue(SDnode *pDnode, SMnodeMsg *pMsg) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
+static void dndWriteMnodeMsgToWorker(SDnode *pDnode, SDnodeWorker *pWorker, SRpcMsg *pRpcMsg) {
+  int32_t code = TSDB_CODE_DND_MNODE_NOT_DEPLOYED;
 
   SMnode *pMnode = dndAcquireMnode(pDnode);
   if (pMnode != NULL) {
-    mndProcessWriteMsg(pMsg);
-    dndReleaseMnode(pDnode, pMnode);
-  } else {
-    mndSendRsp(pMsg, terrno);
-  }
-
-  mndCleanupMsg(pMsg);
-}
-
-static void dndProcessMnodeSyncQueue(SDnode *pDnode, SMnodeMsg *pMsg) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-
-  SMnode *pMnode = dndAcquireMnode(pDnode);
-  if (pMnode != NULL) {
-    mndProcessSyncMsg(pMsg);
-    dndReleaseMnode(pDnode, pMnode);
-  } else {
-    mndSendRsp(pMsg, terrno);
-  }
-
-  mndCleanupMsg(pMsg);
-}
-
-static int32_t dndWriteMnodeMsgToQueue(SMnode *pMnode, taos_queue pQueue, SRpcMsg *pRpcMsg) {
-  SMnodeMsg *pMsg = mndInitMsg(pMnode, pRpcMsg);
-  if (pMsg == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  if (taosWriteQitem(pQueue, pMsg) != 0) {
-    mndCleanupMsg(pMsg);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  return 0;
-}
-
-void dndProcessMnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  SMnode     *pMnode = dndAcquireMnode(pDnode);
-  if (pMnode == NULL || dndWriteMnodeMsgToQueue(pMnode, pMgmt->pWriteQ, pMsg) != 0) {
-    if (pMsg->msgType & 1u) {
-      SRpcMsg rsp = {.handle = pMsg->handle, .code = terrno};
-      rpcSendResponse(&rsp);
+    SMnodeMsg *pMsg = mndInitMsg(pMnode, pRpcMsg);
+    if (pMsg == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+    } else {
+      code = dndWriteMsgToWorker(pWorker, pMsg, 0);
     }
-    rpcFreeCont(pMsg->pCont);
-    pMsg->pCont = NULL;
-  }
 
-  dndReleaseMnode(pDnode, pMnode);
-}
-
-void dndProcessMnodeSyncMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  SMnode     *pMnode = dndAcquireMnode(pDnode);
-  if (pMnode == NULL || dndWriteMnodeMsgToQueue(pMnode, pMgmt->pSyncQ, pMsg) != 0) {
-    if (pMsg->msgType & 1u) {
-      SRpcMsg rsp = {.handle = pMsg->handle, .code = terrno};
-      rpcSendResponse(&rsp);
+    if (code != 0) {
+      mndCleanupMsg(pMsg);
     }
-    rpcFreeCont(pMsg->pCont);
-    pMsg->pCont = NULL;
   }
-
   dndReleaseMnode(pDnode, pMnode);
-}
 
-void dndProcessMnodeReadMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  SMnode     *pMnode = dndAcquireMnode(pDnode);
-  if (pMnode == NULL || dndWriteMnodeMsgToQueue(pMnode, pMgmt->pReadQ, pMsg) != 0) {
-    if (pMsg->msgType & 1u) {
-      SRpcMsg rsp = {.handle = pMsg->handle, .code = terrno};
+  if (code != 0) {
+    if (pRpcMsg->msgType & 1u) {
+      SRpcMsg rsp = {.handle = pRpcMsg->handle, .ahandle = pRpcMsg->ahandle, .code = code};
       rpcSendResponse(&rsp);
     }
-    rpcFreeCont(pMsg->pCont);
-    pMsg->pCont = NULL;
-  }
-
-  dndReleaseMnode(pDnode, pMnode);
-}
-
-
-static int32_t dndAllocMnodeReadQueue(SDnode *pDnode) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  pMgmt->pReadQ = tWorkerAllocQueue(&pMgmt->readPool, pDnode, (FProcessItem)dndProcessMnodeReadQueue);
-  if (pMgmt->pReadQ == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  return 0;
-}
-
-static void dndFreeMnodeReadQueue(SDnode *pDnode) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  tWorkerFreeQueue(&pMgmt->readPool, pMgmt->pReadQ);
-  pMgmt->pReadQ = NULL;
-}
-
-static int32_t dndInitMnodeReadWorker(SDnode *pDnode) {
-  SMnodeMgmt  *pMgmt = &pDnode->mmgmt;
-  SWorkerPool *pPool = &pMgmt->readPool;
-  pPool->name = "mnode-read";
-  pPool->min = 0;
-  pPool->max = 1;
-  if (tWorkerInit(pPool) != 0) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  dDebug("mnode read worker is initialized");
-  return 0;
-}
-
-static void dndCleanupMnodeReadWorker(SDnode *pDnode) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  tWorkerCleanup(&pMgmt->readPool);
-  dDebug("mnode read worker is closed");
-}
-
-static int32_t dndAllocMnodeWriteQueue(SDnode *pDnode) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  pMgmt->pWriteQ = tWorkerAllocQueue(&pMgmt->writePool, pDnode, (FProcessItem)dndProcessMnodeWriteQueue);
-  if (pMgmt->pWriteQ == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  return 0;
-}
-
-static void dndFreeMnodeWriteQueue(SDnode *pDnode) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  tWorkerFreeQueue(&pMgmt->writePool, pMgmt->pWriteQ);
-  pMgmt->pWriteQ = NULL;
-}
-
-static int32_t dndInitMnodeWriteWorker(SDnode *pDnode) {
-  SMnodeMgmt  *pMgmt = &pDnode->mmgmt;
-  SWorkerPool *pPool = &pMgmt->writePool;
-  pPool->name = "mnode-write";
-  pPool->min = 0;
-  pPool->max = 1;
-  if (tWorkerInit(pPool) != 0) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    rpcFreeCont(pRpcMsg->pCont);
   }
-
-  dDebug("mnode write worker is initialized");
-  return 0;
-}
-
-static void dndCleanupMnodeWriteWorker(SDnode *pDnode) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  tWorkerCleanup(&pMgmt->writePool);
-  dDebug("mnode write worker is closed");
-}
-
-static int32_t dndAllocMnodeSyncQueue(SDnode *pDnode) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  pMgmt->pSyncQ = tWorkerAllocQueue(&pMgmt->syncPool, pDnode, (FProcessItem)dndProcessMnodeSyncQueue);
-  if (pMgmt->pSyncQ == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  return 0;
 }
 
-static void dndFreeMnodeSyncQueue(SDnode *pDnode) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  tWorkerFreeQueue(&pMgmt->syncPool, pMgmt->pSyncQ);
-  pMgmt->pSyncQ = NULL;
+void dndProcessMnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
+  dndWriteMnodeMsgToWorker(pDnode, &pDnode->mmgmt.writeWorker, pMsg);
 }
 
-static int32_t dndInitMnodeSyncWorker(SDnode *pDnode) {
-  SMnodeMgmt  *pMgmt = &pDnode->mmgmt;
-  SWorkerPool *pPool = &pMgmt->syncPool;
-  pPool->name = "mnode-sync";
-  pPool->min = 0;
-  pPool->max = 1;
-  if (tWorkerInit(pPool) != 0) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  dDebug("mnode sync worker is initialized");
-  return 0;
+void dndProcessMnodeSyncMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
+  dndWriteMnodeMsgToWorker(pDnode, &pDnode->mmgmt.syncWorker, pMsg);
 }
 
-static void dndCleanupMnodeSyncWorker(SDnode *pDnode) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-  tWorkerCleanup(&pMgmt->syncPool);
-  dDebug("mnode sync worker is closed");
+void dndProcessMnodeReadMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
+  dndWriteMnodeMsgToWorker(pDnode, &pDnode->mmgmt.readWorker, pMsg);
 }
 
 int32_t dndInitMnode(SDnode *pDnode) {
@@ -752,14 +534,6 @@ int32_t dndInitMnode(SDnode *pDnode) {
   SMnodeMgmt *pMgmt = &pDnode->mmgmt;
   taosInitRWLatch(&pMgmt->latch);
 
-  char path[PATH_MAX];
-  snprintf(path, PATH_MAX, "%s/mnode.json", pDnode->dir.dnode);
-  pMgmt->file = strdup(path);
-  if (pMgmt->file == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
   if (dndReadMnodeFile(pDnode) != 0) {
     return -1;
   }
@@ -790,12 +564,13 @@ int32_t dndInitMnode(SDnode *pDnode) {
 }
 
 void dndCleanupMnode(SDnode *pDnode) {
-  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
-
   dInfo("dnode-mnode start to clean up");
-  if (pMgmt->pMnode) dndStopMnodeWorker(pDnode);
-  tfree(pMgmt->file);
-  mndClose(pMgmt->pMnode);
+  SMnodeMgmt *pMgmt = &pDnode->mmgmt;
+  if (pMgmt->pMnode) {
+    dndStopMnodeWorker(pDnode);
+    mndClose(pMgmt->pMnode);
+    pMgmt->pMnode = NULL;
+  }
   dInfo("dnode-mnode is cleaned up");
 }
 

source/dnode/mgmt/impl/src/dndQnode.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 "dndQnode.h"
+#include "dndDnode.h"
+#include "dndTransport.h"
+#include "dndWorker.h"
+
+static void dndProcessQnodeQueue(SDnode *pDnode, SRpcMsg *pMsg);
+
+static SQnode *dndAcquireQnode(SDnode *pDnode) {
+  SQnodeMgmt *pMgmt = &pDnode->qmgmt;
+  SQnode     *pQnode = NULL;
+  int32_t     refCount = 0;
+
+  taosRLockLatch(&pMgmt->latch);
+  if (pMgmt->deployed && !pMgmt->dropped) {
+    refCount = atomic_add_fetch_32(&pMgmt->refCount, 1);
+    pQnode = pMgmt->pQnode;
+  } else {
+    terrno = TSDB_CODE_DND_QNODE_NOT_DEPLOYED;
+  }
+  taosRUnLockLatch(&pMgmt->latch);
+
+  if (pQnode != NULL) {
+    dTrace("acquire qnode, refCount:%d", refCount);
+  }
+  return pQnode;
+}
+
+static void dndReleaseQnode(SDnode *pDnode, SQnode *pQnode) {
+  SQnodeMgmt *pMgmt = &pDnode->qmgmt;
+  int32_t     refCount = 0;
+
+  taosRLockLatch(&pMgmt->latch);
+  if (pQnode != NULL) {
+    refCount = atomic_sub_fetch_32(&pMgmt->refCount, 1);
+  }
+  taosRUnLockLatch(&pMgmt->latch);
+
+  if (pQnode != NULL) {
+    dTrace("release qnode, refCount:%d", refCount);
+  }
+}
+
+static int32_t dndReadQnodeFile(SDnode *pDnode) {
+  SQnodeMgmt *pMgmt = &pDnode->qmgmt;
+  int32_t     code = TSDB_CODE_DND_QNODE_READ_FILE_ERROR;
+  int32_t     len = 0;
+  int32_t     maxLen = 4096;
+  char       *content = calloc(1, maxLen + 1);
+  cJSON      *root = NULL;
+
+  char file[PATH_MAX + 20];
+  snprintf(file, PATH_MAX + 20, "%s/qnode.json", pDnode->dir.dnode);
+
+  FILE *fp = fopen(file, "r");
+  if (fp == NULL) {
+    dDebug("file %s not exist", file);
+    code = 0;
+    goto PRASE_QNODE_OVER;
+  }
+
+  len = (int32_t)fread(content, 1, maxLen, fp);
+  if (len <= 0) {
+    dError("failed to read %s since content is null", file);
+    goto PRASE_QNODE_OVER;
+  }
+
+  content[len] = 0;
+  root = cJSON_Parse(content);
+  if (root == NULL) {
+    dError("failed to read %s since invalid json format", file);
+    goto PRASE_QNODE_OVER;
+  }
+
+  cJSON *deployed = cJSON_GetObjectItem(root, "deployed");
+  if (!deployed || deployed->type != cJSON_Number) {
+    dError("failed to read %s since deployed not found", file);
+    goto PRASE_QNODE_OVER;
+  }
+  pMgmt->deployed = deployed->valueint;
+
+  cJSON *dropped = cJSON_GetObjectItem(root, "dropped");
+  if (!dropped || dropped->type != cJSON_Number) {
+    dError("failed to read %s since dropped not found", file);
+    goto PRASE_QNODE_OVER;
+  }
+  pMgmt->dropped = dropped->valueint;
+
+  code = 0;
+  dDebug("succcessed to read file %s, deployed:%d dropped:%d", file, pMgmt->deployed, pMgmt->dropped);
+
+PRASE_QNODE_OVER:
+  if (content != NULL) free(content);
+  if (root != NULL) cJSON_Delete(root);
+  if (fp != NULL) fclose(fp);
+
+  terrno = code;
+  return code;
+}
+
+static int32_t dndWriteQnodeFile(SDnode *pDnode) {
+  SQnodeMgmt *pMgmt = &pDnode->qmgmt;
+
+  char file[PATH_MAX + 20];
+  snprintf(file, PATH_MAX + 20, "%s/qnode.json", pDnode->dir.dnode);
+
+  FILE *fp = fopen(file, "w");
+  if (fp == NULL) {
+    terrno = TSDB_CODE_DND_QNODE_WRITE_FILE_ERROR;
+    dError("failed to write %s since %s", file, terrstr());
+    return -1;
+  }
+
+  int32_t len = 0;
+  int32_t maxLen = 4096;
+  char   *content = calloc(1, maxLen + 1);
+
+  len += snprintf(content + len, maxLen - len, "{\n");
+  len += snprintf(content + len, maxLen - len, "  \"deployed\": %d,\n", pMgmt->deployed);
+  len += snprintf(content + len, maxLen - len, "  \"dropped\": %d\n", pMgmt->dropped);
+  len += snprintf(content + len, maxLen - len, "}\n");
+
+  fwrite(content, 1, len, fp);
+  taosFsyncFile(fileno(fp));
+  fclose(fp);
+  free(content);
+
+  char realfile[PATH_MAX + 20];
+  snprintf(realfile, PATH_MAX + 20, "%s/qnode.json", pDnode->dir.dnode);
+
+  if (taosRenameFile(file, realfile) != 0) {
+    terrno = TSDB_CODE_DND_QNODE_WRITE_FILE_ERROR;
+    dError("failed to rename %s since %s", file, terrstr());
+    return -1;
+  }
+
+  dInfo("successed to write %s, deployed:%d dropped:%d", realfile, pMgmt->deployed, pMgmt->dropped);
+  return 0;
+}
+
+static int32_t dndStartQnodeWorker(SDnode *pDnode) {
+  SQnodeMgmt *pMgmt = &pDnode->qmgmt;
+  if (dndInitWorker(pDnode, &pMgmt->queryWorker, DND_WORKER_SINGLE, "qnode-query", 0, 1, dndProcessQnodeQueue) != 0) {
+    dError("failed to start qnode query worker since %s", terrstr());
+    return -1;
+  }
+
+  if (dndInitWorker(pDnode, &pMgmt->fetchWorker, DND_WORKER_SINGLE, "qnode-fetch", 0, 1, dndProcessQnodeQueue) != 0) {
+    dError("failed to start qnode fetch worker since %s", terrstr());
+    return -1;
+  }
+
+  return 0;
+}
+
+static void dndStopQnodeWorker(SDnode *pDnode) {
+  SQnodeMgmt *pMgmt = &pDnode->qmgmt;
+
+  taosWLockLatch(&pMgmt->latch);
+  pMgmt->deployed = 0;
+  taosWUnLockLatch(&pMgmt->latch);
+
+  while (pMgmt->refCount > 1) {
+    taosMsleep(10);
+  }
+
+  dndCleanupWorker(&pMgmt->queryWorker);
+  dndCleanupWorker(&pMgmt->fetchWorker);
+}
+
+static void dndBuildQnodeOption(SDnode *pDnode, SQnodeOpt *pOption) {
+  pOption->pDnode = pDnode;
+  pOption->sendMsgToDnodeFp = dndSendMsgToDnode;
+  pOption->sendMsgToMnodeFp = dndSendMsgToMnode;
+  pOption->sendRedirectMsgFp = dndSendRedirectMsg;
+  pOption->dnodeId = dndGetDnodeId(pDnode);
+  pOption->clusterId = dndGetClusterId(pDnode);
+  pOption->cfg.sver = pDnode->opt.sver;
+}
+
+static int32_t dndOpenQnode(SDnode *pDnode) {
+  SQnodeMgmt *pMgmt = &pDnode->qmgmt;
+  SQnodeOpt   option = {0};
+  dndBuildQnodeOption(pDnode, &option);
+
+  SQnode *pQnode = qndOpen(&option);
+  if (pQnode == NULL) {
+    dError("failed to open qnode since %s", terrstr());
+    return -1;
+  }
+
+  if (dndStartQnodeWorker(pDnode) != 0) {
+    dError("failed to start qnode worker since %s", terrstr());
+    qndClose(pQnode);
+    return -1;
+  }
+
+  pMgmt->deployed = 1;
+  if (dndWriteQnodeFile(pDnode) != 0) {
+    pMgmt->deployed = 0;
+    dError("failed to write qnode file since %s", terrstr());
+    dndStopQnodeWorker(pDnode);
+    qndClose(pQnode);
+    return -1;
+  }
+
+  taosWLockLatch(&pMgmt->latch);
+  pMgmt->pQnode = pQnode;
+  taosWUnLockLatch(&pMgmt->latch);
+
+  dInfo("qnode open successfully");
+  return 0;
+}
+
+static int32_t dndDropQnode(SDnode *pDnode) {
+  SQnodeMgmt *pMgmt = &pDnode->qmgmt;
+
+  SQnode *pQnode = dndAcquireQnode(pDnode);
+  if (pQnode == NULL) {
+    dError("failed to drop qnode since %s", terrstr());
+    return -1;
+  }
+
+  taosRLockLatch(&pMgmt->latch);
+  pMgmt->dropped = 1;
+  taosRUnLockLatch(&pMgmt->latch);
+
+  if (dndWriteQnodeFile(pDnode) != 0) {
+    taosRLockLatch(&pMgmt->latch);
+    pMgmt->dropped = 0;
+    taosRUnLockLatch(&pMgmt->latch);
+
+    dndReleaseQnode(pDnode, pQnode);
+    dError("failed to drop qnode since %s", terrstr());
+    return -1;
+  }
+
+  dndReleaseQnode(pDnode, pQnode);
+  dndStopQnodeWorker(pDnode);
+  pMgmt->deployed = 0;
+  dndWriteQnodeFile(pDnode);
+  qndClose(pQnode);
+  pMgmt->pQnode = NULL;
+
+  return 0;
+}
+
+int32_t dndProcessCreateQnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
+  SCreateQnodeInMsg *pMsg = pRpcMsg->pCont;
+  pMsg->dnodeId = htonl(pMsg->dnodeId);
+
+  if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
+    terrno = TSDB_CODE_DND_QNODE_ID_INVALID;
+    return -1;
+  } else {
+    return dndOpenQnode(pDnode);
+  }
+}
+
+int32_t dndProcessDropQnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
+  SDropQnodeInMsg *pMsg = pRpcMsg->pCont;
+  pMsg->dnodeId = htonl(pMsg->dnodeId);
+
+  if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
+    terrno = TSDB_CODE_DND_QNODE_ID_INVALID;
+    return -1;
+  } else {
+    return dndDropQnode(pDnode);
+  }
+}
+
+static void dndProcessQnodeQueue(SDnode *pDnode, SRpcMsg *pMsg) {
+  SQnodeMgmt *pMgmt = &pDnode->qmgmt;
+  SRpcMsg    *pRsp = NULL;
+  int32_t     code = TSDB_CODE_DND_QNODE_NOT_DEPLOYED;
+
+  SQnode *pQnode = dndAcquireQnode(pDnode);
+  if (pQnode != NULL) {
+    code = qndProcessMsg(pQnode, pMsg, &pRsp);
+  }
+
+  if (pRsp != NULL) {
+    pRsp->ahandle = pMsg->ahandle;
+    rpcSendResponse(pRsp);
+    free(pRsp);
+  } else {
+    if (code != 0) code = terrno;
+    SRpcMsg rpcRsp = {.handle = pMsg->handle, .ahandle = pMsg->ahandle, .code = code};
+    rpcSendResponse(&rpcRsp);
+  }
+
+  rpcFreeCont(pMsg->pCont);
+  taosFreeQitem(pMsg);
+}
+
+static void dndWriteQnodeMsgToWorker(SDnode *pDnode, SDnodeWorker *pWorker, SRpcMsg *pMsg) {
+  int32_t code = TSDB_CODE_DND_QNODE_NOT_DEPLOYED;
+
+  SQnode *pQnode = dndAcquireQnode(pDnode);
+  if (pQnode != NULL) {
+    code = dndWriteMsgToWorker(pWorker, pMsg, sizeof(SRpcMsg));
+  }
+  dndReleaseQnode(pDnode, pQnode);
+
+  if (code != 0) {
+    if (pMsg->msgType & 1u) {
+      SRpcMsg rsp = {.handle = pMsg->handle, .ahandle = pMsg->ahandle, .code = code};
+      rpcSendResponse(&rsp);
+    }
+    rpcFreeCont(pMsg->pCont);
+  }
+}
+
+void dndProcessQnodeQueryMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
+  dndWriteQnodeMsgToWorker(pDnode, &pDnode->qmgmt.queryWorker, pMsg);
+}
+
+void dndProcessQnodeFetchMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
+  dndWriteQnodeMsgToWorker(pDnode, &pDnode->qmgmt.queryWorker, pMsg);
+}
+
+int32_t dndInitQnode(SDnode *pDnode) {
+  SQnodeMgmt *pMgmt = &pDnode->qmgmt;
+  taosInitRWLatch(&pMgmt->latch);
+
+  if (dndReadQnodeFile(pDnode) != 0) {
+    return -1;
+  }
+
+  if (pMgmt->dropped) return 0;
+  if (!pMgmt->deployed) return 0;
+
+  return dndOpenQnode(pDnode);
+}
+
+void dndCleanupQnode(SDnode *pDnode) {
+  SQnodeMgmt *pMgmt = &pDnode->qmgmt;
+  if (pMgmt->pQnode) {
+    dndStopQnodeWorker(pDnode);
+    qndClose(pMgmt->pQnode);
+    pMgmt->pQnode = NULL;
+  }
+}

source/dnode/mgmt/impl/src/dndSnode.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 "dndSnode.h"
+#include "dndDnode.h"
+#include "dndTransport.h"
+#include "dndWorker.h"
+
+static void dndProcessSnodeQueue(SDnode *pDnode, SRpcMsg *pMsg);
+
+static SSnode *dndAcquireSnode(SDnode *pDnode) {
+  SSnodeMgmt *pMgmt = &pDnode->smgmt;
+  SSnode     *pSnode = NULL;
+  int32_t     refCount = 0;
+
+  taosRLockLatch(&pMgmt->latch);
+  if (pMgmt->deployed && !pMgmt->dropped) {
+    refCount = atomic_add_fetch_32(&pMgmt->refCount, 1);
+    pSnode = pMgmt->pSnode;
+  } else {
+    terrno = TSDB_CODE_DND_SNODE_NOT_DEPLOYED;
+  }
+  taosRUnLockLatch(&pMgmt->latch);
+
+  if (pSnode != NULL) {
+    dTrace("acquire snode, refCount:%d", refCount);
+  }
+  return pSnode;
+}
+
+static void dndReleaseSnode(SDnode *pDnode, SSnode *pSnode) {
+  SSnodeMgmt *pMgmt = &pDnode->smgmt;
+  int32_t     refCount = 0;
+
+  taosRLockLatch(&pMgmt->latch);
+  if (pSnode != NULL) {
+    refCount = atomic_sub_fetch_32(&pMgmt->refCount, 1);
+  }
+  taosRUnLockLatch(&pMgmt->latch);
+
+  if (pSnode != NULL) {
+    dTrace("release snode, refCount:%d", refCount);
+  }
+}
+
+static int32_t dndReadSnodeFile(SDnode *pDnode) {
+  SSnodeMgmt *pMgmt = &pDnode->smgmt;
+  int32_t     code = TSDB_CODE_DND_SNODE_READ_FILE_ERROR;
+  int32_t     len = 0;
+  int32_t     maxLen = 4096;
+  char       *content = calloc(1, maxLen + 1);
+  cJSON      *root = NULL;
+
+  char file[PATH_MAX + 20];
+  snprintf(file, PATH_MAX + 20, "%s/snode.json", pDnode->dir.dnode);
+
+  FILE *fp = fopen(file, "r");
+  if (fp == NULL) {
+    dDebug("file %s not exist", file);
+    code = 0;
+    goto PRASE_SNODE_OVER;
+  }
+
+  len = (int32_t)fread(content, 1, maxLen, fp);
+  if (len <= 0) {
+    dError("failed to read %s since content is null", file);
+    goto PRASE_SNODE_OVER;
+  }
+
+  content[len] = 0;
+  root = cJSON_Parse(content);
+  if (root == NULL) {
+    dError("failed to read %s since invalid json format", file);
+    goto PRASE_SNODE_OVER;
+  }
+
+  cJSON *deployed = cJSON_GetObjectItem(root, "deployed");
+  if (!deployed || deployed->type != cJSON_Number) {
+    dError("failed to read %s since deployed not found", file);
+    goto PRASE_SNODE_OVER;
+  }
+  pMgmt->deployed = deployed->valueint;
+
+  cJSON *dropped = cJSON_GetObjectItem(root, "dropped");
+  if (!dropped || dropped->type != cJSON_Number) {
+    dError("failed to read %s since dropped not found", file);
+    goto PRASE_SNODE_OVER;
+  }
+  pMgmt->dropped = dropped->valueint;
+
+  code = 0;
+  dDebug("succcessed to read file %s, deployed:%d dropped:%d", file, pMgmt->deployed, pMgmt->dropped);
+
+PRASE_SNODE_OVER:
+  if (content != NULL) free(content);
+  if (root != NULL) cJSON_Delete(root);
+  if (fp != NULL) fclose(fp);
+
+  terrno = code;
+  return code;
+}
+
+static int32_t dndWriteSnodeFile(SDnode *pDnode) {
+  SSnodeMgmt *pMgmt = &pDnode->smgmt;
+
+  char file[PATH_MAX + 20];
+  snprintf(file, PATH_MAX + 20, "%s/snode.json", pDnode->dir.dnode);
+
+  FILE *fp = fopen(file, "w");
+  if (fp == NULL) {
+    terrno = TSDB_CODE_DND_SNODE_WRITE_FILE_ERROR;
+    dError("failed to write %s since %s", file, terrstr());
+    return -1;
+  }
+
+  int32_t len = 0;
+  int32_t maxLen = 4096;
+  char   *content = calloc(1, maxLen + 1);
+
+  len += snprintf(content + len, maxLen - len, "{\n");
+  len += snprintf(content + len, maxLen - len, "  \"deployed\": %d,\n", pMgmt->deployed);
+  len += snprintf(content + len, maxLen - len, "  \"dropped\": %d\n", pMgmt->dropped);
+  len += snprintf(content + len, maxLen - len, "}\n");
+
+  fwrite(content, 1, len, fp);
+  taosFsyncFile(fileno(fp));
+  fclose(fp);
+  free(content);
+
+  char realfile[PATH_MAX + 20];
+  snprintf(realfile, PATH_MAX + 20, "%s/snode.json", pDnode->dir.dnode);
+
+  if (taosRenameFile(file, realfile) != 0) {
+    terrno = TSDB_CODE_DND_SNODE_WRITE_FILE_ERROR;
+    dError("failed to rename %s since %s", file, terrstr());
+    return -1;
+  }
+
+  dInfo("successed to write %s, deployed:%d dropped:%d", realfile, pMgmt->deployed, pMgmt->dropped);
+  return 0;
+}
+
+static int32_t dndStartSnodeWorker(SDnode *pDnode) {
+  SSnodeMgmt *pMgmt = &pDnode->smgmt;
+  if (dndInitWorker(pDnode, &pMgmt->writeWorker, DND_WORKER_SINGLE, "snode-write", 0, 1, dndProcessSnodeQueue) != 0) {
+    dError("failed to start snode write worker since %s", terrstr());
+    return -1;
+  }
+
+  return 0;
+}
+
+static void dndStopSnodeWorker(SDnode *pDnode) {
+  SSnodeMgmt *pMgmt = &pDnode->smgmt;
+
+  taosWLockLatch(&pMgmt->latch);
+  pMgmt->deployed = 0;
+  taosWUnLockLatch(&pMgmt->latch);
+
+  while (pMgmt->refCount > 1) {
+    taosMsleep(10);
+  }
+
+  dndCleanupWorker(&pMgmt->writeWorker);
+}
+
+static void dndBuildSnodeOption(SDnode *pDnode, SSnodeOpt *pOption) {
+  pOption->pDnode = pDnode;
+  pOption->sendMsgToDnodeFp = dndSendMsgToDnode;
+  pOption->sendMsgToMnodeFp = dndSendMsgToMnode;
+  pOption->sendRedirectMsgFp = dndSendRedirectMsg;
+  pOption->dnodeId = dndGetDnodeId(pDnode);
+  pOption->clusterId = dndGetClusterId(pDnode);
+  pOption->cfg.sver = pDnode->opt.sver;
+}
+
+static int32_t dndOpenSnode(SDnode *pDnode) {
+  SSnodeMgmt *pMgmt = &pDnode->smgmt;
+  SSnodeOpt   option = {0};
+  dndBuildSnodeOption(pDnode, &option);
+
+  SSnode *pSnode = sndOpen(pDnode->dir.snode, &option);
+  if (pSnode == NULL) {
+    dError("failed to open snode since %s", terrstr());
+    return -1;
+  }
+
+  if (dndStartSnodeWorker(pDnode) != 0) {
+    dError("failed to start snode worker since %s", terrstr());
+    sndClose(pSnode);
+    return -1;
+  }
+
+  pMgmt->deployed = 1;
+  if (dndWriteSnodeFile(pDnode) != 0) {
+    pMgmt->deployed = 0;
+    dError("failed to write snode file since %s", terrstr());
+    dndStopSnodeWorker(pDnode);
+    sndClose(pSnode);
+    return -1;
+  }
+
+  taosWLockLatch(&pMgmt->latch);
+  pMgmt->pSnode = pSnode;
+  taosWUnLockLatch(&pMgmt->latch);
+
+  dInfo("snode open successfully");
+  return 0;
+}
+
+static int32_t dndDropSnode(SDnode *pDnode) {
+  SSnodeMgmt *pMgmt = &pDnode->smgmt;
+
+  SSnode *pSnode = dndAcquireSnode(pDnode);
+  if (pSnode == NULL) {
+    dError("failed to drop snode since %s", terrstr());
+    return -1;
+  }
+
+  taosRLockLatch(&pMgmt->latch);
+  pMgmt->dropped = 1;
+  taosRUnLockLatch(&pMgmt->latch);
+
+  if (dndWriteSnodeFile(pDnode) != 0) {
+    taosRLockLatch(&pMgmt->latch);
+    pMgmt->dropped = 0;
+    taosRUnLockLatch(&pMgmt->latch);
+
+    dndReleaseSnode(pDnode, pSnode);
+    dError("failed to drop snode since %s", terrstr());
+    return -1;
+  }
+
+  dndReleaseSnode(pDnode, pSnode);
+  dndStopSnodeWorker(pDnode);
+  pMgmt->deployed = 0;
+  dndWriteSnodeFile(pDnode);
+  sndClose(pSnode);
+  pMgmt->pSnode = NULL;
+  sndDestroy(pDnode->dir.snode);
+
+  return 0;
+}
+
+int32_t dndProcessCreateSnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
+  SCreateSnodeInMsg *pMsg = pRpcMsg->pCont;
+  pMsg->dnodeId = htonl(pMsg->dnodeId);
+
+  if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
+    terrno = TSDB_CODE_DND_SNODE_ID_INVALID;
+    return -1;
+  } else {
+    return dndOpenSnode(pDnode);
+  }
+}
+
+int32_t dndProcessDropSnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) {
+  SDropSnodeInMsg *pMsg = pRpcMsg->pCont;
+  pMsg->dnodeId = htonl(pMsg->dnodeId);
+
+  if (pMsg->dnodeId != dndGetDnodeId(pDnode)) {
+    terrno = TSDB_CODE_DND_SNODE_ID_INVALID;
+    return -1;
+  } else {
+    return dndDropSnode(pDnode);
+  }
+}
+
+static void dndProcessSnodeQueue(SDnode *pDnode, SRpcMsg *pMsg) {
+  SSnodeMgmt *pMgmt = &pDnode->smgmt;
+  SRpcMsg    *pRsp = NULL;
+  int32_t     code = TSDB_CODE_DND_SNODE_NOT_DEPLOYED;
+
+  SSnode *pSnode = dndAcquireSnode(pDnode);
+  if (pSnode != NULL) {
+    code = sndProcessMsg(pSnode, pMsg, &pRsp);
+  }
+
+  if (pRsp != NULL) {
+    pRsp->ahandle = pMsg->ahandle;
+    rpcSendResponse(pRsp);
+    free(pRsp);
+  } else {
+    if (code != 0) code = terrno;
+    SRpcMsg rpcRsp = {.handle = pMsg->handle, .ahandle = pMsg->ahandle, .code = code};
+    rpcSendResponse(&rpcRsp);
+  }
+
+  rpcFreeCont(pMsg->pCont);
+  taosFreeQitem(pMsg);
+}
+
+static void dndWriteSnodeMsgToWorker(SDnode *pDnode, SDnodeWorker *pWorker, SRpcMsg *pMsg) {
+  int32_t code = TSDB_CODE_DND_SNODE_NOT_DEPLOYED;
+
+  SSnode *pSnode = dndAcquireSnode(pDnode);
+  if (pSnode != NULL) {
+    code = dndWriteMsgToWorker(pWorker, pMsg, sizeof(SRpcMsg));
+  }
+  dndReleaseSnode(pDnode, pSnode);
+
+  if (code != 0) {
+    if (pMsg->msgType & 1u) {
+      SRpcMsg rsp = {.handle = pMsg->handle, .ahandle = pMsg->ahandle, .code = code};
+      rpcSendResponse(&rsp);
+    }
+    rpcFreeCont(pMsg->pCont);
+  }
+}
+
+void dndProcessSnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
+  dndWriteSnodeMsgToWorker(pDnode, &pDnode->smgmt.writeWorker, pMsg);
+}
+
+int32_t dndInitSnode(SDnode *pDnode) {
+  SSnodeMgmt *pMgmt = &pDnode->smgmt;
+  taosInitRWLatch(&pMgmt->latch);
+
+  if (dndReadSnodeFile(pDnode) != 0) {
+    return -1;
+  }
+
+  if (pMgmt->dropped) {
+    dInfo("snode has been deployed and needs to be deleted");
+    sndDestroy(pDnode->dir.snode);
+    return 0;
+  }
+
+  if (!pMgmt->deployed) return 0;
+
+  return dndOpenSnode(pDnode);
+}
+
+void dndCleanupSnode(SDnode *pDnode) {
+  SSnodeMgmt *pMgmt = &pDnode->smgmt;
+  if (pMgmt->pSnode) {
+    dndStopSnodeWorker(pDnode);
+    sndClose(pMgmt->pSnode);
+    pMgmt->pSnode = NULL;
+  }
+}

source/dnode/mgmt/impl/src/dndWorker.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 "dndWorker.h"
+
+int32_t dndInitWorker(SDnode *pDnode, SDnodeWorker *pWorker, EWorkerType type, const char *name, int32_t minNum,
+                      int32_t maxNum, void *queueFp) {
+  if (pDnode == NULL || pWorker == NULL || name == NULL || minNum < 0 || maxNum <= 0 || queueFp == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return -1;
+  }
+
+  pWorker->type = type;
+  pWorker->name = name;
+  pWorker->minNum = minNum;
+  pWorker->maxNum = maxNum;
+  pWorker->queueFp = queueFp;
+  pWorker->pDnode = pDnode;
+
+  if (pWorker->type == DND_WORKER_SINGLE) {
+    SWorkerPool *pPool = &pWorker->pool;
+    pPool->name = name;
+    pPool->min = minNum;
+    pPool->max = maxNum;
+    if (tWorkerInit(pPool) != 0) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+    pWorker->queue = tWorkerAllocQueue(pPool, pDnode, (FProcessItem)queueFp);
+    if (pWorker->queue == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+  } else if (pWorker->type == DND_WORKER_MULTI) {
+    SMWorkerPool *pPool = &pWorker->mpool;
+    pPool->name = name;
+    pPool->max = maxNum;
+    if (tMWorkerInit(pPool) != 0) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+    pWorker->queue = tMWorkerAllocQueue(pPool, pDnode, (FProcessItems)queueFp);
+    if (pWorker->queue == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+  } else {
+    terrno = TSDB_CODE_INVALID_PARA;
+  }
+
+  return 0;
+}
+
+void dndCleanupWorker(SDnodeWorker *pWorker) {
+  while (!taosQueueEmpty(pWorker->queue)) {
+    taosMsleep(10);
+  }
+
+  if (pWorker->type == DND_WORKER_SINGLE) {
+    tWorkerCleanup(&pWorker->pool);
+    tWorkerFreeQueue(&pWorker->pool, pWorker->queue);
+  } else if (pWorker->type == DND_WORKER_MULTI) {
+    tMWorkerCleanup(&pWorker->mpool);
+    tMWorkerFreeQueue(&pWorker->mpool, pWorker->queue);
+  } else {
+  }
+}
+
+int32_t dndWriteMsgToWorker(SDnodeWorker *pWorker, void *pCont, int32_t contLen) {
+  if (pWorker == NULL || pWorker->queue == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return -1;
+  }
+
+  void *pMsg = NULL;
+  if (contLen != 0) {
+    pMsg = taosAllocateQitem(contLen);
+    if (pMsg != NULL) {
+      memcpy(pMsg, pCont, contLen);
+    }
+  } else {
+    pMsg = pCont;
+  }
+
+  if (pMsg == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  if (taosWriteQitem(pWorker->queue, pMsg) != 0) {
+    taosFreeQitem(pMsg);
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  return 0;
+}
\ No newline at end of file

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

@@ -19,8 +19,6 @@
 #include "dndTransport.h"
 #include "dndVnodes.h"
 #include "sync.h"
-#include "tcache.h"
-#include "tcrc32c.h"
 #include "wal.h"
 
 EStat dndGetStat(SDnode *pDnode) { return pDnode->stat; }
@@ -86,12 +84,14 @@ static int32_t dndInitEnv(SDnode *pDnode, SDnodeOpt *pOption) {
   char path[PATH_MAX + 100];
   snprintf(path, sizeof(path), "%s%smnode", pOption->dataDir, TD_DIRSEP);
   pDnode->dir.mnode = tstrdup(path);
-
   snprintf(path, sizeof(path), "%s%svnode", pOption->dataDir, TD_DIRSEP);
   pDnode->dir.vnodes = tstrdup(path);
-
   snprintf(path, sizeof(path), "%s%sdnode", pOption->dataDir, TD_DIRSEP);
   pDnode->dir.dnode = tstrdup(path);
+  snprintf(path, sizeof(path), "%s%ssnode", pOption->dataDir, TD_DIRSEP);
+  pDnode->dir.snode = tstrdup(path);
+  snprintf(path, sizeof(path), "%s%sbnode", pOption->dataDir, TD_DIRSEP);
+  pDnode->dir.bnode = tstrdup(path);
 
   if (pDnode->dir.mnode == NULL || pDnode->dir.vnodes == NULL || pDnode->dir.dnode == NULL) {
     dError("failed to malloc dir object");
@@ -117,22 +117,28 @@ static int32_t dndInitEnv(SDnode *pDnode, SDnodeOpt *pOption) {
     return -1;
   }
 
+  if (taosMkDir(pDnode->dir.snode) != 0) {
+    dError("failed to create dir:%s since %s", pDnode->dir.snode, strerror(errno));
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    return -1;
+  }
+
+  if (taosMkDir(pDnode->dir.bnode) != 0) {
+    dError("failed to create dir:%s since %s", pDnode->dir.bnode, strerror(errno));
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    return -1;
+  }
+
   memcpy(&pDnode->opt, pOption, sizeof(SDnodeOpt));
   return 0;
 }
 
 static void dndCleanupEnv(SDnode *pDnode) {
-  if (pDnode->dir.mnode != NULL) {
-    tfree(pDnode->dir.mnode);
-  }
-
-  if (pDnode->dir.vnodes != NULL) {
-    tfree(pDnode->dir.vnodes);
-  }
-
-  if (pDnode->dir.dnode != NULL) {
-    tfree(pDnode->dir.dnode);
-  }
+  tfree(pDnode->dir.mnode);
+  tfree(pDnode->dir.vnodes);
+  tfree(pDnode->dir.dnode);
+  tfree(pDnode->dir.snode);
+  tfree(pDnode->dir.bnode);
 
   if (pDnode->lockFd >= 0) {
     taosUnLockFile(pDnode->lockFd);
@@ -176,7 +182,7 @@ SDnode *dndInit(SDnodeOpt *pOption) {
     return NULL;
   }
 
-  if (vnodeInit(1) != 0) {
+  if (vnodeInit(pDnode->opt.numOfCommitThreads) != 0) {
     dError("failed to init vnode env");
     dndCleanup(pDnode);
     return NULL;

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

@@ -91,7 +91,8 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
     int32_t contLen = sizeof(SCreateDnodeMsg);
 
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
-    strcpy(pReq->ep, "localhost:9042");
+    strcpy(pReq->fqdn, "localhost");
+    pReq->port = htonl(9042);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
@@ -148,7 +149,8 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
     int32_t contLen = sizeof(SCreateDnodeMsg);
 
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
-    strcpy(pReq->ep, "localhost:9043");
+    strcpy(pReq->fqdn, "localhost");
+    pReq->port = htonl(9043);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
@@ -159,7 +161,8 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
     int32_t contLen = sizeof(SCreateDnodeMsg);
 
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
-    strcpy(pReq->ep, "localhost:9044");
+    strcpy(pReq->fqdn, "localhost");
+    pReq->port = htonl(9044);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);
@@ -170,7 +173,8 @@ TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
     int32_t contLen = sizeof(SCreateDnodeMsg);
 
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
-    strcpy(pReq->ep, "localhost:9045");
+    strcpy(pReq->fqdn, "localhost");
+    pReq->port = htonl(9045);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);

source/dnode/mgmt/impl/test/mnode/mnode.cpp

@@ -102,7 +102,8 @@ TEST_F(DndTestMnode, 04_Create_Mnode) {
     int32_t contLen = sizeof(SCreateDnodeMsg);
 
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen);
-    strcpy(pReq->ep, "localhost:9062");
+    strcpy(pReq->fqdn, "localhost");
+    pReq->port = htonl(9062);
 
     SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_DNODE, pReq, contLen);
     ASSERT_NE(pMsg, nullptr);

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

@@ -31,6 +31,7 @@ void Testbase::InitLog(const char* path) {
   tsdbDebugFlag = 0;
   cqDebugFlag = 0;
   tscEmbeddedInUtil = 1;
+  tsAsyncLog = 0;
 
   taosRemoveDir(path);
   taosMkDir(path);
@@ -47,7 +48,7 @@ void Testbase::Init(const char* path, int16_t port) {
   char firstEp[TSDB_EP_LEN] = {0};
   snprintf(firstEp, TSDB_EP_LEN, "%s:%u", fqdn, port);
 
-  InitLog("/tmp/tdlog");
+  InitLog("/tmp/td");
   server.Start(path, fqdn, port, firstEp);
   client.Init("root", "taosdata", fqdn, port);
   taosMsleep(1100);

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

@@ -27,6 +27,7 @@ SDnodeOpt TestServer::BuildOption(const char* path, const char* fqdn, uint16_t p
   option.sver = 1;
   option.numOfCores = 1;
   option.numOfSupportVnodes = 1;
+  option.numOfCommitThreads = 1;
   option.statusInterval = 1;
   option.numOfThreadsPerCore = 1;
   option.ratioOfQueryCores = 1;

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

@@ -386,20 +386,16 @@ static int32_t mndCreateDnode(SMnode *pMnode, SMnodeMsg *pMsg, SCreateDnodeMsg *
   dnodeObj.id = sdbGetMaxId(pMnode->pSdb, SDB_DNODE);
   dnodeObj.createdTime = taosGetTimestampMs();
   dnodeObj.updateTime = dnodeObj.createdTime;
-  taosGetFqdnPortFromEp(pCreate->ep, dnodeObj.fqdn, &dnodeObj.port);
-
-  if (dnodeObj.fqdn[0] == 0 || dnodeObj.port <= 0) {
-    terrno = TSDB_CODE_MND_INVALID_DNODE_EP;
-    mError("dnode:%s, failed to create since %s", pCreate->ep, terrstr());
-    return terrno;
-  }
+  dnodeObj.port = pCreate->port;
+  memcpy(dnodeObj.fqdn, pCreate->fqdn, TSDB_FQDN_LEN);
+  snprintf(dnodeObj.ep, TSDB_EP_LEN, "%s:%u", dnodeObj.fqdn, dnodeObj.port);
 
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, &pMsg->rpcMsg);
   if (pTrans == NULL) {
-    mError("dnode:%s, failed to create since %s", pCreate->ep, terrstr());
+    mError("dnode:%s, failed to create since %s", dnodeObj.ep, terrstr());
     return -1;
   }
-  mDebug("trans:%d, used to create dnode:%s", pTrans->id, pCreate->ep);
+  mDebug("trans:%d, used to create dnode:%s", pTrans->id, dnodeObj.ep);
 
   SSdbRaw *pRedoRaw = mndDnodeActionEncode(&dnodeObj);
   if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
@@ -423,17 +419,20 @@ static int32_t mndProcessCreateDnodeMsg(SMnodeMsg *pMsg) {
   SMnode          *pMnode = pMsg->pMnode;
   SCreateDnodeMsg *pCreate = pMsg->rpcMsg.pCont;
 
-  mDebug("dnode:%s, start to create", pCreate->ep);
+  mDebug("dnode:%s:%d, start to create", pCreate->fqdn, pCreate->port);
 
-  if (pCreate->ep[0] == 0) {
+  pCreate->port = htonl(pCreate->port);
+  if (pCreate->fqdn[0] == 0 || pCreate->port <= 0 || pCreate->port > UINT16_MAX) {
     terrno = TSDB_CODE_MND_INVALID_DNODE_EP;
-    mError("dnode:%s, failed to create since %s", pCreate->ep, terrstr());
+    mError("dnode:%s:%d, failed to create since %s", pCreate->fqdn, pCreate->port, terrstr());
     return -1;
   }
 
-  SDnodeObj *pDnode = mndAcquireDnodeByEp(pMnode, pCreate->ep);
+  char ep[TSDB_EP_LEN];
+  snprintf(ep, TSDB_EP_LEN, "%s:%d", pCreate->fqdn, pCreate->port);
+  SDnodeObj *pDnode = mndAcquireDnodeByEp(pMnode, ep);
   if (pDnode != NULL) {
-    mError("dnode:%d, already exist", pDnode->id);
+    mError("dnode:%d, already exist, %s:%u", pDnode->id, pCreate->fqdn, pCreate->port);
     mndReleaseDnode(pMnode, pDnode);
     terrno = TSDB_CODE_MND_DNODE_ALREADY_EXIST;
     return -1;
@@ -442,7 +441,7 @@ static int32_t mndProcessCreateDnodeMsg(SMnodeMsg *pMsg) {
   int32_t code = mndCreateDnode(pMnode, pMsg, pCreate);
 
   if (code != 0) {
-    mError("dnode:%s, failed to create since %s", pCreate->ep, terrstr());
+    mError("dnode:%s:%d, failed to create since %s", pCreate->fqdn, pCreate->port, terrstr());
     return -1;
   }
 

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

@@ -390,7 +390,7 @@ void mndSendRsp(SMnodeMsg *pMsg, int32_t code) {
   rpcSendResponse(&rpcRsp);
 }
 
-static void mndProcessRpcMsg(SMnodeMsg *pMsg) {
+void mndProcessMsg(SMnodeMsg *pMsg) {
   SMnode *pMnode = pMsg->pMnode;
   int32_t code = 0;
   tmsg_t  msgType = pMsg->rpcMsg.msgType;
@@ -451,12 +451,6 @@ void mndSetMsgHandle(SMnode *pMnode, tmsg_t msgType, MndMsgFp fp) {
   }
 }
 
-void mndProcessReadMsg(SMnodeMsg *pMsg) { mndProcessRpcMsg(pMsg); }
-
-void mndProcessWriteMsg(SMnodeMsg *pMsg) { mndProcessRpcMsg(pMsg); }
-
-void mndProcessSyncMsg(SMnodeMsg *pMsg) { mndProcessRpcMsg(pMsg); }
-
 uint64_t mndGenerateUid(char *name, int32_t len) {
   int64_t  us = taosGetTimestampUs();
   int32_t  hashval = MurmurHash3_32(name, len);

source/dnode/qnode/CMakeLists.txt

@@ -4,4 +4,11 @@ target_include_directories(
     qnode
     PUBLIC "${CMAKE_SOURCE_DIR}/include/dnode/qnode"
     private "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+target_link_libraries(
+    qnode
+    PRIVATE transport
+    PRIVATE os
+    PRIVATE common
+    PRIVATE util
 )
\ No newline at end of file

source/dnode/qnode/inc/qnodeInt.h → source/dnode/qnode/inc/qndInt.h

@@ -16,10 +16,27 @@
 #ifndef _TD_QNODE_INT_H_
 #define _TD_QNODE_INT_H_
 
+#include "os.h"
+
+#include "tlog.h"
+#include "tmsg.h"
+#include "trpc.h"
+
+#include "qnode.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+typedef struct SQnode {
+  int32_t           dnodeId;
+  int64_t           clusterId;
+  SQnodeCfg         cfg;
+  SendMsgToDnodeFp  sendMsgToDnodeFp;
+  SendMsgToMnodeFp  sendMsgToMnodeFp;
+  SendRedirectMsgFp sendRedirectMsgFp;
+} SQnode;
+
 #ifdef __cplusplus
 }
 #endif

source/dnode/qnode/src/qnode.c

@@ -11,4 +11,25 @@
  *
  * 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/>.
- */
+ */
\ No newline at end of file
+
+#include "qndInt.h"
+
+SQnode *qndOpen(const SQnodeOpt *pOption) {
+  SQnode *pQnode = calloc(1, sizeof(SQnode));
+  return pQnode;
+}
+
+void qndClose(SQnode *pQnode) { free(pQnode); }
+
+int32_t qndGetLoad(SQnode *pQnode, SQnodeLoad *pLoad) { return 0; }
+
+int32_t qndProcessQueryReq(SQnode *pQnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
+  *pRsp = NULL;
+  return 0;
+}
+
+int32_t qndProcessFetchReq(SQnode *pQnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
+  *pRsp = NULL;
+  return 0;
+}

source/dnode/snode/CMakeLists.txt

+aux_source_directory(src SNODE_SRC)
+add_library(snode ${SNODE_SRC})
+target_include_directories(
+    snode
+    PUBLIC "${CMAKE_SOURCE_DIR}/include/dnode/snode"
+    private "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+target_link_libraries(
+    snode
+    PRIVATE transport
+    PRIVATE os
+    PRIVATE common
+    PRIVATE util
+)
\ No newline at end of file

source/dnode/snode/inc/sndInt.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_SNODE_INT_H_
+#define _TD_SNODE_INT_H_
+
+#include "os.h"
+
+#include "tlog.h"
+#include "tmsg.h"
+#include "trpc.h"
+
+#include "snode.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SSnode {
+  int32_t           dnodeId;
+  int64_t           clusterId;
+  SSnodeCfg         cfg;
+  SendMsgToDnodeFp  sendMsgToDnodeFp;
+  SendMsgToMnodeFp  sendMsgToMnodeFp;
+  SendRedirectMsgFp sendRedirectMsgFp;
+} SSnode;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_SNODE_INT_H_*/
\ No newline at end of file

source/dnode/snode/src/snode.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 "sndInt.h"
+
+SSnode *sndOpen(const char *path, const SSnodeOpt *pOption) {
+  SSnode *pSnode = calloc(1, sizeof(SSnode));
+  return pSnode;
+}
+
+void sndClose(SSnode *pSnode) { free(pSnode); }
+
+int32_t sndGetLoad(SSnode *pSnode, SSnodeLoad *pLoad) { return 0; }
+
+int32_t sndProcessWriteMsg(SSnode *pSnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
+  *pRsp = NULL;
+  return 0;
+}
+
+void sndDestroy(const char *path) {}
\ No newline at end of file

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

@@ -73,7 +73,7 @@ struct SVnode {
   SVnodeSync* pSync;
   SVnodeFS*   pFs;
   tsem_t      canCommit;
-  void*       pQuery;
+  SQHandle*   pQuery;
 };
 
 int vnodeScheduleTask(SVnodeTask* task);

source/dnode/vnode/impl/inc/vnodeQuery.h

@@ -22,6 +22,9 @@ extern "C" {
 #include "vnodeInt.h"
 #include "qworker.h"
 
+typedef struct SQWorkerMgmt SQHandle;
+
+
 int vnodeQueryOpen(SVnode *pVnode);
 
 #ifdef __cplusplus

source/dnode/vnode/impl/src/vnodeQuery.c

@@ -22,13 +22,27 @@ int vnodeQueryOpen(SVnode *pVnode) {
 
 int vnodeProcessQueryReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   vInfo("query message is processed");
-  qWorkerProcessQueryMsg(pVnode, pVnode->pQuery, pMsg);
-  return 0;
+  return qWorkerProcessQueryMsg(pVnode, pVnode->pQuery, pMsg);
 }
 
 int vnodeProcessFetchReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   vInfo("fetch message is processed");
-  qWorkerProcessFetchMsg(pVnode, pVnode->pQuery, pMsg);
+  switch (pMsg->msgType) {
+    case TDMT_VND_FETCH:
+      return qWorkerProcessFetchMsg(pVnode, pVnode->pQuery, pMsg);
+    case TDMT_VND_RES_READY:
+      return qWorkerProcessReadyMsg(pVnode, pVnode->pQuery, pMsg);
+    case TDMT_VND_TASKS_STATUS:
+      return qWorkerProcessStatusMsg(pVnode, pVnode->pQuery, pMsg);
+    case TDMT_VND_CANCEL_TASK:
+      return qWorkerProcessCancelMsg(pVnode, pVnode->pQuery, pMsg);
+    case TDMT_VND_DROP_TASK:
+      return qWorkerProcessDropMsg(pVnode, pVnode->pQuery, pMsg);
+    default:
+      vError("unknown msg type:%d in fetch queue", pMsg->msgType);
+      return TSDB_CODE_VND_APP_ERROR;
+      break;
+  }
   return 0;
 }
 

source/libs/catalog/inc/catalogInt.h

@@ -46,7 +46,6 @@ typedef struct STableMetaCache {
 } STableMetaCache;
 
 typedef struct SCatalog {
-  SVgroupListCache vgroupCache;
   SDBVgroupCache   dbCache;
   STableMetaCache  tableCache;
 } SCatalog;
@@ -67,6 +66,7 @@ typedef uint32_t (*tableNameHashFp)(const char *, uint32_t);
 #define ctgTrace(...)  do { if (ctgDebugFlag & DEBUG_TRACE) { taosPrintLog("CTG ", ctgDebugFlag, __VA_ARGS__); }} while(0)
 #define ctgDebugL(...) do { if (ctgDebugFlag & DEBUG_DEBUG) { taosPrintLongString("CTG ", ctgDebugFlag, __VA_ARGS__); }} while(0)
 
+#define CTG_CACHE_ENABLED() (ctgMgmt.cfg.maxDBCacheNum > 0 || ctgMgmt.cfg.maxTblCacheNum > 0)
 
 #define CTG_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; return _code; } } while (0)
 #define CTG_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; } return _code; } while (0)

source/libs/catalog/src/catalog.c

@@ -146,8 +146,44 @@ void ctgGenEpSet(SEpSet *epSet, SVgroupInfo *vgroupInfo) {
   }
 }
 
+int32_t ctgGetTableMetaFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char *pDBName, const char* pTableName, STableMetaOutput* output) {
+  if (NULL == pCatalog || NULL == pRpc || NULL == pMgmtEps || NULL == pDBName || NULL == pTableName || NULL == output) {
+    CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
+  }
+
+  char tbFullName[TSDB_TABLE_FNAME_LEN];
+
+  snprintf(tbFullName, sizeof(tbFullName), "%s.%s", pDBName, pTableName);
+
+  SBuildTableMetaInput bInput = {.vgId = 0, .tableFullName = tbFullName};
+  char *msg = NULL;
+  SEpSet *pVnodeEpSet = NULL;
+  int32_t msgLen = 0;
+
+  CTG_ERR_RET(queryBuildMsg[TDMT_MND_STB_META](&bInput, &msg, 0, &msgLen));
+
+  SRpcMsg rpcMsg = {
+      .msgType = TDMT_MND_STB_META,
+      .pCont   = msg,
+      .contLen = msgLen,
+  };
+
+  SRpcMsg rpcRsp = {0};
 
-int32_t ctgGetTableMetaFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char *pDBName, const char* pTableName, SVgroupInfo *vgroupInfo, STableMetaOutput* output) {
+  rpcSendRecv(pRpc, (SEpSet*)pMgmtEps, &rpcMsg, &rpcRsp);
+  
+  if (TSDB_CODE_SUCCESS != rpcRsp.code) {
+    ctgError("error rsp for table meta, code:%x", rpcRsp.code);
+    CTG_ERR_RET(rpcRsp.code);
+  }
+
+  CTG_ERR_RET(queryProcessMsgRsp[TDMT_MND_STB_META](output, rpcRsp.pCont, rpcRsp.contLen));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t ctgGetTableMetaFromVnode(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char *pDBName, const char* pTableName, SVgroupInfo *vgroupInfo, STableMetaOutput* output) {
   if (NULL == pCatalog || NULL == pRpc || NULL == pMgmtEps || NULL == pDBName || NULL == pTableName || NULL == vgroupInfo || NULL == output) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
@@ -307,7 +343,9 @@ int32_t ctgUpdateTableMetaCache(struct SCatalog *pCatalog, STableMetaOutput *out
       ctgError("init hash[%d] for tablemeta cache failed", ctgMgmt.cfg.maxTblCacheNum);
       CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
     }
+  }
 
+  if (NULL == pCatalog->tableCache.stableCache) {
     pCatalog->tableCache.stableCache = taosHashInit(ctgMgmt.cfg.maxTblCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), true, HASH_ENTRY_LOCK);
     if (NULL == pCatalog->tableCache.stableCache) {
       ctgError("init hash[%d] for stablemeta cache failed", ctgMgmt.cfg.maxTblCacheNum);
@@ -318,55 +356,51 @@ int32_t ctgUpdateTableMetaCache(struct SCatalog *pCatalog, STableMetaOutput *out
   if (output->metaNum == 2) {
     if (taosHashPut(pCatalog->tableCache.cache, output->ctbFname, strlen(output->ctbFname), &output->ctbMeta, sizeof(output->ctbMeta)) != 0) {
       ctgError("push ctable[%s] to table cache failed", output->ctbFname);
-      goto error_exit;
+      CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
     }
 
     if (TSDB_SUPER_TABLE != output->tbMeta->tableType) {
       ctgError("table type[%d] error, expected:%d", output->tbMeta->tableType, TSDB_SUPER_TABLE);
-      goto error_exit;
+      CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
     }    
   }
 
   int32_t tbSize = sizeof(*output->tbMeta) + sizeof(SSchema) * (output->tbMeta->tableInfo.numOfColumns + output->tbMeta->tableInfo.numOfTags);
   if (taosHashPut(pCatalog->tableCache.cache, output->tbFname, strlen(output->tbFname), output->tbMeta, tbSize) != 0) {
     ctgError("push table[%s] to table cache failed", output->tbFname);
-    goto error_exit;
+    CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
   }
 
   if (TSDB_SUPER_TABLE == output->tbMeta->tableType) {
     if (taosHashPut(pCatalog->tableCache.stableCache, &output->tbMeta->suid, sizeof(output->tbMeta->suid), &output->tbMeta, POINTER_BYTES) != 0) {
       ctgError("push suid[%"PRIu64"] to stable cache failed", output->tbMeta->suid);
-      goto error_exit;
+      CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
     }
   }
   
   return TSDB_CODE_SUCCESS;
-
-error_exit:
-  if (pCatalog->vgroupCache.cache) {
-    taosHashCleanup(pCatalog->vgroupCache.cache);
-    pCatalog->vgroupCache.cache = NULL;
-  }
-
-  pCatalog->vgroupCache.vgroupVersion = CTG_DEFAULT_INVALID_VERSION;
-
-  CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
 }
 
 int32_t catalogInit(SCatalogCfg *cfg) {
-  ctgMgmt.pCluster = taosHashInit(CTG_DEFAULT_CACHE_CLUSTER_NUMBER, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
-  if (NULL == ctgMgmt.pCluster) {
-    CTG_ERR_LRET(TSDB_CODE_CTG_INTERNAL_ERROR, "init %d cluster cache failed", CTG_DEFAULT_CACHE_CLUSTER_NUMBER);
+  if (ctgMgmt.pCluster) {
+    ctgError("catalog already init");
+    CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
   if (cfg) {
     memcpy(&ctgMgmt.cfg, cfg, sizeof(*cfg));
   } else {
-    ctgMgmt.cfg.enableVgroupCache = true;
     ctgMgmt.cfg.maxDBCacheNum = CTG_DEFAULT_CACHE_DB_NUMBER;
     ctgMgmt.cfg.maxTblCacheNum = CTG_DEFAULT_CACHE_TABLEMETA_NUMBER;
   }
 
+  if (CTG_CACHE_ENABLED()) {
+    ctgMgmt.pCluster = taosHashInit(CTG_DEFAULT_CACHE_CLUSTER_NUMBER, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
+    if (NULL == ctgMgmt.pCluster) {
+      CTG_ERR_LRET(TSDB_CODE_CTG_INTERNAL_ERROR, "init %d cluster cache failed", CTG_DEFAULT_CACHE_CLUSTER_NUMBER);
+    }
+  }
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -381,21 +415,19 @@ int32_t catalogGetHandle(const char* clusterId , struct SCatalog** catalogHandle
   }
 
   size_t clen = strlen(clusterId);
-  SCatalog *clusterCtg = (SCatalog *)taosHashGet(ctgMgmt.pCluster, clusterId, clen);
+  SCatalog **ctg = (SCatalog **)taosHashGet(ctgMgmt.pCluster, clusterId, clen);
 
-  if (clusterCtg) {
-    *catalogHandle = clusterCtg;
+  if (ctg && (*ctg)) {
+    *catalogHandle = *ctg;
     return TSDB_CODE_SUCCESS;
   }
 
-  clusterCtg = calloc(1, sizeof(*clusterCtg));
+  SCatalog *clusterCtg = calloc(1, sizeof(SCatalog));
   if (NULL == clusterCtg) {
-    ctgError("calloc %d failed", (int32_t)sizeof(*clusterCtg));
+    ctgError("calloc %d failed", (int32_t)sizeof(SCatalog));
     CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
   }
 
-  clusterCtg->vgroupCache.vgroupVersion = CTG_DEFAULT_INVALID_VERSION;
-
   if (taosHashPut(ctgMgmt.pCluster, clusterId, clen, &clusterCtg, POINTER_BYTES)) {
     ctgError("put cluster %s cache to hash failed", clusterId);
     tfree(clusterCtg);
@@ -443,7 +475,7 @@ int32_t catalogUpdateDBVgroupCache(struct SCatalog* pCatalog, const char* dbName
   }
 
   if (NULL == pCatalog->dbCache.cache) {
-    pCatalog->dbCache.cache = taosHashInit(CTG_DEFAULT_CACHE_DB_NUMBER, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
+    pCatalog->dbCache.cache = taosHashInit(ctgMgmt.cfg.maxDBCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
     if (NULL == pCatalog->dbCache.cache) {
       ctgError("init hash[%d] for db cache failed", CTG_DEFAULT_CACHE_DB_NUMBER);
       CTG_ERR_RET(TSDB_CODE_CTG_MEM_ERROR);
@@ -515,7 +547,9 @@ int32_t catalogRenewTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSe
 
   STableMetaOutput output = {0};
   
-  CTG_ERR_RET(ctgGetTableMetaFromMnode(pCatalog, pRpc, pMgmtEps, pDBName, pTableName, &vgroupInfo, &output));
+  //CTG_ERR_RET(ctgGetTableMetaFromVnode(pCatalog, pRpc, pMgmtEps, pDBName, pTableName, &vgroupInfo, &output));
+
+  CTG_ERR_RET(ctgGetTableMetaFromMnode(pCatalog, pRpc, pMgmtEps, pDBName, pTableName, &output));
 
   CTG_ERR_RET(ctgUpdateTableMetaCache(pCatalog, &output));
 

source/libs/index/inc/indexInt.h

@@ -51,6 +51,8 @@ struct SIndex {
   int64_t suid;      // current super table id, -1 is normal table
   int32_t cVersion;  // current version allocated to cache
 
+  char* path;
+
   SIndexStat      stat;
   pthread_mutex_t mtx;
 };
@@ -87,12 +89,23 @@ typedef struct SIndexTermQuery {
   EIndexQueryType qType;
 } SIndexTermQuery;
 
-typedef struct Iterate {
-  void*   iter;
+typedef struct Iterate Iterate;
+
+typedef struct IterateValue {
   int8_t  type;
   char*   colVal;
   SArray* val;
+} IterateValue;
+
+typedef struct Iterate {
+  void*        iter;
+  IterateValue val;
+  bool (*next)(Iterate* iter);
+  IterateValue* (*getValue)(Iterate* iter);
 } Iterate;
+
+void iterateValueDestroy(IterateValue* iv, bool destroy);
+
 extern void* indexQhandle;
 
 int indexFlushCacheTFile(SIndex* sIdx, void*);

source/libs/index/inc/index_cache.h

@@ -39,8 +39,10 @@ typedef struct IndexCache {
   int32_t    nTerm;
   int8_t     type;
 
+  pthread_mutex_t mtx;
 } IndexCache;
 
+#define CACHE_VERSION(cache) atomic_load_32(&cache->version)
 typedef struct CacheTerm {
   // key
   int32_t nColVal;
@@ -57,6 +59,9 @@ IndexCache* indexCacheCreate(SIndex* idx, const char* colName, int8_t type);
 
 void indexCacheDestroy(void* cache);
 
+Iterate* indexCacheIteratorCreate(IndexCache* cache);
+void     indexCacheIteratorDestroy(Iterate* iiter);
+
 int indexCachePut(void* cache, SIndexTerm* term, uint64_t uid);
 
 // int indexCacheGet(void *cache, uint64_t *rst);
@@ -66,6 +71,8 @@ void indexCacheRef(IndexCache* cache);
 void indexCacheUnRef(IndexCache* cache);
 
 void indexCacheDebug(IndexCache* cache);
+
+void indexCacheDestroyImm(IndexCache* cache);
 #ifdef __cplusplus
 }
 #endif

source/libs/index/inc/index_fst.h

@@ -319,6 +319,8 @@ bool streamWithStateSeekMin(StreamWithState* sws, FstBoundWithData* min);
 StreamWithStateResult* streamWithStateNextWith(StreamWithState* sws, StreamCallback callback);
 
 FstStreamBuilder* fstStreamBuilderCreate(Fst* fst, AutomationCtx* aut);
+
+void fstStreamBuilderDestroy(FstStreamBuilder* b);
 // set up bound range
 // refator, simple code by marco
 

source/libs/index/inc/index_tfile.h

@@ -113,6 +113,8 @@ int          tfileReaderSearch(TFileReader* reader, SIndexTermQuery* query, SArr
 void         tfileReaderRef(TFileReader* reader);
 void         tfileReaderUnRef(TFileReader* reader);
 
+TFileWriter* tfileWriterOpen(char* path, uint64_t suid, int32_t version, const char* colName, uint8_t type);
+void         tfileWriteClose(TFileWriter* tw);
 TFileWriter* tfileWriterCreate(WriterCtx* ctx, TFileHeader* header);
 void         tfileWriterDestroy(TFileWriter* tw);
 int          tfileWriterPut(TFileWriter* tw, void* data);
@@ -123,6 +125,14 @@ IndexTFile* indexTFileCreate(const char* path);
 int         indexTFilePut(void* tfile, SIndexTerm* term, uint64_t uid);
 int         indexTFileSearch(void* tfile, SIndexTermQuery* query, SArray* result);
 
+Iterate* tfileIteratorCreate(TFileReader* reader);
+void     tfileIteratorDestroy(Iterate* iterator);
+
+TFileValue* tfileValueCreate(char* val);
+
+int  tfileValuePush(TFileValue* tf, uint64_t val);
+void tfileValueDestroy(TFileValue* tf);
+
 #ifdef __cplusplus
 }
 

source/libs/index/src/index.c

@@ -75,9 +75,12 @@ int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
   sIdx->tindex = indexTFileCreate(path);
   sIdx->colObj = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   sIdx->cVersion = 1;
+  sIdx->path = calloc(1, strlen(path) + 1);
+  memcpy(sIdx->path, path, strlen(path));
   pthread_mutex_init(&sIdx->mtx, NULL);
 
   *index = sIdx;
+
   return 0;
 #endif
 
@@ -361,14 +364,94 @@ static int indexMergeFinalResults(SArray* interResults, EIndexOperatorType oType
   }
   return 0;
 }
+
 int indexFlushCacheTFile(SIndex* sIdx, void* cache) {
   if (sIdx == NULL) { return -1; }
   indexWarn("suid %" PRIu64 " merge cache into tindex", sIdx->suid);
-  IndexCache* pCache = (IndexCache*)cache;
 
+  IndexCache*  pCache = (IndexCache*)cache;
   TFileReader* pReader = tfileGetReaderByCol(sIdx->tindex, pCache->colName);
 
+  // handle flush
+  Iterate* cacheIter = indexCacheIteratorCreate(pCache);
+  Iterate* tfileIter = tfileIteratorCreate(pReader);
+
+  SArray* result = taosArrayInit(1024, sizeof(void*));
+
+  bool cn = cacheIter->next(cacheIter);
+  bool tn = tfileIter->next(tfileIter);
+  while (cn == true && tn == true) {
+    IterateValue* cv = cacheIter->getValue(cacheIter);
+    IterateValue* tv = tfileIter->getValue(tfileIter);
+
+    // dump value
+    int comp = strcmp(cv->colVal, tv->colVal);
+    if (comp == 0) {
+      TFileValue* tfv = tfileValueCreate(cv->colVal);
+      taosArrayAddAll(tfv->tableId, cv->val);
+      taosArrayAddAll(tfv->tableId, tv->val);
+      taosArrayPush(result, &tfv);
+
+      cn = cacheIter->next(cacheIter);
+      tn = tfileIter->next(tfileIter);
+      continue;
+    } else if (comp < 0) {
+      TFileValue* tfv = tfileValueCreate(cv->colVal);
+      taosArrayAddAll(tfv->tableId, cv->val);
+      taosArrayPush(result, &tfv);
+
+      // copy to final Result;
+      cn = cacheIter->next(cacheIter);
+    } else {
+      TFileValue* tfv = tfileValueCreate(tv->colVal);
+      taosArrayPush(result, &tfv);
+      taosArrayAddAll(tfv->tableId, tv->val);
+      // copy to final result
+      tn = tfileIter->next(tfileIter);
+    }
+  }
+  while (cn == true) {
+    IterateValue* cv = cacheIter->getValue(cacheIter);
+    TFileValue*   tfv = tfileValueCreate(cv->colVal);
+    taosArrayAddAll(tfv->tableId, cv->val);
+    taosArrayPush(result, &tfv);
+    cn = cacheIter->next(cacheIter);
+  }
+  while (tn == true) {
+    IterateValue* tv = tfileIter->getValue(tfileIter);
+    TFileValue*   tfv = tfileValueCreate(tv->colVal);
+    taosArrayAddAll(tfv->tableId, tv->val);
+    taosArrayPush(result, &tfv);
+    tn = tfileIter->next(tfileIter);
+  }
+
+  int32_t version = CACHE_VERSION(pCache);
+  uint8_t colType = pCache->type;
+
+  TFileWriter* tw = tfileWriterOpen(sIdx->path, sIdx->suid, version, pCache->colName, colType);
+  if (tw == NULL) {
+    indexError("faile to open file to write");
+  } else {
+    int ret = tfileWriterPut(tw, result);
+    if (ret != 0) { indexError("faile to write into tindex "); }
+  }
+  // not free later, just put int table cache
+  indexCacheDestroyImm(pCache);
+
+  tfileWriteClose(tw);
+  indexCacheIteratorDestroy(cacheIter);
+  tfileIteratorDestroy(tfileIter);
+
   tfileReaderUnRef(pReader);
   indexCacheUnRef(pCache);
   return 0;
 }
+void iterateValueDestroy(IterateValue* value, bool destroy) {
+  if (destroy) {
+    taosArrayDestroy(value->val);
+  } else {
+    taosArrayClear(value->val);
+  }
+  free(value->colVal);
+  value->colVal = NULL;
+}

source/libs/index/src/index_cache.c

@@ -20,7 +20,7 @@
 
 #define MAX_INDEX_KEY_LEN 256  // test only, change later
 
-#define CACH_LIMIT 1000000
+#define MEM_TERM_LIMIT 1000000
 // ref index_cache.h:22
 //#define CACHE_KEY_LEN(p) \
 //  (sizeof(int32_t) + sizeof(uint16_t) + sizeof(p->colType) + sizeof(p->nColVal) + p->nColVal + sizeof(uint64_t) + sizeof(p->operType))
@@ -78,6 +78,7 @@ IndexCache* indexCacheCreate(SIndex* idx, const char* colName, int8_t type) {
   cache->index = idx;
   cache->version = 0;
 
+  pthread_mutex_init(&cache->mtx, NULL);
   indexCacheRef(cache);
   return cache;
 }
@@ -94,12 +95,30 @@ void indexCacheDebug(IndexCache* cache) {
   tSkipListDestroyIter(iter);
 }
 
+void indexCacheDestroySkiplist(SSkipList* slt) {
+  SSkipListIterator* iter = tSkipListCreateIter(slt);
+  while (tSkipListIterNext(iter)) {
+    SSkipListNode* node = tSkipListIterGet(iter);
+    CacheTerm*     ct = (CacheTerm*)SL_GET_NODE_DATA(node);
+    if (ct != NULL) {}
+  }
+  tSkipListDestroyIter(iter);
+}
+void indexCacheDestroyImm(IndexCache* cache) {
+  pthread_mutex_lock(&cache->mtx);
+  SSkipList* timm = (SSkipList*)cache->imm;
+  cache->imm = NULL;  // or throw int bg thread
+  pthread_mutex_unlock(&cache->mtx);
+
+  indexCacheDestroySkiplist(timm);
+}
 void indexCacheDestroy(void* cache) {
   IndexCache* pCache = cache;
   if (pCache == NULL) { return; }
   tSkipListDestroy(pCache->mem);
   tSkipListDestroy(pCache->imm);
   free(pCache->colName);
+
   free(pCache);
 }
 
@@ -108,6 +127,48 @@ static void doMergeWork(SSchedMsg* msg) {
   SIndex*     sidx = (SIndex*)pCache->index;
   indexFlushCacheTFile(sidx, pCache);
 }
+static bool indexCacheIteratorNext(Iterate* itera) {
+  SSkipListIterator* iter = itera->iter;
+  if (iter == NULL) { return false; }
+
+  IterateValue* iv = &itera->val;
+  iterateValueDestroy(iv, false);
+
+  bool next = tSkipListIterNext(iter);
+  if (next) {
+    SSkipListNode* node = tSkipListIterGet(iter);
+    CacheTerm*     ct = (CacheTerm*)SL_GET_NODE_DATA(node);
+
+    iv->type = ct->operaType;
+    iv->colVal = ct->colVal;
+
+    taosArrayPush(iv->val, &ct->uid);
+  }
+
+  return next;
+}
+
+static IterateValue* indexCacheIteratorGetValue(Iterate* iter) {
+  return &iter->val;
+}
+Iterate* indexCacheIteratorCreate(IndexCache* cache) {
+  Iterate* iiter = calloc(1, sizeof(Iterate));
+  if (iiter == NULL) { return NULL; }
+
+  iiter->val.val = taosArrayInit(1, sizeof(uint64_t));
+  iiter->iter = cache->imm != NULL ? tSkipListCreateIter(cache->imm) : NULL;
+  iiter->next = indexCacheIteratorNext;
+  iiter->getValue = indexCacheIteratorGetValue;
+
+  return iiter;
+}
+void indexCacheIteratorDestroy(Iterate* iter) {
+  if (iter == NULL) { return; }
+
+  tSkipListDestroyIter(iter->iter);
+  iterateValueDestroy(&iter->val, true);
+  free(iter);
+}
 
 int indexCacheSchedToMerge(IndexCache* pCache) {
   SSchedMsg schedMsg = {0};
@@ -118,6 +179,27 @@ int indexCacheSchedToMerge(IndexCache* pCache) {
 
   taosScheduleTask(indexQhandle, &schedMsg);
 }
+static void indexCacheMakeRoomForWrite(IndexCache* cache) {
+  while (true) {
+    if (cache->nTerm < MEM_TERM_LIMIT) {
+      cache->nTerm += 1;
+      break;
+    } else if (cache->imm != NULL) {
+      // TODO: wake up by condition variable
+      pthread_mutex_unlock(&cache->mtx);
+      taosMsleep(50);
+      pthread_mutex_lock(&cache->mtx);
+    } else {
+      cache->imm = cache->mem;
+      cache->mem = indexInternalCacheCreate(cache->type);
+      cache->nTerm = 1;
+      // sched to merge
+      // unref cache in bgwork
+      indexCacheSchedToMerge(cache);
+    }
+  }
+}
+
 int indexCachePut(void* cache, SIndexTerm* term, uint64_t uid) {
   if (cache == NULL) { return -1; }
 
@@ -136,23 +218,12 @@ int indexCachePut(void* cache, SIndexTerm* term, uint64_t uid) {
   ct->uid = uid;
   ct->operaType = term->operType;
 
+  // ugly code, refactor later
+  pthread_mutex_lock(&pCache->mtx);
+  indexCacheMakeRoomForWrite(pCache);
   tSkipListPut(pCache->mem, (char*)ct);
-  pCache->nTerm += 1;
-
-  if (pCache->nTerm >= CACH_LIMIT) {
-    pCache->nTerm = 0;
+  pthread_mutex_unlock(&pCache->mtx);
 
-    while (pCache->imm != NULL) {
-      // do nothong
-    }
-
-    pCache->imm = pCache->mem;
-    pCache->mem = indexInternalCacheCreate(pCache->type);
-
-    // sched to merge
-    // unref cache int bgwork
-    indexCacheSchedToMerge(pCache);
-  }
   indexCacheUnRef(pCache);
   return 0;
   // encode end

source/libs/index/src/index_tfile.c

@@ -23,6 +23,13 @@
 #include "taosdef.h"
 #include "tcompare.h"
 
+typedef struct TFileFstIter {
+  FstStreamBuilder* fb;
+  StreamWithState*  st;
+  AutomationCtx*    ctx;
+  TFileReader*      rdr;
+} TFileFstIter;
+
 #define TF_TABLE_TATOAL_SIZE(sz) (sizeof(sz) + sz * sizeof(uint64_t))
 
 static int  tfileStrCompare(const void* a, const void* b);
@@ -184,6 +191,23 @@ int tfileReaderSearch(TFileReader* reader, SIndexTermQuery* query, SArray* resul
   return ret;
 }
 
+TFileWriter* tfileWriterOpen(char* path, uint64_t suid, int32_t version, const char* colName, uint8_t colType) {
+  char    filename[128] = {0};
+  int32_t coldId = 1;
+  tfileGenFileName(filename, suid, coldId, version);
+
+  char fullname[256] = {0};
+  snprintf(fullname, sizeof(fullname), "%s/%s", path, filename);
+  WriterCtx* wcx = writerCtxCreate(TFile, fullname, true, 1024 * 1024);
+
+  TFileHeader tfh = {0};
+  tfh.suid = suid;
+  tfh.version = version;
+  memcpy(tfh.colName, colName, strlen(colName));
+  tfh.colType = colType;
+
+  return tfileWriterCreate(wcx, &tfh);
+}
 TFileWriter* tfileWriterCreate(WriterCtx* ctx, TFileHeader* header) {
   // char pathBuf[128] = {0};
   // sprintf(pathBuf, "%s/% " PRIu64 "-%d-%d.tindex", path, suid, colId, version);
@@ -279,6 +303,11 @@ int tfileWriterPut(TFileWriter* tw, void* data) {
   tw->fb = NULL;
   return 0;
 }
+void tfileWriteClose(TFileWriter* tw) {
+  if (tw == NULL) { return; }
+  writerCtxDestroy(tw->ctx);
+  free(tw);
+}
 void tfileWriterDestroy(TFileWriter* tw) {
   if (tw == NULL) { return; }
 
@@ -314,6 +343,71 @@ int indexTFilePut(void* tfile, SIndexTerm* term, uint64_t uid) {
 
   return 0;
 }
+static bool tfileIteratorNext(Iterate* iiter) {
+  IterateValue* iv = &iiter->val;
+  iterateValueDestroy(iv, false);
+  // SArray* tblIds = iv->val;
+
+  char*    colVal = NULL;
+  uint64_t offset = 0;
+
+  TFileFstIter*          tIter = iiter->iter;
+  StreamWithStateResult* rt = streamWithStateNextWith(tIter->st, NULL);
+  if (rt == NULL) { return false; }
+
+  int32_t sz = 0;
+  char*   ch = (char*)fstSliceData(&rt->data, &sz);
+  colVal = calloc(1, sz + 1);
+  memcpy(colVal, ch, sz);
+
+  offset = (uint64_t)(rt->out.out);
+
+  swsResultDestroy(rt);
+  // set up iterate value
+  if (tfileReaderLoadTableIds(tIter->rdr, offset, iv->val) != 0) { return false; }
+
+  iv->colVal = colVal;
+
+  // std::string key(ch, sz);
+}
+
+static IterateValue* tifileIterateGetValue(Iterate* iter) {
+  return &iter->val;
+}
+
+static TFileFstIter* tfileFstIteratorCreate(TFileReader* reader) {
+  TFileFstIter* tIter = calloc(1, sizeof(Iterate));
+  if (tIter == NULL) { return NULL; }
+  tIter->ctx = automCtxCreate(NULL, AUTOMATION_ALWAYS);
+  tIter->fb = fstSearch(reader->fst, tIter->ctx);
+  tIter->st = streamBuilderIntoStream(tIter->fb);
+  tIter->rdr = reader;
+  return tIter;
+}
+
+Iterate* tfileIteratorCreate(TFileReader* reader) {
+  Iterate* iter = calloc(1, sizeof(Iterate));
+
+  iter->iter = tfileFstIteratorCreate(reader);
+  if (iter->iter == NULL) { return NULL; }
+
+  iter->next = tfileIteratorNext;
+  iter->getValue = tifileIterateGetValue;
+  return iter;
+}
+void tfileIteratorDestroy(Iterate* iter) {
+  if (iter == NULL) { return; }
+  IterateValue* iv = &iter->val;
+  iterateValueDestroy(iv, true);
+
+  TFileFstIter* tIter = iter->iter;
+  streamWithStateDestroy(tIter->st);
+  fstStreamBuilderDestroy(tIter->fb);
+  automCtxDestroy(tIter->ctx);
+
+  free(iter);
+}
+
 TFileReader* tfileGetReaderByCol(IndexTFile* tf, char* colName) {
   if (tf == NULL) { return NULL; }
   TFileCacheKey key = {.suid = 0, .colType = TSDB_DATA_TYPE_BINARY, .colName = colName, .nColName = strlen(colName)};
@@ -334,6 +428,23 @@ static int tfileValueCompare(const void* a, const void* b, const void* param) {
 
   return fn(av->colVal, bv->colVal);
 }
+
+TFileValue* tfileValueCreate(char* val) {
+  TFileValue* tf = calloc(1, sizeof(TFileValue));
+  if (tf == NULL) { return NULL; }
+
+  tf->tableId = taosArrayInit(32, sizeof(uint64_t));
+  return tf;
+}
+int tfileValuePush(TFileValue* tf, uint64_t val) {
+  if (tf == NULL) { return -1; }
+  taosArrayPush(tf->tableId, &val);
+  return 0;
+}
+void tfileValueDestroy(TFileValue* tf) {
+  taosArrayDestroy(tf->tableId);
+  free(tf);
+}
 static void tfileSerialTableIdsToBuf(char* buf, SArray* ids) {
   int sz = taosArrayGetSize(ids);
   SERIALIZE_VAR_TO_BUF(buf, sz, int32_t);

source/libs/parser/src/astToMsg.c

@@ -414,8 +414,8 @@ SCreateDnodeMsg *buildCreateDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMs
     return NULL;
   }
 
-  strncpy(pCreate->ep, id->z, id->n);
-  pCreate->port = val;
+  strncpy(pCreate->fqdn, id->z, id->n);
+  pCreate->port = htonl(val);
 
   *len = sizeof(SCreateDnodeMsg);
   return pCreate;
@@ -428,6 +428,7 @@ SDropDnodeMsg *buildDropDnodeMsg(SSqlInfo* pInfo, int32_t* len, SMsgBuf* pMsgBuf
   char* end = NULL;
   SDropDnodeMsg * pDrop = (SDropDnodeMsg *)calloc(1, sizeof(SDropDnodeMsg));
   pDrop->dnodeId = strtoll(pzName->z, &end, 10);
+  pDrop->dnodeId = htonl(pDrop->dnodeId);
   *len = sizeof(SDropDnodeMsg);
 
   if (end - pzName->z != pzName->n) {

source/libs/parser/src/parser.c

@@ -229,6 +229,6 @@ void qParserClearupMetaRequestInfo(SCatalogReq* pMetaReq) {
   taosArrayDestroy(pMetaReq->pUdf);
 }
 
-void qDestoryQuery(SQueryNode* pQuery) {
+void qDestroyQuery(SQueryNode* pQuery) {
   // todo
 }

source/libs/planner/src/physicalPlanJson.c

@@ -857,3 +857,84 @@ int32_t stringToSubplan(const char* str, SSubplan** subplan) {
   *subplan = subplanFromJson(json);
   return (NULL == *subplan ? TSDB_CODE_FAILED : TSDB_CODE_SUCCESS);
 }
+
+cJSON* qDagToJson(const SQueryDag* pDag) {
+  cJSON* pRoot = cJSON_CreateObject();
+  if(pRoot == NULL) {
+    return NULL;
+  }
+  cJSON_AddNumberToObject(pRoot, "numOfSubplans", pDag->numOfSubplans);
+  cJSON_AddNumberToObject(pRoot, "queryId", pDag->queryId);
+  cJSON *pLevels = cJSON_CreateArray();
+  if(pLevels == NULL) {
+    cJSON_Delete(pRoot);
+    return NULL;
+  }
+  cJSON_AddItemToObject(pRoot, "pSubplans", pLevels);
+  size_t level = taosArrayGetSize(pDag->pSubplans);
+  for(size_t i = 0; i < level; i++) {
+    const SArray* pSubplans = (const SArray*)taosArrayGetP(pDag->pSubplans, i);
+    size_t num = taosArrayGetSize(pSubplans);
+    cJSON* plansOneLevel = cJSON_CreateArray();
+    if(plansOneLevel == NULL) {
+      cJSON_Delete(pRoot);
+      return NULL;
+    }
+    cJSON_AddItemToArray(pLevels, plansOneLevel);
+    for(size_t j = 0; j < num; j++) {
+      cJSON* pSubplan = subplanToJson((const SSubplan*)taosArrayGetP(pSubplans, j));
+      if(pSubplan == NULL) {
+        cJSON_Delete(pRoot);
+        return NULL;
+      }
+      cJSON_AddItemToArray(plansOneLevel, pSubplan);
+    }
+  }
+  return pRoot;
+}
+
+char* qDagToString(const SQueryDag* pDag) {
+  cJSON* pRoot = qDagToJson(pDag);
+  return cJSON_Print(pRoot);
+}
+
+SQueryDag* qJsonToDag(const cJSON* pRoot) {
+  SQueryDag* pDag = malloc(sizeof(SQueryDag));
+  if(pDag == NULL) {
+    return NULL;
+  }
+  pDag->numOfSubplans = cJSON_GetNumberValue(cJSON_GetObjectItem(pRoot, "numOfSubplans"));
+  pDag->queryId = cJSON_GetNumberValue(cJSON_GetObjectItem(pRoot, "queryId"));
+  pDag->pSubplans = taosArrayInit(0, sizeof(SArray));
+  if (pDag->pSubplans == NULL) {
+    free(pDag);
+    return NULL;
+  }
+  cJSON* pLevels = cJSON_GetObjectItem(pRoot, "pSubplans");
+  int level = cJSON_GetArraySize(pLevels);
+  for(int i = 0; i < level; i++) {
+    SArray* plansOneLevel = taosArrayInit(0, sizeof(void*));
+    if(plansOneLevel == NULL) {
+      for(int j = 0; j < i; j++) {
+        taosArrayDestroy(taosArrayGetP(pDag->pSubplans, j));
+      }
+      taosArrayDestroy(pDag->pSubplans);
+      free(pDag);
+      return NULL;
+    }
+    cJSON* pItem = cJSON_GetArrayItem(pLevels, i);
+    int sz = cJSON_GetArraySize(pItem);
+    for(int j = 0; j < sz; j++) {
+      cJSON* pSubplanJson = cJSON_GetArrayItem(pItem, j);
+      SSubplan* pSubplan = subplanFromJson(pSubplanJson);
+      taosArrayPush(plansOneLevel, &pSubplan);
+    }
+    taosArrayPush(pDag->pSubplans, plansOneLevel);
+  }
+  return pDag;
+}
+
+SQueryDag* qStringToDag(const char* pStr) {
+  cJSON* pRoot = cJSON_Parse(pStr);
+  return qJsonToDag(pRoot);
+}

source/libs/planner/test/phyPlanTests.cpp

@@ -83,7 +83,7 @@ protected:
     }
   }
 
-  SQueryDag* reslut() {
+  SQueryDag* result() {
     return dag_.get();
   }
 
@@ -149,16 +149,23 @@ TEST_F(PhyPlanTest, tableScanTest) {
   pushScan("test", "t1", QNODE_TABLESCAN);
   ASSERT_EQ(run(), TSDB_CODE_SUCCESS);
   explain();
-  SQueryDag* dag = reslut();
+  SQueryDag* dag = result();
   // todo check
 }
 
+TEST_F(PhyPlanTest, serializeTest) {
+  pushScan("test", "t1", QNODE_TABLESCAN);
+  ASSERT_EQ(run(), TSDB_CODE_SUCCESS);
+  SQueryDag* dag = result();
+  cout << qDagToString(dag) << endl;
+}
+
 // select * from supertable
 TEST_F(PhyPlanTest, superTableScanTest) {
   pushScan("test", "st1", QNODE_TABLESCAN);
   ASSERT_EQ(run(), TSDB_CODE_SUCCESS);
   explain();
-  SQueryDag* dag = reslut();
+  SQueryDag* dag = result();
   // todo check
 }
 
@@ -166,6 +173,6 @@ TEST_F(PhyPlanTest, superTableScanTest) {
 TEST_F(PhyPlanTest, insertTest) {
   ASSERT_EQ(run("test", "insert into t1 values (now, 1, \"beijing\")"), TSDB_CODE_SUCCESS);
   explain();
-  SQueryDag* dag = reslut();
+  SQueryDag* dag = result();
   // todo check
 }

source/libs/qcom/src/querymsg.c

@@ -266,9 +266,11 @@ int32_t queryProcessTableMetaRsp(void* output, char *msg, int32_t msgSize) {
 
 void initQueryModuleMsgHandle() {
   queryBuildMsg[TDMT_VND_TABLE_META] = queryBuildTableMetaReqMsg;
+  queryBuildMsg[TDMT_MND_STB_META] = queryBuildTableMetaReqMsg;
   queryBuildMsg[TDMT_MND_USE_DB] = queryBuildUseDbMsg;
 
   queryProcessMsgRsp[TDMT_VND_TABLE_META] = queryProcessTableMetaRsp;
+  queryProcessMsgRsp[TDMT_MND_STB_META] = queryProcessTableMetaRsp;
   queryProcessMsgRsp[TDMT_MND_USE_DB] = queryProcessUseDBRsp;
 }
 

source/libs/qworker/inc/qworkerInt.h

@@ -42,25 +42,41 @@ enum {
   QW_WRITE,
 };
 
-typedef struct SQWorkerTaskStatus {  
+enum {
+  QW_EXIST_ACQUIRE = 1,
+  QW_EXIST_RET_ERR,
+};
+
+enum {
+  QW_NOT_EXIST_RET_ERR = 1,
+  QW_NOT_EXIST_ADD,
+};
+
+enum {
+  QW_ADD_RET_ERR = 1,
+  QW_ADD_ACQUIRE,
+};
+
+
+typedef struct SQWTaskStatus {  
   SRWLatch lock;
   int32_t  code;
   int8_t   status;
   int8_t   ready; 
   bool     cancel;
   bool     drop;
-} SQWorkerTaskStatus;
+} SQWTaskStatus;
 
 typedef struct SQWorkerResCache {
   SRWLatch lock;
   void *data;
 } SQWorkerResCache;
 
-typedef struct SQWorkerSchStatus {
+typedef struct SQWSchStatus {
   int32_t   lastAccessTs; // timestamp in second
   SRWLatch  tasksLock;
   SHashObj *tasksHash;   // key:queryId+taskId, value: SQWorkerTaskStatus
-} SQWorkerSchStatus;
+} SQWSchStatus;
 
 // Qnode/Vnode level task management
 typedef struct SQWorkerMgmt {
@@ -71,7 +87,7 @@ typedef struct SQWorkerMgmt {
   SHashObj *resHash;       //key: queryId+taskId, value: SQWorkerResCache
 } SQWorkerMgmt;
 
-#define QW_GOT_RES_DATA(data) (false)
+#define QW_GOT_RES_DATA(data) (true)
 #define QW_LOW_RES_DATA(data) (false)
 
 #define QW_TASK_NOT_EXIST(code) (TSDB_CODE_QRY_SCH_NOT_EXIST == (code) || TSDB_CODE_QRY_TASK_NOT_EXIST == (code))
@@ -86,8 +102,31 @@ typedef struct SQWorkerMgmt {
 #define QW_ERR_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { qError(__VA_ARGS__); terrno = _code; return _code; } } while (0)
 #define QW_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { terrno = code; goto _return; } } while (0)
 
-#define QW_LOCK(type, _lock) (QW_READ == (type) ? taosRLockLatch(_lock) : taosWLockLatch(_lock))
-#define QW_UNLOCK(type, _lock) (QW_READ == (type) ? taosRUnLockLatch(_lock) : taosWUnLockLatch(_lock))
+#define QW_LOCK(type, _lock) do {   \
+  if (QW_READ == (type)) {          \
+    if ((*(_lock)) < 0) assert(0);    \
+    taosRLockLatch(_lock);          \
+    qDebug("RLOCK%p, %s:%d", (_lock), __FILE__, __LINE__); \
+  } else {                                                \
+    if ((*(_lock)) < 0) assert(0);                          \
+    taosWLockLatch(_lock);                                \
+    qDebug("WLOCK%p, %s:%d", (_lock), __FILE__, __LINE__);  \
+  }                                                       \
+} while (0)
+
+#define QW_UNLOCK(type, _lock) do {                       \
+  if (QW_READ == (type)) {                                \
+    if ((*(_lock)) <= 0) assert(0);                         \
+    taosRUnLockLatch(_lock);                              \
+    qDebug("RULOCK%p, %s:%d", (_lock), __FILE__, __LINE__); \
+  } else {                                                \
+    if ((*(_lock)) <= 0) assert(0);                         \
+    taosWUnLockLatch(_lock);                              \
+    qDebug("WULOCK%p, %s:%d", (_lock), __FILE__, __LINE__); \
+  }                                                       \
+} while (0)
+
+static int32_t qwAcquireScheduler(int32_t rwType, SQWorkerMgmt *mgmt, uint64_t sId, SQWSchStatus **sch, int32_t nOpt);
 
 
 #ifdef __cplusplus

source/libs/qworker/test/qworkerTests.cpp

@@ -36,10 +36,25 @@
 
 namespace {
 
+bool testStop = false;
+
 int32_t qwtStringToPlan(const char* str, SSubplan** subplan) {
   return 0;
 }
 
+void qwtRpcSendResponse(const SRpcMsg *pRsp) {
+  if (TDMT_VND_TASKS_STATUS_RSP == pRsp->msgType) {
+    SSchedulerStatusRsp *rsp = (SSchedulerStatusRsp *)pRsp->pCont;
+    printf("task num:%d\n", rsp->num);
+    for (int32_t i = 0; i < rsp->num; ++i) {
+      STaskStatus *task = &rsp->status[i];
+      printf("qId:%"PRIx64",tId:%"PRIx64",status:%d\n", task->queryId, task->taskId, task->status);
+    }
+  }
+  return;
+}
+
+
 
 void stubSetStringToPlan() {
   static Stub stub;
@@ -54,11 +69,148 @@ void stubSetStringToPlan() {
   }
 }
 
+void stubSetRpcSendResponse() {
+  static Stub stub;
+  stub.set(rpcSendResponse, qwtRpcSendResponse);
+  {
+    AddrAny any("libplanner.so");
+    std::map<std::string,void*> result;
+    any.get_global_func_addr_dynsym("^rpcSendResponse$", result);
+    for (const auto& f : result) {
+      stub.set(f.second, qwtRpcSendResponse);
+    }
+  }
+}
+
+void *queryThread(void *param) {
+  SRpcMsg queryRpc = {0};
+  int32_t code = 0;
+  uint32_t n = 0;
+  void *mockPointer = (void *)0x1;    
+  void *mgmt = param;
+  SSubQueryMsg *queryMsg = (SSubQueryMsg *)calloc(1, sizeof(SSubQueryMsg) + 100);
+  queryMsg->queryId = htobe64(1);
+  queryMsg->sId = htobe64(1);
+  queryMsg->taskId = htobe64(1);
+  queryMsg->contentLen = htonl(100);
+  queryRpc.pCont = queryMsg;
+  queryRpc.contLen = sizeof(SSubQueryMsg) + 100;
+
+  while (!testStop) {
+    qWorkerProcessQueryMsg(mockPointer, mgmt, &queryRpc);
+    usleep(rand()%5);
+    if (++n % 50000 == 0) {
+      printf("query:%d\n", n);
+    }
+  }
+
+  return NULL;
+}
+
+void *readyThread(void *param) {
+  SRpcMsg readyRpc = {0};
+  int32_t code = 0;
+  uint32_t n = 0;  
+  void *mockPointer = (void *)0x1;    
+  void *mgmt = param;
+  SResReadyMsg readyMsg = {0};
+  readyMsg.sId = htobe64(1);
+  readyMsg.queryId = htobe64(1);
+  readyMsg.taskId = htobe64(1);
+  readyRpc.pCont = &readyMsg;
+  readyRpc.contLen = sizeof(SResReadyMsg);
+
+  while (!testStop) {
+    code = qWorkerProcessReadyMsg(mockPointer, mgmt, &readyRpc);
+    usleep(rand()%5);
+    if (++n % 50000 == 0) {
+      printf("ready:%d\n", n);
+    }    
+  }
+
+  return NULL;
+}
+
+void *fetchThread(void *param) {
+  SRpcMsg fetchRpc = {0};
+  int32_t code = 0;
+  uint32_t n = 0;  
+  void *mockPointer = (void *)0x1;    
+  void *mgmt = param;
+  SResFetchMsg fetchMsg = {0};
+  fetchMsg.sId = htobe64(1);
+  fetchMsg.queryId = htobe64(1);
+  fetchMsg.taskId = htobe64(1);
+  fetchRpc.pCont = &fetchMsg;
+  fetchRpc.contLen = sizeof(SResFetchMsg);
+
+  while (!testStop) {
+    code = qWorkerProcessFetchMsg(mockPointer, mgmt, &fetchRpc);
+    usleep(rand()%5);
+    if (++n % 50000 == 0) {
+      printf("fetch:%d\n", n);
+    }    
+  }
+
+  return NULL;
+}
+
+void *dropThread(void *param) {
+  SRpcMsg dropRpc = {0};
+  int32_t code = 0;
+  uint32_t n = 0;  
+  void *mockPointer = (void *)0x1;    
+  void *mgmt = param;
+  STaskDropMsg dropMsg = {0};  
+  dropMsg.sId = htobe64(1);
+  dropMsg.queryId = htobe64(1);
+  dropMsg.taskId = htobe64(1);
+  dropRpc.pCont = &dropMsg;
+  dropRpc.contLen = sizeof(STaskDropMsg);
+
+  while (!testStop) {
+    code = qWorkerProcessDropMsg(mockPointer, mgmt, &dropRpc);
+    usleep(rand()%5);
+    if (++n % 50000 == 0) {
+      printf("drop:%d\n", n);
+    }    
+  }
+
+  return NULL;
+}
+
+void *statusThread(void *param) {
+  SRpcMsg statusRpc = {0};
+  int32_t code = 0;
+  uint32_t n = 0;  
+  void *mockPointer = (void *)0x1;    
+  void *mgmt = param;
+  SSchTasksStatusMsg statusMsg = {0};
+  statusMsg.sId = htobe64(1);
+  statusRpc.pCont = &statusMsg;
+  statusRpc.contLen = sizeof(SSchTasksStatusMsg);
+  statusRpc.msgType = TDMT_VND_TASKS_STATUS;
+
+  while (!testStop) {
+    statusMsg.sId = htobe64(1);
+    code = qWorkerProcessStatusMsg(mockPointer, mgmt, &statusRpc);
+    usleep(rand()%5);
+    if (++n % 50000 == 0) {
+      printf("status:%d\n", n);
+    }    
+  }
+
+  return NULL;
+}
+
+
+
+
 
 }
 
 
-TEST(testCase, normalCase) {
+TEST(seqTest, normalCase) {
   void *mgmt = NULL;
   int32_t code = 0;
   void *mockPointer = (void *)0x1;
@@ -66,48 +218,254 @@ TEST(testCase, normalCase) {
   SRpcMsg readyRpc = {0};
   SRpcMsg fetchRpc = {0};
   SRpcMsg dropRpc = {0};
+  SRpcMsg statusRpc = {0};
+  
   SSubQueryMsg *queryMsg = (SSubQueryMsg *)calloc(1, sizeof(SSubQueryMsg) + 100);
   queryMsg->queryId = htobe64(1);
-  queryMsg->schedulerId = htobe64(1);
+  queryMsg->sId = htobe64(1);
   queryMsg->taskId = htobe64(1);
   queryMsg->contentLen = htonl(100);
   queryRpc.pCont = queryMsg;
+  queryRpc.contLen = sizeof(SSubQueryMsg) + 100;
 
   SResReadyMsg readyMsg = {0};
-  readyMsg.schedulerId = htobe64(1);
+  readyMsg.sId = htobe64(1);
   readyMsg.queryId = htobe64(1);
   readyMsg.taskId = htobe64(1);
   readyRpc.pCont = &readyMsg;
+  readyRpc.contLen = sizeof(SResReadyMsg);
 
   SResFetchMsg fetchMsg = {0};
-  fetchMsg.schedulerId = htobe64(1);
+  fetchMsg.sId = htobe64(1);
   fetchMsg.queryId = htobe64(1);
   fetchMsg.taskId = htobe64(1);
   fetchRpc.pCont = &fetchMsg;
+  fetchRpc.contLen = sizeof(SResFetchMsg);
 
   STaskDropMsg dropMsg = {0};  
-  dropMsg.schedulerId = htobe64(1);
+  dropMsg.sId = htobe64(1);
   dropMsg.queryId = htobe64(1);
   dropMsg.taskId = htobe64(1);
   dropRpc.pCont = &dropMsg;
+  dropRpc.contLen = sizeof(STaskDropMsg);
 
+  SSchTasksStatusMsg statusMsg = {0};
+  statusMsg.sId = htobe64(1);
+  statusRpc.pCont = &statusMsg;
+  statusRpc.contLen = sizeof(SSchTasksStatusMsg);
+  statusRpc.msgType = TDMT_VND_TASKS_STATUS;
+  
   stubSetStringToPlan();
+  stubSetRpcSendResponse();
   
   code = qWorkerInit(NULL, &mgmt);
   ASSERT_EQ(code, 0);
 
+  statusMsg.sId = htobe64(1);
+  code = qWorkerProcessStatusMsg(mockPointer, mgmt, &statusRpc);
+  ASSERT_EQ(code, 0);
+
   code = qWorkerProcessQueryMsg(mockPointer, mgmt, &queryRpc);
   ASSERT_EQ(code, 0);
 
+  statusMsg.sId = htobe64(1);
+  code = qWorkerProcessStatusMsg(mockPointer, mgmt, &statusRpc);
+  ASSERT_EQ(code, 0);
+
   code = qWorkerProcessReadyMsg(mockPointer, mgmt, &readyRpc);
   ASSERT_EQ(code, 0);
 
+  statusMsg.sId = htobe64(1);
+  code = qWorkerProcessStatusMsg(mockPointer, mgmt, &statusRpc);
+  ASSERT_EQ(code, 0);
+
   code = qWorkerProcessFetchMsg(mockPointer, mgmt, &fetchRpc);
   ASSERT_EQ(code, 0);
 
+  statusMsg.sId = htobe64(1);
+  code = qWorkerProcessStatusMsg(mockPointer, mgmt, &statusRpc);
+  ASSERT_EQ(code, 0);
+
   code = qWorkerProcessDropMsg(mockPointer, mgmt, &dropRpc);
   ASSERT_EQ(code, 0);
+
+  statusMsg.sId = htobe64(1);
+  code = qWorkerProcessStatusMsg(mockPointer, mgmt, &statusRpc);
+  ASSERT_EQ(code, 0);
+
+  qWorkerDestroy(&mgmt);
+}
+
+TEST(seqTest, cancelFirst) {
+  void *mgmt = NULL;
+  int32_t code = 0;
+  void *mockPointer = (void *)0x1;
+  SRpcMsg queryRpc = {0};
+  SRpcMsg dropRpc = {0};
+  SRpcMsg statusRpc = {0};
+  
+  SSubQueryMsg *queryMsg = (SSubQueryMsg *)calloc(1, sizeof(SSubQueryMsg) + 100);
+  queryMsg->queryId = htobe64(1);
+  queryMsg->sId = htobe64(1);
+  queryMsg->taskId = htobe64(1);
+  queryMsg->contentLen = htonl(100);
+  queryRpc.pCont = queryMsg;
+  queryRpc.contLen = sizeof(SSubQueryMsg) + 100;
+
+  STaskDropMsg dropMsg = {0};  
+  dropMsg.sId = htobe64(1);
+  dropMsg.queryId = htobe64(1);
+  dropMsg.taskId = htobe64(1);
+  dropRpc.pCont = &dropMsg;
+  dropRpc.contLen = sizeof(STaskDropMsg);
+
+  SSchTasksStatusMsg statusMsg = {0};
+  statusMsg.sId = htobe64(1);
+  statusRpc.pCont = &statusMsg;
+  statusRpc.contLen = sizeof(SSchTasksStatusMsg);
+  statusRpc.msgType = TDMT_VND_TASKS_STATUS;
+
+  stubSetStringToPlan();
+  stubSetRpcSendResponse();
+  
+  code = qWorkerInit(NULL, &mgmt);
+  ASSERT_EQ(code, 0);
+
+  statusMsg.sId = htobe64(1);
+  code = qWorkerProcessStatusMsg(mockPointer, mgmt, &statusRpc);
+  ASSERT_EQ(code, 0);
+
+  code = qWorkerProcessDropMsg(mockPointer, mgmt, &dropRpc);
+  ASSERT_EQ(code, 0);
+
+  statusMsg.sId = htobe64(1);
+  code = qWorkerProcessStatusMsg(mockPointer, mgmt, &statusRpc);
+  ASSERT_EQ(code, 0);
+
+  code = qWorkerProcessQueryMsg(mockPointer, mgmt, &queryRpc);
+  ASSERT_EQ(code, 0);
+
+  statusMsg.sId = htobe64(1);
+  code = qWorkerProcessStatusMsg(mockPointer, mgmt, &statusRpc);
+  ASSERT_EQ(code, 0);
+
+  qWorkerDestroy(&mgmt);
+}
+
+TEST(seqTest, randCase) {
+  void *mgmt = NULL;
+  int32_t code = 0;
+  void *mockPointer = (void *)0x1;
+  SRpcMsg queryRpc = {0};
+  SRpcMsg readyRpc = {0};
+  SRpcMsg fetchRpc = {0};
+  SRpcMsg dropRpc = {0};
+  SRpcMsg statusRpc = {0};
+  
+  SSubQueryMsg *queryMsg = (SSubQueryMsg *)calloc(1, sizeof(SSubQueryMsg) + 100);
+  queryMsg->queryId = htobe64(1);
+  queryMsg->sId = htobe64(1);
+  queryMsg->taskId = htobe64(1);
+  queryMsg->contentLen = htonl(100);
+  queryRpc.pCont = queryMsg;
+  queryRpc.contLen = sizeof(SSubQueryMsg) + 100;
+
+  SResReadyMsg readyMsg = {0};
+  readyMsg.sId = htobe64(1);
+  readyMsg.queryId = htobe64(1);
+  readyMsg.taskId = htobe64(1);
+  readyRpc.pCont = &readyMsg;
+  readyRpc.contLen = sizeof(SResReadyMsg);
+
+  SResFetchMsg fetchMsg = {0};
+  fetchMsg.sId = htobe64(1);
+  fetchMsg.queryId = htobe64(1);
+  fetchMsg.taskId = htobe64(1);
+  fetchRpc.pCont = &fetchMsg;
+  fetchRpc.contLen = sizeof(SResFetchMsg);
+
+  STaskDropMsg dropMsg = {0};  
+  dropMsg.sId = htobe64(1);
+  dropMsg.queryId = htobe64(1);
+  dropMsg.taskId = htobe64(1);
+  dropRpc.pCont = &dropMsg;
+  dropRpc.contLen = sizeof(STaskDropMsg);
+
+  SSchTasksStatusMsg statusMsg = {0};
+  statusMsg.sId = htobe64(1);
+  statusRpc.pCont = &statusMsg;
+  statusRpc.contLen = sizeof(SSchTasksStatusMsg);
+  statusRpc.msgType = TDMT_VND_TASKS_STATUS;
+  
+  stubSetStringToPlan();
+  stubSetRpcSendResponse();
+
+  srand(time(NULL));
+  
+  code = qWorkerInit(NULL, &mgmt);
+  ASSERT_EQ(code, 0);
+
+  int32_t t = 0;
+  int32_t maxr = 10001;
+  while (true) {
+    int32_t r = rand() % maxr;
+    
+    if (r >= 0 && r < maxr/5) {
+      printf("Query,%d\n", t++);
+      code = qWorkerProcessQueryMsg(mockPointer, mgmt, &queryRpc);
+    } else if (r >= maxr/5 && r < maxr * 2/5) {
+      printf("Ready,%d\n", t++);
+      code = qWorkerProcessReadyMsg(mockPointer, mgmt, &readyRpc);
+    } else if (r >= maxr * 2/5 && r < maxr* 3/5) {
+      printf("Fetch,%d\n", t++);
+      code = qWorkerProcessFetchMsg(mockPointer, mgmt, &fetchRpc);
+    } else if (r >= maxr * 3/5 && r < maxr * 4/5) {
+      printf("Drop,%d\n", t++);
+      code = qWorkerProcessDropMsg(mockPointer, mgmt, &dropRpc);
+    } else if (r >= maxr * 4/5 && r < maxr-1) {
+      printf("Status,%d\n", t++);
+      statusMsg.sId = htobe64(1);
+      code = qWorkerProcessStatusMsg(mockPointer, mgmt, &statusRpc);
+      ASSERT_EQ(code, 0);
+    } else {
+      printf("QUIT RAND NOW");
+      break;
+    }
+  }
+
+  qWorkerDestroy(&mgmt);
+}
+
+TEST(seqTest, multithreadRand) {
+  void *mgmt = NULL;
+  int32_t code = 0;
+  void *mockPointer = (void *)0x1;
+  
+  stubSetStringToPlan();
+  stubSetRpcSendResponse();
+
+  srand(time(NULL));
+  
+  code = qWorkerInit(NULL, &mgmt);
+  ASSERT_EQ(code, 0);
+
+  pthread_attr_t thattr;
+  pthread_attr_init(&thattr);
+
+  pthread_t t1,t2,t3,t4,t5;
+  pthread_create(&(t1), &thattr, queryThread, mgmt);
+  pthread_create(&(t2), &thattr, readyThread, NULL);
+  pthread_create(&(t3), &thattr, fetchThread, NULL);
+  pthread_create(&(t4), &thattr, dropThread, NULL);
+  pthread_create(&(t5), &thattr, statusThread, NULL);
+
+  int32_t t = 0;
+  int32_t maxr = 10001;
+  sleep(300);
+  testStop = true;
+  sleep(1);
   
+  qWorkerDestroy(&mgmt);
 }
 
 

source/libs/scheduler/inc/schedulerInt.h

@@ -38,11 +38,16 @@ enum {
 
 typedef struct SSchedulerMgmt {
   uint64_t  taskId; 
-  uint64_t  schedulerId;
+  uint64_t  sId;
   SSchedulerCfg cfg;
   SHashObj *jobs;  // key: queryId, value: SQueryJob*
 } SSchedulerMgmt;
 
+typedef struct SSchCallbackParam {
+  uint64_t queryId;
+  uint64_t taskId;
+} SSchCallbackParam;
+
 typedef struct SSchLevel {
   int32_t  level;
   int8_t   status;
@@ -120,6 +125,7 @@ typedef struct SSchJob {
 
 
 extern int32_t schLaunchTask(SSchJob *job, SSchTask *task);
+extern int32_t schBuildAndSendMsg(SSchJob *job, SSchTask *task, int32_t msgType);
 
 #ifdef __cplusplus
 }

source/libs/scheduler/test/schedulerTests.cpp

@@ -36,7 +36,7 @@
 
 namespace {
 
-extern "C" int32_t schHandleRspMsg(SSchJob *job, SSchTask *task, int32_t msgType, char *msg, int32_t msgSize, int32_t rspCode);
+extern "C" int32_t schProcessRspMsg(SSchJob *job, SSchTask *task, int32_t msgType, char *msg, int32_t msgSize, int32_t rspCode);
 
 void schtBuildQueryDag(SQueryDag *dag) {
   uint64_t qId = 0x0000000000000001;
@@ -182,7 +182,7 @@ void *schtSendRsp(void *param) {
 
     SShellSubmitRspMsg rsp = {0};
     rsp.affectedRows = 10;
-    schHandleRspMsg(job, task, TDMT_VND_SUBMIT, (char *)&rsp, sizeof(rsp), 0);
+    schProcessRspMsg(job, task, TDMT_VND_SUBMIT, (char *)&rsp, sizeof(rsp), 0);
     
     pIter = taosHashIterate(job->execTasks, pIter);
   }    
@@ -227,7 +227,7 @@ TEST(queryTest, normalCase) {
     SSchTask *task = *(SSchTask **)pIter;
 
     SQueryTableRsp rsp = {0};
-    code = schHandleRspMsg(job, task, TDMT_VND_QUERY, (char *)&rsp, sizeof(rsp), 0);
+    code = schProcessRspMsg(job, task, TDMT_VND_QUERY, (char *)&rsp, sizeof(rsp), 0);
     
     ASSERT_EQ(code, 0);
     pIter = taosHashIterate(job->execTasks, pIter);
@@ -238,7 +238,7 @@ TEST(queryTest, normalCase) {
     SSchTask *task = *(SSchTask **)pIter;
 
     SResReadyRsp rsp = {0};
-    code = schHandleRspMsg(job, task, TDMT_VND_RES_READY, (char *)&rsp, sizeof(rsp), 0);
+    code = schProcessRspMsg(job, task, TDMT_VND_RES_READY, (char *)&rsp, sizeof(rsp), 0);
     
     ASSERT_EQ(code, 0);
     pIter = taosHashIterate(job->execTasks, pIter);
@@ -249,7 +249,7 @@ TEST(queryTest, normalCase) {
     SSchTask *task = *(SSchTask **)pIter;
 
     SQueryTableRsp rsp = {0};
-    code = schHandleRspMsg(job, task, TDMT_VND_QUERY, (char *)&rsp, sizeof(rsp), 0);
+    code = schProcessRspMsg(job, task, TDMT_VND_QUERY, (char *)&rsp, sizeof(rsp), 0);
     
     ASSERT_EQ(code, 0);
     pIter = taosHashIterate(job->execTasks, pIter);
@@ -260,7 +260,7 @@ TEST(queryTest, normalCase) {
     SSchTask *task = *(SSchTask **)pIter;
 
     SResReadyRsp rsp = {0};
-    code = schHandleRspMsg(job, task, TDMT_VND_RES_READY, (char *)&rsp, sizeof(rsp), 0);
+    code = schProcessRspMsg(job, task, TDMT_VND_RES_READY, (char *)&rsp, sizeof(rsp), 0);
     ASSERT_EQ(code, 0);
     
     pIter = taosHashIterate(job->execTasks, pIter);
@@ -269,7 +269,7 @@ TEST(queryTest, normalCase) {
   SRetrieveTableRsp rsp = {0};
   rsp.completed = 1;
   rsp.numOfRows = 10;
-  code = schHandleRspMsg(job, NULL, TDMT_VND_FETCH, (char *)&rsp, sizeof(rsp), 0);
+  code = schProcessRspMsg(job, NULL, TDMT_VND_FETCH, (char *)&rsp, sizeof(rsp), 0);
     
   ASSERT_EQ(code, 0);
 

source/util/src/terror.c

@@ -79,6 +79,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_FILE_CORRUPTED,               "Data file corrupted")
 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_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")
@@ -256,6 +257,24 @@ TAOS_DEFINE_ERROR(TSDB_CODE_DND_MNODE_ID_INVALID,         "Mnode Id invalid")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_MNODE_ID_NOT_FOUND,       "Mnode Id not found")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_MNODE_READ_FILE_ERROR,    "Read mnode.json error")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_MNODE_WRITE_FILE_ERROR,   "Write mnode.json error")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_QNODE_ALREADY_DEPLOYED,   "Qnode already deployed")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_QNODE_NOT_DEPLOYED,       "Qnode not deployed")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_QNODE_ID_INVALID,         "Qnode Id invalid")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_QNODE_ID_NOT_FOUND,       "Qnode Id not found")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_QNODE_READ_FILE_ERROR,    "Read qnode.json error")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_QNODE_WRITE_FILE_ERROR,   "Write qnode.json error")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_SNODE_ALREADY_DEPLOYED,   "Snode already deployed")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_SNODE_NOT_DEPLOYED,       "Snode not deployed")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_SNODE_ID_INVALID,         "Snode Id invalid")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_SNODE_ID_NOT_FOUND,       "Snode Id not found")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_SNODE_READ_FILE_ERROR,    "Read snode.json error")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_SNODE_WRITE_FILE_ERROR,   "Write snode.json error")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_BNODE_ALREADY_DEPLOYED,   "Bnode already deployed")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_BNODE_NOT_DEPLOYED,       "Bnode not deployed")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_BNODE_ID_INVALID,         "Bnode Id invalid")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_BNODE_ID_NOT_FOUND,       "Bnode Id not found")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_BNODE_READ_FILE_ERROR,    "Read bnode.json error")
+TAOS_DEFINE_ERROR(TSDB_CODE_DND_BNODE_WRITE_FILE_ERROR,   "Write bnode.json error")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_VNODE_TOO_MANY_VNODES,    "Too many vnode directories")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_VNODE_READ_FILE_ERROR,    "Read vnodes.json error")
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_VNODE_WRITE_FILE_ERROR,   "Write vnodes.json error")
@@ -360,132 +379,6 @@ TAOS_DEFINE_ERROR(TSDB_CODE_WAL_APP_ERROR,                "Unexpected generic er
 TAOS_DEFINE_ERROR(TSDB_CODE_WAL_FILE_CORRUPTED,           "WAL file is corrupted")
 TAOS_DEFINE_ERROR(TSDB_CODE_WAL_SIZE_LIMIT,               "WAL size exceeds limit")
 
-// http
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_SERVER_OFFLINE,          "http server is not onlin")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_UNSUPPORT_URL,           "url is not support")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_INVALID_URL,            "invalid url format")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_NO_ENOUGH_MEMORY,        "no enough memory")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_REQUSET_TOO_BIG,         "request size is too big")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_NO_AUTH_INFO,            "no auth info input")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_NO_MSG_INPUT,            "request is empty")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_NO_SQL_INPUT,            "no sql input")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_NO_EXEC_USEDB,           "no need to execute use db cmd")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_SESSION_FULL,            "session list was full")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_GEN_TAOSD_TOKEN_ERR,     "generate taosd token error")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_INVALID_MULTI_REQUEST,   "size of multi request is 0")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_CREATE_GZIP_FAILED,      "failed to create gzip")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_FINISH_GZIP_FAILED,      "failed to finish gzip")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_LOGIN_FAILED,            "failed to login")
-
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_INVALID_VERSION,         "invalid http version")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_INVALID_CONTENT_LENGTH,  "invalid content length")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_INVALID_AUTH_TYPE,       "invalid type of Authorization")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_INVALID_AUTH_FORMAT,     "invalid format of Authorization")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_INVALID_BASIC_AUTH,      "invalid basic Authorization")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_INVALID_TAOSD_AUTH,      "invalid taosd Authorization")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_METHOD_FAILED,     "failed to parse method")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_TARGET_FAILED,     "failed to parse target")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_VERSION_FAILED,    "failed to parse http version")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_SP_FAILED,         "failed to parse sp")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_STATUS_FAILED,     "failed to parse status")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_PHRASE_FAILED,     "failed to parse phrase")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_CRLF_FAILED,       "failed to parse crlf")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_HEADER_FAILED,     "failed to parse header")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_HEADER_KEY_FAILED, "failed to parse header key")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_HEADER_VAL_FAILED, "failed to parse header val")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_CHUNK_SIZE_FAILED, "failed to parse chunk size")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_CHUNK_FAILED,      "failed to parse chunk")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_END_FAILED,        "failed to parse end section")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_INVALID_STATE,     "invalid parse state")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_PARSE_ERROR_STATE,       "failed to parse error section")
-
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_GC_QUERY_NULL,           "query size is 0")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_GC_QUERY_SIZE,           "query size can not more than 100")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_GC_REQ_PARSE_ERROR,      "parse grafana json error")
-
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_DB_NOT_INPUT,         "database name can not be null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_DB_TOO_LONG,          "database name too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_INVALID_JSON,         "invalid telegraf json fromat")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_METRICS_NULL,         "metrics size is 0")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_METRICS_SIZE,         "metrics size can not more than 1K")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_METRIC_NULL,          "metric name not find")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_METRIC_TYPE,          "metric name type should be string")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_METRIC_NAME_NULL,     "metric name length is 0")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_METRIC_NAME_LONG,     "metric name length too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TIMESTAMP_NULL,       "timestamp not find")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TIMESTAMP_TYPE,       "timestamp type should be integer")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TIMESTAMP_VAL_NULL,   "timestamp value smaller than 0")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TAGS_NULL,            "tags not find")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TAGS_SIZE_0,          "tags size is 0")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TAGS_SIZE_LONG,       "tags size too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TAG_NULL,             "tag is null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TAG_NAME_NULL,        "tag name is null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TAG_NAME_SIZE,        "tag name length too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TAG_VALUE_TYPE,       "tag value type should be number or string")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TAG_VALUE_NULL,       "tag value is null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TABLE_NULL,           "table is null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_TABLE_SIZE,           "table name length too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_FIELDS_NULL,          "fields not find")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_FIELDS_SIZE_0,        "fields size is 0")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_FIELDS_SIZE_LONG,     "fields size too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_FIELD_NULL,           "field is null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_FIELD_NAME_NULL,      "field name is null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_FIELD_NAME_SIZE,      "field name length too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_FIELD_VALUE_TYPE,     "field value type should be number or string")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_FIELD_VALUE_NULL,     "field value is null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_HOST_NOT_STRING,      "host type should be string")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_TG_STABLE_NOT_EXIST,     "stable not exist")
-
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_DB_NOT_INPUT,         "database name can not be null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_DB_TOO_LONG,          "database name too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_INVALID_JSON,         "invalid opentsdb json fromat")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_METRICS_NULL,         "metrics size is 0")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_METRICS_SIZE,         "metrics size can not more than 10K")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_METRIC_NULL,          "metric name not find")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_METRIC_TYPE,          "metric name type should be string")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_METRIC_NAME_NULL,     "metric name length is 0")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_METRIC_NAME_LONG,     "metric name length can not more than 22")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TIMESTAMP_NULL,       "timestamp not find")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TIMESTAMP_TYPE,       "timestamp type should be integer")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TIMESTAMP_VAL_NULL,   "timestamp value smaller than 0")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAGS_NULL,            "tags not find")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAGS_SIZE_0,          "tags size is 0")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAGS_SIZE_LONG,       "tags size too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAG_NULL,             "tag is null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAG_NAME_NULL,        "tag name is null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAG_NAME_SIZE,        "tag name length too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAG_VALUE_TYPE,       "tag value type should be boolean, number or string")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAG_VALUE_NULL,       "tag value is null")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAG_VALUE_TOO_LONG,   "tag value can not more than 64")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_NULL,           "value not find")
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_TYPE,           "value type should be boolean, number or string")
-
-TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_REQUEST_JSON_ERROR,      "http request json error")
-
-// odbc
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_OOM,                     "out of memory")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_CHAR_NOT_NUM,       "convertion not a valid literal input")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_UNDEF,              "convertion undefined")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_TRUNC_FRAC,         "convertion fractional truncated")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_TRUNC,              "convertion truncated")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_NOT_SUPPORT,        "convertion not supported")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_OOR,                "convertion numeric value out of range")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_OUT_OF_RANGE,            "out of range")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NOT_SUPPORT,             "not supported yet")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_INVALID_HANDLE,          "invalid handle")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NO_RESULT,               "no result set")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NO_FIELDS,               "no fields returned")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_INVALID_CURSOR,          "invalid cursor")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_STATEMENT_NOT_READY,     "statement not ready")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONNECTION_BUSY,         "connection still busy")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_BAD_CONNSTR,             "bad connection string")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_BAD_ARG,                 "bad argument")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_NOT_VALID_TS,       "not a valid timestamp")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_SRC_TOO_LARGE,      "src too large")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_SRC_BAD_SEQ,        "src bad sequence")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_SRC_INCOMPLETE,     "src incomplete")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_SRC_GENERAL,        "src general")
-
 // tfs
 TAOS_DEFINE_ERROR(TSDB_CODE_FS_OUT_OF_MEMORY,             "tfs out of memory")
 TAOS_DEFINE_ERROR(TSDB_CODE_FS_INVLD_CFG,                 "tfs invalid mount config")

tests/script/general/db/basic1.sim

@@ -58,4 +58,11 @@ if $data03 != 0 then
   return -1
 endi
 
+print =============== show vgroups
+sql use d4
+
+if $rows == 0 then 
+  return -1
+endi
+
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file

tests/script/general/http/autocreate.sim

-system sh/stop_dnodes.sh
-sleep 2000
-system sh/deploy.sh -n dnode1 -i 1
-system sh/cfg.sh -n dnode1 -c wallevel -v 0
-system sh/cfg.sh -n dnode1 -c http -v 1
-system sh/cfg.sh -n dnode1 -c httpEnableRecordSql -v 1
-system sh/exec.sh -n dnode1 -s start
-
-sleep 2000
-sql connect
-
-print ============================ dnode1 start
-
-print ===============  step1 - prepare data
-sql create database db
-sql use db
-sql create table if not exists db.win_cpu(ts timestamp,f_percent_dpc_time double,f_percent_idle_time double,f_percent_interrupt_time double,f_percent_privileged_time double,f_percent_processor_time double,f_percent_user_time double) tags(t_host binary(32),t_instance binary(32),t_objectname binary(32));
-
-print ===============  step2 - auto create
-
-system_content curl -H 'Authorization: Taosd /KfeAzX/f9na8qdtNZmtONryp201ma04bEl8LcvLUd7a8qdtNZmtONryp201ma04' -d 'import into db.win_cpu_windows_1_processor using db.win_cpu tags('windows','1','Processor') values(1564641722000,0.000000,95.598305,0.000000,0.000000,0.000000,0.000000);' 127.0.0.1:7111/rest/sql
-print curl 127.0.0.1:7111/rest/sql -----> $system_content
-#if $system_content != @{"status":"succ","head":["ts","i"],"data":[["2017-12-25 21:28:41.022",1],["2017-12-25 21:28:42.022",2],["2017-12-25 21:28:43.022",3],["2017-12-25 21:28:44.022",4],["2017-12-25 21:28:45.022",5],["2017-12-25 21:28:46.022",6],["2017-12-25 21:28:47.022",7],["2017-12-25 21:28:48.022",8],["2017-12-25 21:28:49.022",9],["2017-12-25 21:28:50.022",10],["2017-12-25 21:28:51.022",11]],"rows":11}@ then
-#  return -1
-#endi
-
-sql select * from db.win_cpu_windows_1_processor
-print rows: $rows
-if $rows != 1 then
-  return -1
-endi
-
-#system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file