Merge branch '3.0' of https://github.com/taosdata/TDengine into feat--tag-index

Jenkinsfile2

@@ -33,7 +33,18 @@ def abort_previous(){
     milestone(buildNumber)
 }
 def pre_test(){
-    sh 'hostname'
+    sh '''
+        hostname
+        date
+    '''
+    sh '''
+        cd ${WK}
+        git reset --hard
+        git fetch || git fetch
+        cd ${WKC}
+        git reset --hard
+        git fetch || git fetch
+    '''
     script {
         if (env.CHANGE_TARGET == 'master') {
             sh '''
@@ -222,7 +233,7 @@ pipeline {
                         changeRequest()
                     }
                     steps {
-                        timeout(time: 20, unit: 'MINUTES'){
+                        timeout(time: 40, unit: 'MINUTES'){
                             pre_test()
                             script {
                                 sh '''
@@ -234,8 +245,9 @@ pipeline {
                                 '''
                                 sh '''
                                     cd ${WKC}/tests/parallel_test
+                                    export DEFAULT_RETRY_TIME=2
                                     date
-                                    time ./run.sh -e -m /home/m.json -t /tmp/cases.task -b ${CHANGE_TARGET} -l ${WKDIR}/log
+                                    timeout 2100 time ./run.sh -e -m /home/m.json -t /tmp/cases.task -b ${BRANCH_NAME} -l ${WKDIR}/log -o 480
                                 '''
                             }
                         }

contrib/CMakeLists.txt

@@ -365,7 +365,7 @@ if(${BUILD_ADDR2LINE})
     if(HAVE_LIBELF_H OR HAVE_LIBELF_LIBELF_H)
         target_link_libraries(libdwarf PUBLIC libelf)
     endif()
-    target_include_directories(libdwarf SYSTEM PUBLIC "libdwarf/src/lib/libdwarf" ${CMAKE_BINARY_DIR}/contrib)
+    target_include_directories(libdwarf SYSTEM PUBLIC "libdwarf/src/lib/libdwarf" ${CMAKE_CURRENT_BINARY_DIR})
     file(READ "addr2line/addr2line.c" ADDR2LINE_CONTENT)
     string(REPLACE "static int" "int" ADDR2LINE_CONTENT "${ADDR2LINE_CONTENT}")
     string(REPLACE "static void" "void" ADDR2LINE_CONTENT "${ADDR2LINE_CONTENT}")

include/common/tcommon.h

@@ -204,7 +204,6 @@ typedef struct {
   const char*   key;
   int32_t       keyLen;
   uint8_t       type;
-  int16_t length;
   union{
     const char* value;
     int64_t     i;
@@ -212,7 +211,7 @@ typedef struct {
     double      d;
     float       f;
   };
-  int32_t valueLen;
+  int32_t       length;
 } SSmlKv;
 
 #define QUERY_ASC_FORWARD_STEP  1

include/common/tglobal.h

@@ -34,7 +34,6 @@ extern int32_t  tsVersion;
 extern int32_t  tsStatusInterval;
 
 // common
-extern int32_t tsMaxConnections;
 extern int32_t tsMaxShellConns;
 extern int32_t tsShellActivityTimer;
 extern int32_t tsCompressMsgSize;

include/common/tmsgcb.h

@@ -37,11 +37,12 @@ typedef enum {
   QUEUE_MAX,
 } EQueueType;
 
-typedef int32_t (*PutToQueueFp)(SMgmtWrapper* pWrapper, SRpcMsg* pReq);
-typedef int32_t (*GetQueueSizeFp)(SMgmtWrapper* pWrapper, int32_t vgId, EQueueType qtype);
+typedef int32_t (*PutToQueueFp)(void *pMgmt, SRpcMsg* pReq);
+typedef int32_t (*GetQueueSizeFp)(void *pMgmt, int32_t vgId, EQueueType qtype);
 typedef int32_t (*SendReqFp)(SMgmtWrapper* pWrapper, const SEpSet* epSet, SRpcMsg* pReq);
 typedef int32_t (*SendMnodeReqFp)(SMgmtWrapper* pWrapper, SRpcMsg* pReq);
 typedef void (*SendRspFp)(SMgmtWrapper* pWrapper, const SRpcMsg* pRsp);
+typedef void (*SendMnodeRecvFp)(SMgmtWrapper* pWrapper, SRpcMsg* pReq, SRpcMsg* pRsp);
 typedef void (*SendRedirectRspFp)(SMgmtWrapper* pWrapper, const SRpcMsg* pRsp, const SEpSet* pNewEpSet);
 typedef void (*RegisterBrokenLinkArgFp)(SMgmtWrapper* pWrapper, SRpcMsg* pMsg);
 typedef void (*ReleaseHandleFp)(SMgmtWrapper* pWrapper, void* handle, int8_t type);
@@ -49,23 +50,26 @@ typedef void (*ReportStartup)(SMgmtWrapper* pWrapper, const char* name, const ch
 
 typedef struct {
   SMgmtWrapper*           pWrapper;
+  void*                   pMgmt;
+  void*                   clientRpc;
   PutToQueueFp            queueFps[QUEUE_MAX];
   GetQueueSizeFp          qsizeFp;
   SendReqFp               sendReqFp;
   SendRspFp               sendRspFp;
+  SendMnodeRecvFp         sendMnodeRecvFp;
   SendRedirectRspFp       sendRedirectRspFp;
   RegisterBrokenLinkArgFp registerBrokenLinkArgFp;
   ReleaseHandleFp         releaseHandleFp;
   ReportStartup           reportStartupFp;
-  void*                   clientRpc;
 } SMsgCb;
 
 void    tmsgSetDefaultMsgCb(const SMsgCb* pMsgCb);
 int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pReq);
 int32_t tmsgGetQueueSize(const SMsgCb* pMsgCb, int32_t vgId, EQueueType qtype);
 int32_t tmsgSendReq(const SMsgCb* pMsgCb, const SEpSet* epSet, SRpcMsg* pReq);
-void    tmsgSendRsp(const SRpcMsg* pRsp);
-void    tmsgSendRedirectRsp(const SRpcMsg* pRsp, const SEpSet* pNewEpSet);
+void    tmsgSendRsp(SRpcMsg* pRsp);
+void    tmsgSendMnodeRecv(SRpcMsg* pReq, SRpcMsg* pRsp);
+void    tmsgSendRedirectRsp(SRpcMsg* pRsp, const SEpSet* pNewEpSet);
 void    tmsgRegisterBrokenLinkArg(const SMsgCb* pMsgCb, SRpcMsg* pMsg);
 void    tmsgReleaseHandle(void* handle, int8_t type);
 void    tmsgReportStartup(const char* name, const char* desc);

include/util/tdef.h

@@ -425,9 +425,12 @@ enum {
   SND_WORKER_TYPE__UNIQUE,
 };
 
-#define MNODE_HANDLE   -1
-#define QNODE_HANDLE   1
 #define DEFAULT_HANDLE 0
+#define MNODE_HANDLE   -1
+#define QNODE_HANDLE   -2
+#define SNODE_HANDLE   -3
+#define VNODE_HANDLE   -4
+#define BNODE_HANDLE   -5
 
 #define TSDB_CONFIG_OPTION_LEN 16
 #define TSDB_CONIIG_VALUE_LEN  48

include/util/tjson.h

@@ -22,17 +22,12 @@
 extern "C" {
 #endif
 
-#ifdef WINDOWS
-#define tjsonGetNumberValue(pJson, pName, val) -1
-#else
-#define tjsonGetNumberValue(pJson, pName, val) \
-  ({ \
+#define tjsonGetNumberValue(pJson, pName, val, code)  \
+  do {                                                \
     uint64_t _tmp = 0;                                \
-    int32_t _code = tjsonGetUBigIntValue(pJson, pName, &_tmp); \
+    code = tjsonGetUBigIntValue(pJson, pName, &_tmp); \
     val = _tmp;                                       \
-    _code; \
-  })
-#endif
+  } while (0)
 
 typedef void SJson;
 

source/client/inc/clientStmt.h

@@ -63,7 +63,7 @@ typedef struct SStmtBindInfo {
   int8_t       tbType;
   bool         tagsCached;
   void*        boundTags;  
-  char         tbName[TSDB_TABLE_FNAME_LEN];;
+  char         tbName[TSDB_TABLE_FNAME_LEN];
   char         tbFName[TSDB_TABLE_FNAME_LEN];
   char         stbFName[TSDB_TABLE_FNAME_LEN];
   SName        sname;
@@ -71,7 +71,6 @@ typedef struct SStmtBindInfo {
 
 typedef struct SStmtExecInfo {
   int32_t      affectedRows;
-  bool         emptyRes;
   SRequestObj* pRequest;
   SHashObj*    pVgHash;
   SHashObj*    pBlockHash;
@@ -87,7 +86,6 @@ typedef struct SStmtSQLInfo {
   char*             sqlStr;
   int32_t           sqlLen;
   SArray*           nodeList;
-  SQueryPlan*       pQueryPlan;
   SStmtQueryResInfo queryRes;
   bool              autoCreateTbl;
 } SStmtSQLInfo;

source/client/src/clientEnv.c

@@ -91,7 +91,7 @@ void *openTransporter(const char *user, const char *auth, int32_t numOfThread) {
   rpcInit.label = "TSC";
   rpcInit.numOfThreads = numOfThread;
   rpcInit.cfp = processMsgFromServer;
-  rpcInit.sessions = tsMaxConnections;
+  rpcInit.sessions = 1024;
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.user = (char *)user;
   rpcInit.idleTime = tsShellActivityTimer * 1000;

source/client/src/clientStmt.c

@@ -279,7 +279,6 @@ int32_t stmtCleanExecInfo(STscStmt* pStmt, bool keepTable, bool freeRequest) {
   }
 
   pStmt->exec.autoCreateTbl = false;
-  pStmt->exec.emptyRes = false;
   
   if (keepTable) {
     return TSDB_CODE_SUCCESS;
@@ -298,7 +297,6 @@ int32_t stmtCleanSQLInfo(STscStmt* pStmt) {
   taosMemoryFree(pStmt->sql.queryRes.userFields);
   taosMemoryFree(pStmt->sql.sqlStr);
   qDestroyQuery(pStmt->sql.pQuery);
-  qDestroyQueryPlan(pStmt->sql.pQueryPlan);
   taosArrayDestroy(pStmt->sql.nodeList);
 
   void* pIter = taosHashIterate(pStmt->sql.pTableCache, NULL);
@@ -599,6 +597,8 @@ int32_t stmtFetchColFields(STscStmt* pStmt, int32_t* fieldNum, TAOS_FIELD** fiel
 int stmtBindBatch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int32_t colIdx) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
+  STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_BIND));
+
   if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 &&
       STMT_TYPE_MULTI_INSERT != pStmt->sql.type) {
     pStmt->bInfo.needParse = false;
@@ -617,19 +617,40 @@ int stmtBindBatch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int32_t colIdx) {
     STMT_ERR_RET(stmtParseSql(pStmt));
   }
 
-  STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_BIND));
-
   if (STMT_TYPE_QUERY == pStmt->sql.type) {
-    if (NULL == pStmt->sql.pQueryPlan) {
-      STMT_ERR_RET(getQueryPlan(pStmt->exec.pRequest, pStmt->sql.pQuery, &pStmt->sql.nodeList));
-      pStmt->sql.pQueryPlan = pStmt->exec.pRequest->body.pDag;
-      pStmt->exec.pRequest->body.pDag = NULL;
-      STMT_ERR_RET(stmtBackupQueryFields(pStmt));
-    } else {
-      STMT_ERR_RET(stmtRestoreQueryFields(pStmt));
+    STMT_ERR_RET(qStmtBindParams(pStmt->sql.pQuery, bind, colIdx, pStmt->exec.pRequest->requestId));
+    
+    SParseContext ctx = {.requestId = pStmt->exec.pRequest->requestId,
+                         .acctId = pStmt->taos->acctId,
+                         .db = pStmt->exec.pRequest->pDb,
+                         .topicQuery = false,
+                         .pSql = pStmt->sql.sqlStr,
+                         .sqlLen = pStmt->sql.sqlLen,
+                         .pMsg = pStmt->exec.pRequest->msgBuf,
+                         .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE,
+                         .pTransporter = pStmt->taos->pAppInfo->pTransporter,
+                         .pStmtCb = NULL,
+                         .pUser = pStmt->taos->user};
+    ctx.mgmtEpSet = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp);
+    STMT_ERR_RET(catalogGetHandle(pStmt->taos->pAppInfo->clusterId, &ctx.pCatalog));
+    
+    STMT_ERR_RET(qStmtParseQuerySql(&ctx, pStmt->sql.pQuery));
+
+    if (pStmt->sql.pQuery->haveResultSet) {
+      setResSchemaInfo(&pStmt->exec.pRequest->body.resInfo, pStmt->sql.pQuery->pResSchema, pStmt->sql.pQuery->numOfResCols);
+      setResPrecision(&pStmt->exec.pRequest->body.resInfo, pStmt->sql.pQuery->precision);
     }
   
-    STMT_RET(qStmtBindParam(pStmt->sql.pQueryPlan, bind, colIdx, pStmt->exec.pRequest->requestId, &pStmt->exec.emptyRes));
+    TSWAP(pStmt->exec.pRequest->dbList, pStmt->sql.pQuery->pDbList);
+    TSWAP(pStmt->exec.pRequest->tableList, pStmt->sql.pQuery->pTableList);  
+
+    //if (STMT_TYPE_QUERY == pStmt->sql.queryRes) {
+    //  STMT_ERR_RET(stmtRestoreQueryFields(pStmt));
+    //}
+
+    //STMT_ERR_RET(stmtBackupQueryFields(pStmt));
+
+    return TSDB_CODE_SUCCESS;
   }
  
   STableDataBlocks **pDataBlock = (STableDataBlocks**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
@@ -736,11 +757,7 @@ int stmtExec(TAOS_STMT *stmt) {
   STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_EXECUTE));
 
   if (STMT_TYPE_QUERY == pStmt->sql.type) {
-    if (pStmt->exec.emptyRes) {
-      pStmt->exec.pRequest->type = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
-    } else {
-      scheduleQuery(pStmt->exec.pRequest, pStmt->sql.pQueryPlan, pStmt->sql.nodeList, NULL);
-    }
+    launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, TSDB_CODE_SUCCESS, true, NULL);
   } else {
     STMT_ERR_RET(qBuildStmtOutput(pStmt->sql.pQuery, pStmt->exec.pVgHash, pStmt->exec.pBlockHash));
     launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, TSDB_CODE_SUCCESS, true, (autoCreateTbl ? (void**)&pRsp : NULL));
@@ -839,16 +856,7 @@ int stmtGetParamNum(TAOS_STMT* stmt, int* nums) {
   }
 
   if (STMT_TYPE_QUERY == pStmt->sql.type) {
-    if (NULL == pStmt->sql.pQueryPlan) {
-      STMT_ERR_RET(getQueryPlan(pStmt->exec.pRequest, pStmt->sql.pQuery, &pStmt->sql.nodeList));
-      pStmt->sql.pQueryPlan = pStmt->exec.pRequest->body.pDag;
-      pStmt->exec.pRequest->body.pDag = NULL;
-      STMT_ERR_RET(stmtBackupQueryFields(pStmt));
-    } else {
-      STMT_ERR_RET(stmtRestoreQueryFields(pStmt));
-    }
-
-    *nums = taosArrayGetSize(pStmt->sql.pQueryPlan->pPlaceholderValues);
+    *nums = taosArrayGetSize(pStmt->sql.pQuery->pPlaceholderValues);
   } else {
     STMT_ERR_RET(stmtFetchColFields(stmt, nums, NULL));
   }

source/client/test/smlTest.cpp

@@ -228,7 +228,7 @@ TEST(testCase, smlParseCols_tag_Test) {
   ASSERT_EQ(strncasecmp(kv->key, "cbin", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_NCHAR);
-  ASSERT_EQ(kv->valueLen, 17);
+  ASSERT_EQ(kv->length, 17);
   ASSERT_EQ(strncasecmp(kv->value, "\"passit", 7), 0);
   taosMemoryFree(kv);
 
@@ -237,7 +237,7 @@ TEST(testCase, smlParseCols_tag_Test) {
   ASSERT_EQ(strncasecmp(kv->key, "cf64", 4), 0);
   ASSERT_EQ(kv->keyLen, 4);
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_NCHAR);
-  ASSERT_EQ(kv->valueLen, 7);
+  ASSERT_EQ(kv->length, 7);
   ASSERT_EQ(strncasecmp(kv->value, "4.31f64", 7), 0);
   taosMemoryFree(kv);
 
@@ -259,7 +259,7 @@ TEST(testCase, smlParseCols_tag_Test) {
   ASSERT_EQ(strncasecmp(kv->key, TAG, strlen(TAG)), 0);
   ASSERT_EQ(kv->keyLen, strlen(TAG));
   ASSERT_EQ(kv->type, TSDB_DATA_TYPE_NCHAR);
-  ASSERT_EQ(kv->valueLen, strlen(TAG));
+  ASSERT_EQ(kv->length, strlen(TAG));
   ASSERT_EQ(strncasecmp(kv->value, TAG, strlen(TAG)), 0);
   taosMemoryFree(kv);
 
@@ -499,12 +499,14 @@ TEST(testCase, smlProcess_influx_Test) {
   TAOS_RES *res = taos_query(taos, "select * from t_6885c584b98481584ee13dac399e173d");
   ASSERT_NE(res, nullptr);
   int fieldNum = taos_field_count(res);
-  ASSERT_EQ(fieldNum, 11);
+  ASSERT_EQ(fieldNum, 5);
   int rowNum = taos_affected_rows(res);
   ASSERT_EQ(rowNum, 2);
   for (int i = 0; i < rowNum; ++i) {
     TAOS_ROW rows = taos_fetch_row(res);
   }
+  taos_free_result(res);
+  smlDestroyInfo(info);
 }
 
 // different types
@@ -530,9 +532,11 @@ TEST(testCase, smlParseLine_error_Test) {
   };
   int ret = smlProcess(info, (char **)sql, sizeof(sql)/sizeof(sql[0]));
   ASSERT_NE(ret, 0);
+  destroyRequest(request);
+  smlDestroyInfo(info);
 }
 
- TEST(testCase, smlGetTimestampLen_Test) {
+TEST(testCase, smlGetTimestampLen_Test) {
   uint8_t len = smlGetTimestampLen(0);
   ASSERT_EQ(len, 1);
 
@@ -553,9 +557,9 @@ TEST(testCase, smlParseLine_error_Test) {
 
   len = smlGetTimestampLen(-390);
   ASSERT_EQ(len, 3);
- }
+}
 
- TEST(testCase, smlProcess_telnet_Test) {
+TEST(testCase, smlProcess_telnet_Test) {
   TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(taos, nullptr);
 
@@ -571,11 +575,12 @@ TEST(testCase, smlParseLine_error_Test) {
   SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
   ASSERT_NE(info, nullptr);
 
-   const char *sql[4] = {
+  const char *sql[5] = {
      "sys.if.bytes.out 1479496100 1.3E0 host=web01 interface=eth0",
-       "sys.if.bytes.out 1479496101 1.3E1 interface=eth0 host=web01 ",
+     "sys.if.bytes.out 1479496101 1.3E1 interface=eth0 host=web01",
      "sys.if.bytes.out 1479496102 1.3E3 network=tcp",
-       "sys.procs.running 1479496100 42 host=web01"
+     "sys.procs.running 1479496100 42 host=web01 ",
+     " sys.procs.running 1479496200 42 host=web01=4"
   };
   int ret = smlProcess(info, (char**)sql, sizeof(sql)/sizeof(sql[0]));
   ASSERT_EQ(ret, 0);
@@ -589,6 +594,7 @@ TEST(testCase, smlParseLine_error_Test) {
   for (int i = 0; i < rowNum; ++i) {
    TAOS_ROW rows = taos_fetch_row(res);
   }
+  taos_free_result(pRes);
 
   res = taos_query(taos, "select * from t_6931529054e5637ca92c78a1ad441961");
   ASSERT_NE(res, nullptr);
@@ -599,25 +605,28 @@ TEST(testCase, smlParseLine_error_Test) {
   for (int i = 0; i < rowNum; ++i) {
    TAOS_ROW rows = taos_fetch_row(res);
   }
- }
+  taos_free_result(pRes);
+  smlDestroyInfo(info);
+}
 
- TEST(testCase, smlProcess_json_Test) {
+TEST(testCase, smlProcess_json1_Test) {
   TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(taos, nullptr);
 
-   TAOS_RES* pRes = taos_query(taos, "create database if not exists sml_db");
+  TAOS_RES *pRes = taos_query(taos, "create database if not exists sml_db");
   taos_free_result(pRes);
 
   pRes = taos_query(taos, "use sml_db");
   taos_free_result(pRes);
 
-   SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
+  SRequestObj *request = (SRequestObj *)createRequest((STscObj *)taos, NULL, NULL, TSDB_SQL_INSERT);
   ASSERT_NE(request, nullptr);
 
   SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
   ASSERT_NE(info, nullptr);
 
-   const char *sql = "[\n"
+  const char *sql =
+     "[\n"
      "    {\n"
      "        \"metric\": \"sys.cpu.nice\",\n"
      "        \"timestamp\": 1346846400,\n"
@@ -637,21 +646,40 @@ TEST(testCase, smlParseLine_error_Test) {
      "        }\n"
      "    }\n"
      "]";
-   int ret = smlProcess(info, (char**)(&sql), -1);
+  int ret = smlProcess(info, (char **)(&sql), -1);
   ASSERT_EQ(ret, 0);
 
   TAOS_RES *res = taos_query(taos, "select * from t_cb27a7198d637b4f1c6464bd73f756a7");
   ASSERT_NE(res, nullptr);
   int fieldNum = taos_field_count(res);
   ASSERT_EQ(fieldNum, 2);
-//   int rowNum = taos_affected_rows(res);
-//   ASSERT_EQ(rowNum, 1);
-//   for (int i = 0; i < rowNum; ++i) {
-//     TAOS_ROW rows = taos_fetch_row(res);
-//   }
-
-   sql = "{\n"
-       "    \"metric\": \"meter_current\",\n"
+  //   int rowNum = taos_affected_rows(res);
+  //   ASSERT_EQ(rowNum, 1);
+  //   for (int i = 0; i < rowNum; ++i) {
+  //     TAOS_ROW rows = taos_fetch_row(res);
+  //   }
+  taos_free_result(pRes);
+  smlDestroyInfo(info);
+}
+
+TEST(testCase, smlProcess_json2_Test) {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(taos, nullptr);
+
+  TAOS_RES *pRes = taos_query(taos, "create database if not exists sml_db");
+  taos_free_result(pRes);
+
+  pRes = taos_query(taos, "use sml_db");
+  taos_free_result(pRes);
+
+  SRequestObj *request = (SRequestObj *)createRequest((STscObj *)taos, NULL, NULL, TSDB_SQL_INSERT);
+  ASSERT_NE(request, nullptr);
+
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  ASSERT_NE(info, nullptr);
+  const char *sql =
+     "{\n"
+     "    \"metric\": \"meter_current0\",\n"
      "    \"timestamp\": {\n"
      "        \"value\"  : 1346846400,\n"
      "        \"type\"   : \"s\"\n"
@@ -672,11 +700,30 @@ TEST(testCase, smlParseLine_error_Test) {
      "       \"id\": \"d1001\"\n"
      "    }\n"
      "}";
-   ret = smlProcess(info, (char**)(&sql), -1);
+  int32_t ret = smlProcess(info, (char **)(&sql), -1);
   ASSERT_EQ(ret, 0);
+  taos_free_result(pRes);
+  smlDestroyInfo(info);
+}
 
-   sql = "{\n"
-       "    \"metric\": \"meter_current\",\n"
+TEST(testCase, smlProcess_json3_Test) {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(taos, nullptr);
+
+  TAOS_RES *pRes = taos_query(taos, "create database if not exists sml_db");
+  taos_free_result(pRes);
+
+  pRes = taos_query(taos, "use sml_db");
+  taos_free_result(pRes);
+
+  SRequestObj *request = (SRequestObj *)createRequest((STscObj *)taos, NULL, NULL, TSDB_SQL_INSERT);
+  ASSERT_NE(request, nullptr);
+
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  ASSERT_NE(info, nullptr);
+  const char *sql =
+     "{\n"
+     "    \"metric\": \"meter_current1\",\n"
      "    \"timestamp\": {\n"
      "        \"value\"  : 1346846400,\n"
      "        \"type\"   : \"s\"\n"
@@ -716,7 +763,7 @@ TEST(testCase, smlParseLine_error_Test) {
      "       },\n"
      "       \"t8\": { \n"
      "           \"value\" : \"北京\",\n"
-       "           \"type\"  : \"binary\"\n"
+     "           \"type\"  : \"nchar\"\n"
      "       },\n"
      "       \"t9\": { \n"
      "           \"value\" : true,\n"
@@ -725,13 +772,31 @@ TEST(testCase, smlParseLine_error_Test) {
      "       \"id\": \"d1001\"\n"
      "    }\n"
      "}";
-   ret = smlProcess(info, (char**)(&sql), -1);
+  int32_t ret = smlProcess(info, (char **)(&sql), -1);
   ASSERT_EQ(ret, 0);
+  taos_free_result(pRes);
+  smlDestroyInfo(info);
+}
 
-   sql = "{\n"
-       "    \"metric\": \"meter_current\",\n"
+TEST(testCase, smlProcess_json4_Test) {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(taos, nullptr);
+
+  TAOS_RES* pRes = taos_query(taos, "create database if not exists sml_db");
+  taos_free_result(pRes);
+
+  pRes = taos_query(taos, "use sml_db");
+  taos_free_result(pRes);
+
+  SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
+  ASSERT_NE(request, nullptr);
+
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  ASSERT_NE(info, nullptr);
+  const char *sql = "{\n"
+     "    \"metric\": \"meter_current2\",\n"
      "    \"timestamp\": {\n"
-       "        \"value\"  : 1346846400000,\n"
+     "        \"value\"  : 1346846500000,\n"
      "        \"type\"   : \"ms\"\n"
      "    },\n"
      "    \"value\": \"ni\",\n"
@@ -763,12 +828,246 @@ TEST(testCase, smlParseLine_error_Test) {
      "       \"t7\": \"nsj\",\n"
      "       \"t8\": { \n"
      "           \"value\" : \"北京\",\n"
-       "           \"type\"  : \"binary\"\n"
+     "           \"type\"  : \"nchar\"\n"
      "       },\n"
      "       \"t9\": false,\n"
      "       \"id\": \"d1001\"\n"
      "    }\n"
      "}";
-   ret = smlProcess(info, (char**)(&sql), -1);
+  int32_t ret = smlProcess(info, (char**)(&sql), -1);
   ASSERT_EQ(ret, 0);
+  taos_free_result(pRes);
+  smlDestroyInfo(info);
+}
+
+TEST(testCase, smlParseTelnetLine_error_Test) {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(taos, nullptr);
+
+  TAOS_RES* pRes = taos_query(taos, "create database if not exists sml_db");
+  taos_free_result(pRes);
+
+  pRes = taos_query(taos, "use sml_db");
+  taos_free_result(pRes);
+
+  SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
+  ASSERT_NE(request, nullptr);
+
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  ASSERT_NE(info, nullptr);
+
+  int32_t ret = 0;
+  const char *sql[19] = {
+      "sys.procs.running 14794961040 42 host=web01",
+      "sys.procs.running 14791040 42 host=web01",
+      "sys.procs.running erere 42 host=web01",
+      "sys.procs.running 1.6e10 42 host=web01",
+      "sys.procs.running 1.47949610 42 host=web01",
+      "sys.procs.running 147949610i 42 host=web01",
+      "sys.procs.running -147949610 42 host=web01",
+      "",
+      "   ",
+      "sys  ",
+      "sys.procs.running 1479496100 42 ",
+      "sys.procs.running 1479496100 42 host= ",
+      "sys.procs.running 1479496100 42or host=web01",
+      "sys.procs.running 1479496100 true host=web01",
+      "sys.procs.running 1479496100 \"binary\" host=web01",
+      "sys.procs.running 1479496100 L\"rfr\" host=web01",
+      "sys.procs.running 1479496100 42 host=web01 cpu= ",
+      "sys.procs.running 1479496100 42 host=web01 host=w2",
+      "sys.procs.running 1479496100 42 host=web01 host",
+  };
+  for(int i = 0; i < sizeof(sql)/sizeof(sql[0]); i++){
+    ret = smlParseTelnetLine(info, (void*)sql[i]);
+    ASSERT_NE(ret, 0);
+  }
+
+  destroyRequest(request);
+  smlDestroyInfo(info);
+}
+
+TEST(testCase, smlParseTelnetLine_diff_type_Test) {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(taos, nullptr);
+
+  TAOS_RES* pRes = taos_query(taos, "create database if not exists sml_db");
+  taos_free_result(pRes);
+
+  pRes = taos_query(taos, "use sml_db");
+  taos_free_result(pRes);
+
+  SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
+  ASSERT_NE(request, nullptr);
+
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  ASSERT_NE(info, nullptr);
+
+  const char *sql[2] = {
+      "sys.procs.running 1479496104000 42 host=web01",
+      "sys.procs.running 1479496104000 42u8 host=web01"
+  };
+  int32_t ret = smlProcess(info, (char**)sql, sizeof(sql)/sizeof(sql[0]));
+  ASSERT_NE(ret, 0);
+
+  destroyRequest(request);
+  smlDestroyInfo(info);
+}
+
+TEST(testCase, smlParseTelnetLine_json_error_Test) {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(taos, nullptr);
+
+  TAOS_RES* pRes = taos_query(taos, "create database if not exists sml_db");
+  taos_free_result(pRes);
+
+  pRes = taos_query(taos, "use sml_db");
+  taos_free_result(pRes);
+
+  SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
+  ASSERT_NE(request, nullptr);
+
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  ASSERT_NE(info, nullptr);
+
+  int32_t ret = 0;
+  const char *sql[] = {
+      "[\n"
+      "    {\n"
+      "        \"metric\": \"sys.cpu.nice\",\n"
+      "        \"timestamp\": 13468464009999333322222223,\n"
+      "        \"value\": 18,\n"
+      "        \"tags\": {\n"
+      "           \"host\": \"web01\",\n"
+      "           \"dc\": \"lga\"\n"
+      "        }\n"
+      "    },\n"
+      "]",
+      "[\n"
+      "    {\n"
+      "        \"metric\": \"sys.cpu.nice\",\n"
+      "        \"timestamp\": 1346846400i,\n"
+      "        \"value\": 18,\n"
+      "        \"tags\": {\n"
+      "           \"host\": \"web01\",\n"
+      "           \"dc\": \"lga\"\n"
+      "        }\n"
+      "    },\n"
+      "]",
+      "[\n"
+      "    {\n"
+      "        \"metric\": \"sys.cpu.nice\",\n"
+      "        \"timestamp\": 1346846400,\n"
+      "        \"value\": 18,\n"
+      "        \"tags\": {\n"
+      "           \"groupid\": { \n"
+      "                 \"value\" : 2,\n"
+      "                 \"type\"  : \"nchar\"\n"
+      "             },\n"
+      "           \"location\": { \n"
+      "                 \"value\" : \"北京\",\n"
+      "                 \"type\"  : \"binary\"\n"
+      "             },\n"
+      "           \"id\": \"d1001\"\n"
+      "         }\n"
+      "    },\n"
+      "]",
+  };
+  for(int i = 0; i < sizeof(sql)/sizeof(sql[0]); i++){
+    ret = smlParseTelnetLine(info, (void*)sql[i]);
+    ASSERT_NE(ret, 0);
   }
+
+  destroyRequest(request);
+  smlDestroyInfo(info);
+}
+
+TEST(testCase, smlParseTelnetLine_diff_json_type1_Test) {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(taos, nullptr);
+
+  TAOS_RES* pRes = taos_query(taos, "create database if not exists sml_db");
+  taos_free_result(pRes);
+
+  pRes = taos_query(taos, "use sml_db");
+  taos_free_result(pRes);
+
+  SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
+  ASSERT_NE(request, nullptr);
+
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  ASSERT_NE(info, nullptr);
+
+  const char *sql[2] = {
+      "[\n"
+      "    {\n"
+      "        \"metric\": \"sys.cpu.nice\",\n"
+      "        \"timestamp\": 1346846400,\n"
+      "        \"value\": 18,\n"
+      "        \"tags\": {\n"
+      "           \"host\": \"lga\"\n"
+      "        }\n"
+      "    },\n"
+      "]",
+      "[\n"
+      "    {\n"
+      "        \"metric\": \"sys.cpu.nice\",\n"
+      "        \"timestamp\": 1346846400,\n"
+      "        \"value\": 18,\n"
+      "        \"tags\": {\n"
+      "           \"host\": 8\n"
+      "        }\n"
+      "    },\n"
+      "]",
+  };
+  int32_t ret = smlProcess(info, (char**)sql, sizeof(sql)/sizeof(sql[0]));
+  ASSERT_NE(ret, 0);
+
+  destroyRequest(request);
+  smlDestroyInfo(info);
+}
+
+TEST(testCase, smlParseTelnetLine_diff_json_type2_Test) {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(taos, nullptr);
+
+  TAOS_RES* pRes = taos_query(taos, "create database if not exists sml_db");
+  taos_free_result(pRes);
+
+  pRes = taos_query(taos, "use sml_db");
+  taos_free_result(pRes);
+
+  SRequestObj *request = (SRequestObj *)createRequest((STscObj*)taos, NULL, NULL, TSDB_SQL_INSERT);
+  ASSERT_NE(request, nullptr);
+
+  SSmlHandle *info = smlBuildSmlInfo(taos, request, TSDB_SML_TELNET_PROTOCOL, TSDB_SML_TIMESTAMP_NANO_SECONDS, true);
+  ASSERT_NE(info, nullptr);
+
+  const char *sql[2] = {
+      "[\n"
+      "    {\n"
+      "        \"metric\": \"sys.cpu.nice\",\n"
+      "        \"timestamp\": 1346846400,\n"
+      "        \"value\": 18,\n"
+      "        \"tags\": {\n"
+      "           \"host\": \"lga\"\n"
+      "        }\n"
+      "    },\n"
+      "]",
+      "[\n"
+      "    {\n"
+      "        \"metric\": \"sys.cpu.nice\",\n"
+      "        \"timestamp\": 1346846400,\n"
+      "        \"value\": \"18\",\n"
+      "        \"tags\": {\n"
+      "           \"host\": \"fff\"\n"
+      "        }\n"
+      "    },\n"
+      "]",
+  };
+  int32_t ret = smlProcess(info, (char**)sql, sizeof(sql)/sizeof(sql[0]));
+  ASSERT_NE(ret, 0);
+
+  destroyRequest(request);
+  smlDestroyInfo(info);
+}

source/common/src/systable.c

@@ -26,7 +26,7 @@ static const SSysDbTableSchema dnodesSchema[] = {
     {.name = "id", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT},
     {.name = "endpoint", .bytes = TSDB_EP_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
     {.name = "vnodes", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT},
-    {.name = "max_vnodes", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT},
+    {.name = "support_vnodes", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT},
     {.name = "status", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
     {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP},
     {.name = "note", .bytes = 256 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},

source/common/src/tglobal.c

@@ -33,18 +33,17 @@ int32_t  tsStatusInterval = 1;  // second
 
 // common
 int32_t tsMaxShellConns = 50000;
-int32_t tsMaxConnections = 50000;
 int32_t tsShellActivityTimer = 3;  // second
 bool    tsEnableSlaveQuery = true;
 bool    tsPrintAuth = false;
 
 // multi process
 bool    tsMultiProcess = false;
-int32_t tsMnodeShmSize = TSDB_MAX_WAL_SIZE * 2;
-int32_t tsVnodeShmSize = TSDB_MAX_WAL_SIZE * 10;
-int32_t tsQnodeShmSize = TSDB_MAX_WAL_SIZE * 4;
-int32_t tsSnodeShmSize = TSDB_MAX_WAL_SIZE * 4;
-int32_t tsBnodeShmSize = TSDB_MAX_WAL_SIZE * 4;
+int32_t tsMnodeShmSize = TSDB_MAX_WAL_SIZE * 2 + 128;
+int32_t tsVnodeShmSize = TSDB_MAX_WAL_SIZE * 10 + 128;
+int32_t tsQnodeShmSize = TSDB_MAX_WAL_SIZE * 4 + 128;
+int32_t tsSnodeShmSize = TSDB_MAX_WAL_SIZE * 4 + 128;
+int32_t tsBnodeShmSize = TSDB_MAX_WAL_SIZE * 4 + 128;
 
 // queue & threads
 int32_t tsNumOfRpcThreads = 1;
@@ -280,6 +279,7 @@ int32_t taosAddClientLogCfg(SConfig *pCfg) {
   if (cfgAddInt32(pCfg, "cDebugFlag", cDebugFlag, 0, 255, 1) != 0) return -1;
   if (cfgAddInt32(pCfg, "uDebugFlag", uDebugFlag, 0, 255, 1) != 0) return -1;
   if (cfgAddInt32(pCfg, "rpcDebugFlag", rpcDebugFlag, 0, 255, 1) != 0) return -1;
+  if (cfgAddInt32(pCfg, "qDebugFlag", qDebugFlag, 0, 255, 1) != 0) return -1;
   if (cfgAddInt32(pCfg, "tmrDebugFlag", tmrDebugFlag, 0, 255, 1) != 0) return -1;
   if (cfgAddInt32(pCfg, "jniDebugFlag", jniDebugFlag, 0, 255, 1) != 0) return -1;
   if (cfgAddInt32(pCfg, "simDebugFlag", 143, 0, 255, 1) != 0) return -1;
@@ -351,15 +351,14 @@ static int32_t taosAddSystemCfg(SConfig *pCfg) {
 }
 
 static int32_t taosAddServerCfg(SConfig *pCfg) {
-  if (cfgAddInt32(pCfg, "supportVnodes", 256, 0, 4096, 0) != 0) return -1;
   if (cfgAddDir(pCfg, "dataDir", tsDataDir, 0) != 0) return -1;
   if (cfgAddFloat(pCfg, "minimalDataDirGB", 2.0f, 0.001f, 10000000, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "maxNumOfDistinctRes", tsMaxNumOfDistinctResults, 10 * 10000, 10000 * 10000, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "maxConnections", tsMaxConnections, 1, 100000, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "supportVnodes", 256, 0, 4096, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxShellConns", tsMaxShellConns, 10, 50000000, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "statusInterval", tsStatusInterval, 1, 30, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "minSlidingTime", tsMinSlidingTime, 10, 1000000, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "minIntervalTime", tsMinIntervalTime, 1, 1000000, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "maxNumOfDistinctRes", tsMaxNumOfDistinctResults, 10 * 10000, 10000 * 10000, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxStreamCompDelay", tsMaxStreamComputDelay, 10, 1000000000, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxFirstStreamCompDelay", tsStreamCompStartDelay, 1000, 1000000000, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "retryStreamCompDelay", tsRetryStreamCompDelay, 10, 1000000000, 0) != 0) return -1;
@@ -371,11 +370,11 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddBool(pCfg, "deadLockKillQuery", tsDeadLockKillQuery, 0) != 0) return -1;
 
   if (cfgAddBool(pCfg, "multiProcess", tsMultiProcess, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "mnodeShmSize", tsMnodeShmSize, 4096, INT32_MAX, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "vnodeShmSize", tsVnodeShmSize, 4096, INT32_MAX, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "qnodeShmSize", tsQnodeShmSize, 4096, INT32_MAX, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "snodeShmSize", tsSnodeShmSize, 4096, INT32_MAX, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "bnodeShmSize", tsBnodeShmSize, 4096, INT32_MAX, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "mnodeShmSize", tsMnodeShmSize, TSDB_MAX_WAL_SIZE + 128, INT32_MAX, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "vnodeShmSize", tsVnodeShmSize, TSDB_MAX_WAL_SIZE + 128, INT32_MAX, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "qnodeShmSize", tsQnodeShmSize, TSDB_MAX_WAL_SIZE + 128, INT32_MAX, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "snodeShmSize", tsSnodeShmSize, TSDB_MAX_WAL_SIZE + 128, INT32_MAX, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "bnodeShmSize", tsBnodeShmSize, TSDB_MAX_WAL_SIZE + 128, INT32_MAX, 0) != 0) return -1;
 
   tsNumOfRpcThreads = tsNumOfCores / 2;
   tsNumOfRpcThreads = TRANGE(tsNumOfRpcThreads, 1, 4);
@@ -458,6 +457,7 @@ static void taosSetClientLogCfg(SConfig *pCfg) {
   tsLogKeepDays = cfgGetItem(pCfg, "logKeepDays")->i32;
   cDebugFlag = cfgGetItem(pCfg, "cDebugFlag")->i32;
   uDebugFlag = cfgGetItem(pCfg, "uDebugFlag")->i32;
+  qDebugFlag = cfgGetItem(pCfg, "qDebugFlag")->i32;
   rpcDebugFlag = cfgGetItem(pCfg, "rpcDebugFlag")->i32;
   tmrDebugFlag = cfgGetItem(pCfg, "tmrDebugFlag")->i32;
   jniDebugFlag = cfgGetItem(pCfg, "jniDebugFlag")->i32;
@@ -533,12 +533,11 @@ static void taosSetSystemCfg(SConfig *pCfg) {
 
 static int32_t taosSetServerCfg(SConfig *pCfg) {
   tsDataSpace.reserved = cfgGetItem(pCfg, "minimalDataDirGB")->fval;
-  tsMaxNumOfDistinctResults = cfgGetItem(pCfg, "maxNumOfDistinctRes")->i32;
-  tsMaxConnections = cfgGetItem(pCfg, "maxConnections")->i32;
   tsMaxShellConns = cfgGetItem(pCfg, "maxShellConns")->i32;
   tsStatusInterval = cfgGetItem(pCfg, "statusInterval")->i32;
   tsMinSlidingTime = cfgGetItem(pCfg, "minSlidingTime")->i32;
   tsMinIntervalTime = cfgGetItem(pCfg, "minIntervalTime")->i32;
+  tsMaxNumOfDistinctResults = cfgGetItem(pCfg, "maxNumOfDistinctRes")->i32;
   tsMaxStreamComputDelay = cfgGetItem(pCfg, "maxStreamCompDelay")->i32;
   tsStreamCompStartDelay = cfgGetItem(pCfg, "maxFirstStreamCompDelay")->i32;
   tsRetryStreamCompDelay = cfgGetItem(pCfg, "retryStreamCompDelay")->i32;

source/common/src/tmsgcb.c

@@ -19,12 +19,16 @@
 
 static SMsgCb tsDefaultMsgCb;
 
-void tmsgSetDefaultMsgCb(const SMsgCb* pMsgCb) { tsDefaultMsgCb = *pMsgCb; }
+void tmsgSetDefaultMsgCb(const SMsgCb* pMsgCb) {
+  // if (tsDefaultMsgCb.pWrapper == NULL) {
+  tsDefaultMsgCb = *pMsgCb;
+  //}
+}
 
 int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pReq) {
   PutToQueueFp fp = pMsgCb->queueFps[qtype];
   if (fp != NULL) {
-    return (*fp)(pMsgCb->pWrapper, pReq);
+    return (*fp)(pMsgCb->pMgmt, pReq);
   } else {
     terrno = TSDB_CODE_INVALID_PTR;
     return -1;
@@ -34,7 +38,7 @@ int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pReq) {
 int32_t tmsgGetQueueSize(const SMsgCb* pMsgCb, int32_t vgId, EQueueType qtype) {
   GetQueueSizeFp fp = pMsgCb->qsizeFp;
   if (fp != NULL) {
-    return (*fp)(pMsgCb->pWrapper, vgId, qtype);
+    return (*fp)(pMsgCb->pMgmt, vgId, qtype);
   } else {
     terrno = TSDB_CODE_INVALID_PTR;
     return -1;
@@ -51,7 +55,7 @@ int32_t tmsgSendReq(const SMsgCb* pMsgCb, const SEpSet* epSet, SRpcMsg* pReq) {
   }
 }
 
-void tmsgSendRsp(const SRpcMsg* pRsp) {
+void tmsgSendRsp(SRpcMsg* pRsp) {
   SendRspFp fp = tsDefaultMsgCb.sendRspFp;
   if (fp != NULL) {
     return (*fp)(tsDefaultMsgCb.pWrapper, pRsp);
@@ -60,7 +64,7 @@ void tmsgSendRsp(const SRpcMsg* pRsp) {
   }
 }
 
-void tmsgSendRedirectRsp(const SRpcMsg* pRsp, const SEpSet* pNewEpSet) {
+void tmsgSendRedirectRsp(SRpcMsg* pRsp, const SEpSet* pNewEpSet) {
   SendRedirectRspFp fp = tsDefaultMsgCb.sendRedirectRspFp;
   if (fp != NULL) {
     (*fp)(tsDefaultMsgCb.pWrapper, pRsp, pNewEpSet);
@@ -69,6 +73,15 @@ void tmsgSendRedirectRsp(const SRpcMsg* pRsp, const SEpSet* pNewEpSet) {
   }
 }
 
+void tmsgSendMnodeRecv(SRpcMsg* pReq, SRpcMsg* pRsp) {
+  SendMnodeRecvFp fp = tsDefaultMsgCb.sendMnodeRecvFp;
+  if (fp != NULL) {
+    (*fp)(tsDefaultMsgCb.pWrapper, pReq, pRsp);
+  } else {
+    terrno = TSDB_CODE_INVALID_PTR;
+  }
+}
+
 void tmsgRegisterBrokenLinkArg(const SMsgCb* pMsgCb, SRpcMsg* pMsg) {
   RegisterBrokenLinkArgFp fp = pMsgCb->registerBrokenLinkArgFp;
   if (fp != NULL) {

source/common/src/tname.c

@@ -317,7 +317,11 @@ void buildChildTableName(RandTableName* rName) {
   for (int j = 0; j < size; ++j) {
     SSmlKv* tagKv = taosArrayGetP(rName->tags, j);
     taosStringBuilderAppendStringLen(&sb, tagKv->key, tagKv->keyLen);
-    taosStringBuilderAppendStringLen(&sb, tagKv->value, tagKv->valueLen);
+    if(IS_VAR_DATA_TYPE(tagKv->type)){
+      taosStringBuilderAppendStringLen(&sb, tagKv->value, tagKv->length);
+    }else{
+      taosStringBuilderAppendStringLen(&sb, (char*)(&(tagKv->value)), tagKv->length);
+    }
   }
   size_t    len = 0;
   char*     keyJoined = taosStringBuilderGetResult(&sb, &len);

source/dnode/mgmt/CMakeLists.txt

-add_subdirectory(interface)
-add_subdirectory(implement)
+add_subdirectory(node_mgmt)
+add_subdirectory(node_util)
 add_subdirectory(mgmt_bnode)
 add_subdirectory(mgmt_mnode)
 add_subdirectory(mgmt_qnode)
 add_subdirectory(mgmt_snode)
 add_subdirectory(mgmt_vnode)
+add_subdirectory(mgmt_dnode)
 add_subdirectory(test)
 
 aux_source_directory(exe EXEC_SRC)
 add_executable(taosd ${EXEC_SRC})
 target_include_directories(
     taosd
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/implement/inc"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/node_mgmt/inc"
 )
 target_link_libraries(taosd dnode)

source/dnode/mgmt/exe/dmMain.c

@@ -14,7 +14,7 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dmImp.h"
+#include "dmMgmt.h"
 #include "tconfig.h"
 
 #define DM_APOLLO_URL    "The apollo string to use when configuring the server, such as: -a 'jsonFile:./tests/cfg.json', cfg.json text can be '{\"fqdn\":\"td1\"}'."
@@ -163,14 +163,14 @@ static SDnodeOpt dmGetOpt() {
 
 static int32_t dmInitLog() {
   char logName[12] = {0};
-  snprintf(logName, sizeof(logName), "%slog", dmLogName(global.ntype));
+  snprintf(logName, sizeof(logName), "%slog", dmNodeLogName(global.ntype));
   return taosCreateLog(logName, 1, configDir, global.envCmd, global.envFile, global.apolloUrl, global.pArgs, 0);
 }
 
 static void dmSetProcInfo(int32_t argc, char **argv) {
   taosSetProcPath(argc, argv);
   if (global.ntype != DNODE && global.ntype != NODE_END) {
-    const char *name = dmProcName(global.ntype);
+    const char *name = dmNodeProcName(global.ntype);
     taosSetProcName(argc, argv, name);
   }
 }

source/dnode/mgmt/implement/src/dmHandle.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 "dmImp.h"
-
-static void dmUpdateDnodeCfg(SDnode *pDnode, SDnodeCfg *pCfg) {
-  if (pDnode->data.dnodeId == 0 || pDnode->data.clusterId == 0) {
-    dInfo("set dnodeId:%d clusterId:%" PRId64, pCfg->dnodeId, pCfg->clusterId);
-    taosWLockLatch(&pDnode->data.latch);
-    pDnode->data.dnodeId = pCfg->dnodeId;
-    pDnode->data.clusterId = pCfg->clusterId;
-    dmWriteEps(pDnode);
-    taosWUnLockLatch(&pDnode->data.latch);
-  }
-}
-
-static int32_t dmProcessStatusRsp(SDnode *pDnode, SRpcMsg *pRsp) {
-  if (pRsp->code != TSDB_CODE_SUCCESS) {
-    if (pRsp->code == TSDB_CODE_MND_DNODE_NOT_EXIST && !pDnode->data.dropped && pDnode->data.dnodeId > 0) {
-      dInfo("dnode:%d, set to dropped since not exist in mnode", pDnode->data.dnodeId);
-      pDnode->data.dropped = 1;
-      dmWriteEps(pDnode);
-    }
-  } else {
-    SStatusRsp statusRsp = {0};
-    if (pRsp->pCont != NULL && pRsp->contLen > 0 &&
-        tDeserializeSStatusRsp(pRsp->pCont, pRsp->contLen, &statusRsp) == 0) {
-      pDnode->data.dnodeVer = statusRsp.dnodeVer;
-      dmUpdateDnodeCfg(pDnode, &statusRsp.dnodeCfg);
-      dmUpdateEps(pDnode, statusRsp.pDnodeEps);
-    }
-    rpcFreeCont(pRsp->pCont);
-    tFreeSStatusRsp(&statusRsp);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-void dmSendStatusReq(SDnode *pDnode) {
-  SStatusReq req = {0};
-
-  taosRLockLatch(&pDnode->data.latch);
-  req.sver = tsVersion;
-  req.dnodeVer = pDnode->data.dnodeVer;
-  req.dnodeId = pDnode->data.dnodeId;
-  req.clusterId = pDnode->data.clusterId;
-  if (req.clusterId == 0) req.dnodeId = 0;
-  req.rebootTime = pDnode->data.rebootTime;
-  req.updateTime = pDnode->data.updateTime;
-  req.numOfCores = tsNumOfCores;
-  req.numOfSupportVnodes = pDnode->data.supportVnodes;
-  tstrncpy(req.dnodeEp, pDnode->data.localEp, TSDB_EP_LEN);
-
-  req.clusterCfg.statusInterval = tsStatusInterval;
-  req.clusterCfg.checkTime = 0;
-  char timestr[32] = "1970-01-01 00:00:00.00";
-  (void)taosParseTime(timestr, &req.clusterCfg.checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
-  memcpy(req.clusterCfg.timezone, tsTimezoneStr, TD_TIMEZONE_LEN);
-  memcpy(req.clusterCfg.locale, tsLocale, TD_LOCALE_LEN);
-  memcpy(req.clusterCfg.charset, tsCharset, TD_LOCALE_LEN);
-  taosRUnLockLatch(&pDnode->data.latch);
-
-  SMonVloadInfo vinfo = {0};
-  dmGetVnodeLoads(pDnode, &vinfo);
-  req.pVloads = vinfo.pVloads;
-  pDnode->data.unsyncedVgId = 0;
-  pDnode->data.vndState = TAOS_SYNC_STATE_LEADER;
-  for (int32_t i = 0; i < taosArrayGetSize(req.pVloads); ++i) {
-    SVnodeLoad *pLoad = taosArrayGet(req.pVloads, i);
-    if (pLoad->syncState != TAOS_SYNC_STATE_LEADER && pLoad->syncState != TAOS_SYNC_STATE_FOLLOWER) {
-      pDnode->data.unsyncedVgId = pLoad->vgId;
-      pDnode->data.vndState = pLoad->syncState;
-    }
-  }
-
-  SMonMloadInfo minfo = {0};
-  dmGetMnodeLoads(pDnode, &minfo);
-  pDnode->data.isMnode = minfo.isMnode;
-  pDnode->data.mndState = minfo.load.syncState;
-
-  int32_t contLen = tSerializeSStatusReq(NULL, 0, &req);
-  void   *pHead = rpcMallocCont(contLen);
-  tSerializeSStatusReq(pHead, contLen, &req);
-  tFreeSStatusReq(&req);
-
-  SRpcMsg rpcMsg = {.pCont = pHead, .contLen = contLen, .msgType = TDMT_MND_STATUS, .ahandle = (void *)0x9527};
-  SRpcMsg rpcRsp = {0};
-
-  dTrace("send req:%s to mnode, app:%p", TMSG_INFO(rpcMsg.msgType), rpcMsg.ahandle);
-  dmSendToMnodeRecv(pDnode, &rpcMsg, &rpcRsp);
-  dmProcessStatusRsp(pDnode, &rpcRsp);
-}
-
-int32_t dmProcessAuthRsp(SDnode *pDnode, SNodeMsg *pMsg) {
-  SRpcMsg *pRsp = &pMsg->rpcMsg;
-  dError("auth rsp is received, but not supported yet");
-  return 0;
-}
-
-int32_t dmProcessGrantRsp(SDnode *pDnode, SNodeMsg *pMsg) {
-  SRpcMsg *pRsp = &pMsg->rpcMsg;
-  dError("grant rsp is received, but not supported yet");
-  return 0;
-}
-
-int32_t dmProcessConfigReq(SDnode *pDnode, SNodeMsg *pMsg) {
-  SRpcMsg       *pReq = &pMsg->rpcMsg;
-  SDCfgDnodeReq *pCfg = pReq->pCont;
-  dError("config req is received, but not supported yet");
-  return TSDB_CODE_OPS_NOT_SUPPORT;
-}
-
-int32_t dmProcessCreateNodeReq(SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg) {
-  SMgmtWrapper *pWrapper = dmAcquireWrapper(pDnode, ntype);
-  if (pWrapper != NULL) {
-    dmReleaseWrapper(pWrapper);
-    terrno = TSDB_CODE_NODE_ALREADY_DEPLOYED;
-    dError("failed to create node since %s", terrstr());
-    return -1;
-  }
-
-  taosThreadMutexLock(&pDnode->mutex);
-  pWrapper = &pDnode->wrappers[ntype];
-
-  if (taosMkDir(pWrapper->path) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to create dir:%s since %s", pWrapper->path, terrstr());
-    return -1;
-  }
-
-  int32_t code = (*pWrapper->fp.createFp)(pWrapper, pMsg);
-  if (code != 0) {
-    dError("node:%s, failed to create since %s", pWrapper->name, terrstr());
-  } else {
-    dDebug("node:%s, has been created", pWrapper->name);
-    (void)dmOpenNode(pWrapper);
-    pWrapper->required = true;
-    pWrapper->deployed = true;
-    pWrapper->procType = pDnode->ptype;
-  }
-
-  taosThreadMutexUnlock(&pDnode->mutex);
-  return code;
-}
-
-int32_t dmProcessDropNodeReq(SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg) {
-  SMgmtWrapper *pWrapper = dmAcquireWrapper(pDnode, ntype);
-  if (pWrapper == NULL) {
-    terrno = TSDB_CODE_NODE_NOT_DEPLOYED;
-    dError("failed to drop node since %s", terrstr());
-    return -1;
-  }
-
-  taosThreadMutexLock(&pDnode->mutex);
-
-  int32_t code = (*pWrapper->fp.dropFp)(pWrapper, pMsg);
-  if (code != 0) {
-    dError("node:%s, failed to drop since %s", pWrapper->name, terrstr());
-  } else {
-    dDebug("node:%s, has been dropped", pWrapper->name);
-    pWrapper->required = false;
-    pWrapper->deployed = false;
-  }
-
-  dmReleaseWrapper(pWrapper);
-
-  if (code == 0) {
-    dmCloseNode(pWrapper);
-    taosRemoveDir(pWrapper->path);
-  }
-  taosThreadMutexUnlock(&pDnode->mutex);
-  return code;
-}
-
-static void dmSetMgmtMsgHandle(SMgmtWrapper *pWrapper) {
-  // Requests handled by DNODE
-  dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_MNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_DROP_MNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_QNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_DROP_QNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_SNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_DROP_SNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_BNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_DROP_BNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_CONFIG_DNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-
-  // Requests handled by MNODE
-  dmSetMsgHandle(pWrapper, TDMT_MND_GRANT_RSP, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_AUTH_RSP, dmProcessMgmtMsg, DEFAULT_HANDLE);
-}
-
-static int32_t dmStartMgmt(SMgmtWrapper *pWrapper) {
-  if (dmStartStatusThread(pWrapper->pDnode) != 0) {
-    return -1;
-  }
-  if (dmStartMonitorThread(pWrapper->pDnode) != 0) {
-    return -1;
-  }
-  return 0;
-}
-
-static void dmStopMgmt(SMgmtWrapper *pWrapper) {
-  dmStopMonitorThread(pWrapper->pDnode);
-  dmStopStatusThread(pWrapper->pDnode);
-}
-
-static int32_t dmInitMgmt(SMgmtWrapper *pWrapper) {
-  dInfo("dnode-mgmt start to init");
-  SDnode *pDnode = pWrapper->pDnode;
-
-  pDnode->data.dnodeHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
-  if (pDnode->data.dnodeHash == NULL) {
-    dError("failed to init dnode hash");
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  if (dmReadEps(pDnode) != 0) {
-    dError("failed to read file since %s", terrstr());
-    return -1;
-  }
-
-  if (pDnode->data.dropped) {
-    dError("dnode will not start since its already dropped");
-    return -1;
-  }
-
-  if (dmStartWorker(pDnode) != 0) {
-    return -1;
-  }
-
-  if (dmInitServer(pDnode) != 0) {
-    dError("failed to init transport since %s", terrstr());
-    return -1;
-  }
-  dmReportStartup(pDnode, "dnode-transport", "initialized");
-
-  if (udfStartUdfd(pDnode->data.dnodeId) != 0) {
-    dError("failed to start udfd");
-  }
-
-  dInfo("dnode-mgmt is initialized");
-  return 0;
-}
-
-static void dmCleanupMgmt(SMgmtWrapper *pWrapper) {
-  dInfo("dnode-mgmt start to clean up");
-  SDnode *pDnode = pWrapper->pDnode;
-
-  udfStopUdfd();
-
-  dmStopWorker(pDnode);
-
-  taosWLockLatch(&pDnode->data.latch);
-  if (pDnode->data.dnodeEps != NULL) {
-    taosArrayDestroy(pDnode->data.dnodeEps);
-    pDnode->data.dnodeEps = NULL;
-  }
-  if (pDnode->data.dnodeHash != NULL) {
-    taosHashCleanup(pDnode->data.dnodeHash);
-    pDnode->data.dnodeHash = NULL;
-  }
-  taosWUnLockLatch(&pDnode->data.latch);
-
-  dmCleanupClient(pDnode);
-  dmCleanupServer(pDnode);
-  dInfo("dnode-mgmt is cleaned up");
-}
-
-static int32_t dmRequireMgmt(SMgmtWrapper *pWrapper, bool *required) {
-  *required = true;
-  return 0;
-}
-
-void dmSetMgmtFp(SMgmtWrapper *pWrapper) {
-  SMgmtFp mgmtFp = {0};
-  mgmtFp.openFp = dmInitMgmt;
-  mgmtFp.closeFp = dmCleanupMgmt;
-  mgmtFp.startFp = dmStartMgmt;
-  mgmtFp.stopFp = dmStopMgmt;
-  mgmtFp.requiredFp = dmRequireMgmt;
-
-  dmSetMgmtMsgHandle(pWrapper);
-  pWrapper->name = "dnode";
-  pWrapper->fp = mgmtFp;
-}

source/dnode/mgmt/implement/src/dmMonitor.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 "dmImp.h"
-
-static void dmGetMonitorBasicInfo(SDnode *pDnode, SMonBasicInfo *pInfo) {
-  pInfo->protocol = 1;
-  pInfo->dnode_id = pDnode->data.dnodeId;
-  pInfo->cluster_id = pDnode->data.clusterId;
-  tstrncpy(pInfo->dnode_ep, tsLocalEp, TSDB_EP_LEN);
-}
-
-static void dmGetMonitorDnodeInfo(SDnode *pDnode, SMonDnodeInfo *pInfo) {
-  pInfo->uptime = (taosGetTimestampMs() - pDnode->data.rebootTime) / (86400000.0f);
-  pInfo->has_mnode = pDnode->wrappers[MNODE].required;
-  pInfo->has_qnode = pDnode->wrappers[QNODE].required;
-  pInfo->has_snode = pDnode->wrappers[SNODE].required;
-  pInfo->has_bnode = pDnode->wrappers[BNODE].required;
-  tstrncpy(pInfo->logdir.name, tsLogDir, sizeof(pInfo->logdir.name));
-  pInfo->logdir.size = tsLogSpace.size;
-  tstrncpy(pInfo->tempdir.name, tsTempDir, sizeof(pInfo->tempdir.name));
-  pInfo->tempdir.size = tsTempSpace.size;
-}
-
-static void dmGetMonitorInfo(SDnode *pDnode, SMonDmInfo *pInfo) {
-  dmGetMonitorBasicInfo(pDnode, &pInfo->basic);
-  dmGetMonitorSysInfo(&pInfo->sys);
-  dmGetMonitorDnodeInfo(pDnode, &pInfo->dnode);
-}
-
-void dmSendMonitorReport(SDnode *pDnode) {
-  if (!tsEnableMonitor || tsMonitorFqdn[0] == 0 || tsMonitorPort == 0) return;
-  dTrace("send monitor report to %s:%u", tsMonitorFqdn, tsMonitorPort);
-
-  SMonDmInfo dmInfo = {0};
-  SMonMmInfo mmInfo = {0};
-  SMonVmInfo vmInfo = {0};
-  SMonQmInfo qmInfo = {0};
-  SMonSmInfo smInfo = {0};
-  SMonBmInfo bmInfo = {0};
-
-  SRpcMsg req = {0};
-  SRpcMsg rsp;
-  SEpSet  epset = {.inUse = 0, .numOfEps = 1};
-  tstrncpy(epset.eps[0].fqdn, pDnode->data.localFqdn, TSDB_FQDN_LEN);
-  epset.eps[0].port = tsServerPort;
-
-  SMgmtWrapper *pWrapper = NULL;
-  dmGetMonitorInfo(pDnode, &dmInfo);
-
-  bool getFromAPI = !tsMultiProcess;
-  pWrapper = &pDnode->wrappers[MNODE];
-  if (getFromAPI) {
-    if (dmMarkWrapper(pWrapper) == 0) {
-      mmGetMonitorInfo(pWrapper, &mmInfo);
-      dmReleaseWrapper(pWrapper);
-    }
-  } else {
-    if (pWrapper->required) {
-      req.msgType = TDMT_MON_MM_INFO;
-      dmSendRecv(pDnode, &epset, &req, &rsp);
-      if (rsp.code == 0 && rsp.contLen > 0) {
-        tDeserializeSMonMmInfo(rsp.pCont, rsp.contLen, &mmInfo);
-      }
-      rpcFreeCont(rsp.pCont);
-    }
-  }
-
-  pWrapper = &pDnode->wrappers[VNODE];
-  if (getFromAPI) {
-    if (dmMarkWrapper(pWrapper) == 0) {
-      vmGetMonitorInfo(pWrapper, &vmInfo);
-      dmReleaseWrapper(pWrapper);
-    }
-  } else {
-    if (pWrapper->required) {
-      req.msgType = TDMT_MON_VM_INFO;
-      dmSendRecv(pDnode, &epset, &req, &rsp);
-      if (rsp.code == 0 && rsp.contLen > 0) {
-        tDeserializeSMonVmInfo(rsp.pCont, rsp.contLen, &vmInfo);
-      }
-      rpcFreeCont(rsp.pCont);
-    }
-  }
-
-  pWrapper = &pDnode->wrappers[QNODE];
-  if (getFromAPI) {
-    if (dmMarkWrapper(pWrapper) == 0) {
-      qmGetMonitorInfo(pWrapper, &qmInfo);
-      dmReleaseWrapper(pWrapper);
-    }
-  } else {
-    if (pWrapper->required) {
-      req.msgType = TDMT_MON_QM_INFO;
-      dmSendRecv(pDnode, &epset, &req, &rsp);
-      if (rsp.code == 0 && rsp.contLen > 0) {
-        tDeserializeSMonQmInfo(rsp.pCont, rsp.contLen, &qmInfo);
-      }
-      rpcFreeCont(rsp.pCont);
-    }
-  }
-
-  pWrapper = &pDnode->wrappers[SNODE];
-  if (getFromAPI) {
-    if (dmMarkWrapper(pWrapper) == 0) {
-      smGetMonitorInfo(pWrapper, &smInfo);
-      dmReleaseWrapper(pWrapper);
-    }
-  } else {
-    if (pWrapper->required) {
-      req.msgType = TDMT_MON_SM_INFO;
-      dmSendRecv(pDnode, &epset, &req, &rsp);
-      if (rsp.code == 0 && rsp.contLen > 0) {
-        tDeserializeSMonSmInfo(rsp.pCont, rsp.contLen, &smInfo);
-      }
-      rpcFreeCont(rsp.pCont);
-    }
-  }
-
-  pWrapper = &pDnode->wrappers[BNODE];
-  if (getFromAPI) {
-    if (dmMarkWrapper(pWrapper) == 0) {
-      bmGetMonitorInfo(pWrapper, &bmInfo);
-      dmReleaseWrapper(pWrapper);
-    }
-  } else {
-    if (pWrapper->required) {
-      req.msgType = TDMT_MON_BM_INFO;
-      dmSendRecv(pDnode, &epset, &req, &rsp);
-      if (rsp.code == 0 && rsp.contLen > 0) {
-        tDeserializeSMonBmInfo(rsp.pCont, rsp.contLen, &bmInfo);
-      }
-      rpcFreeCont(rsp.pCont);
-    }
-  }
-
-  monSetDmInfo(&dmInfo);
-  monSetMmInfo(&mmInfo);
-  monSetVmInfo(&vmInfo);
-  monSetQmInfo(&qmInfo);
-  monSetSmInfo(&smInfo);
-  monSetBmInfo(&bmInfo);
-  tFreeSMonMmInfo(&mmInfo);
-  tFreeSMonVmInfo(&vmInfo);
-  tFreeSMonQmInfo(&qmInfo);
-  tFreeSMonSmInfo(&smInfo);
-  tFreeSMonBmInfo(&bmInfo);
-  monSendReport();
-}
-
-void dmGetVnodeLoads(SDnode *pDnode, SMonVloadInfo *pInfo) {
-  SMgmtWrapper *pWrapper = dmAcquireWrapper(pDnode, VNODE);
-  if (pWrapper == NULL) return;
-
-  bool getFromAPI = !tsMultiProcess;
-  if (getFromAPI) {
-    vmGetVnodeLoads(pWrapper, pInfo);
-  } else {
-    SRpcMsg req = {.msgType = TDMT_MON_VM_LOAD};
-    SRpcMsg rsp = {0};
-    SEpSet  epset = {.inUse = 0, .numOfEps = 1};
-    tstrncpy(epset.eps[0].fqdn, pDnode->data.localFqdn, TSDB_FQDN_LEN);
-    epset.eps[0].port = tsServerPort;
-
-    dmSendRecv(pDnode, &epset, &req, &rsp);
-    if (rsp.code == 0 && rsp.contLen > 0) {
-      tDeserializeSMonVloadInfo(rsp.pCont, rsp.contLen, pInfo);
-    }
-    rpcFreeCont(rsp.pCont);
-  }
-  dmReleaseWrapper(pWrapper);
-}
-
-void dmGetMnodeLoads(SDnode *pDnode, SMonMloadInfo *pInfo) {
-  SMgmtWrapper *pWrapper = dmAcquireWrapper(pDnode, MNODE);
-  if (pWrapper == NULL) {
-    pInfo->isMnode = 0;
-    return;
-  }
-
-  bool getFromAPI = !tsMultiProcess;
-  if (getFromAPI) {
-    mmGetMnodeLoads(pWrapper, pInfo);
-  } else {
-    SRpcMsg req = {.msgType = TDMT_MON_MM_LOAD};
-    SRpcMsg rsp = {0};
-    SEpSet  epset = {.inUse = 0, .numOfEps = 1};
-    tstrncpy(epset.eps[0].fqdn, pDnode->data.localFqdn, TSDB_FQDN_LEN);
-    epset.eps[0].port = tsServerPort;
-
-    dmSendRecv(pDnode, &epset, &req, &rsp);
-    if (rsp.code == 0 && rsp.contLen > 0) {
-      tDeserializeSMonMloadInfo(rsp.pCont, rsp.contLen, pInfo);
-    }
-    rpcFreeCont(rsp.pCont);
-  }
-  dmReleaseWrapper(pWrapper);
-}

source/dnode/mgmt/implement/src/dmObj.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 "dmImp.h"
-
-static int32_t dmInitVars(SDnode *pDnode, const SDnodeOpt *pOption) {
-  pDnode->data.dnodeId = 0;
-  pDnode->data.clusterId = 0;
-  pDnode->data.dnodeVer = 0;
-  pDnode->data.updateTime = 0;
-  pDnode->data.rebootTime = taosGetTimestampMs();
-  pDnode->data.dropped = 0;
-  pDnode->data.localEp = strdup(pOption->localEp);
-  pDnode->data.localFqdn = strdup(pOption->localFqdn);
-  pDnode->data.firstEp = strdup(pOption->firstEp);
-  pDnode->data.secondEp = strdup(pOption->secondEp);
-  pDnode->data.dataDir = strdup(pOption->dataDir);
-  pDnode->data.disks = pOption->disks;
-  pDnode->data.numOfDisks = pOption->numOfDisks;
-  pDnode->data.supportVnodes = pOption->numOfSupportVnodes;
-  pDnode->data.serverPort = pOption->serverPort;
-  pDnode->ntype = pOption->ntype;
-
-  if (pDnode->data.dataDir == NULL || pDnode->data.localEp == NULL || pDnode->data.localFqdn == NULL ||
-      pDnode->data.firstEp == NULL || pDnode->data.secondEp == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  if (!tsMultiProcess || pDnode->ntype == DNODE || pDnode->ntype == NODE_END) {
-    pDnode->data.lockfile = dmCheckRunning(pDnode->data.dataDir);
-    if (pDnode->data.lockfile == NULL) {
-      return -1;
-    }
-  }
-
-  taosInitRWLatch(&pDnode->data.latch);
-  taosThreadMutexInit(&pDnode->mutex, NULL);
-  return 0;
-}
-
-static void dmClearVars(SDnode *pDnode) {
-  for (EDndNodeType n = DNODE; n < NODE_END; ++n) {
-    SMgmtWrapper *pMgmt = &pDnode->wrappers[n];
-    taosMemoryFreeClear(pMgmt->path);
-  }
-  if (pDnode->data.lockfile != NULL) {
-    taosUnLockFile(pDnode->data.lockfile);
-    taosCloseFile(&pDnode->data.lockfile);
-    pDnode->data.lockfile = NULL;
-  }
-  taosMemoryFreeClear(pDnode->data.localEp);
-  taosMemoryFreeClear(pDnode->data.localFqdn);
-  taosMemoryFreeClear(pDnode->data.firstEp);
-  taosMemoryFreeClear(pDnode->data.secondEp);
-  taosMemoryFreeClear(pDnode->data.dataDir);
-  taosThreadMutexDestroy(&pDnode->mutex);
-  memset(&pDnode->mutex, 0, sizeof(pDnode->mutex));
-  taosMemoryFree(pDnode);
-  dDebug("dnode memory is cleared, data:%p", pDnode);
-}
-
-SDnode *dmCreate(const SDnodeOpt *pOption) {
-  dDebug("start to create dnode");
-  int32_t code = -1;
-  char    path[PATH_MAX] = {0};
-  SDnode *pDnode = NULL;
-
-  pDnode = taosMemoryCalloc(1, sizeof(SDnode));
-  if (pDnode == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    goto _OVER;
-  }
-
-  if (dmInitVars(pDnode, pOption) != 0) {
-    dError("failed to init variables since %s", terrstr());
-    goto _OVER;
-  }
-
-  dmSetStatus(pDnode, DND_STAT_INIT);
-  dmSetMgmtFp(&pDnode->wrappers[DNODE]);
-  mmSetMgmtFp(&pDnode->wrappers[MNODE]);
-  vmSetMgmtFp(&pDnode->wrappers[VNODE]);
-  qmSetMgmtFp(&pDnode->wrappers[QNODE]);
-  smSetMgmtFp(&pDnode->wrappers[SNODE]);
-  bmSetMgmtFp(&pDnode->wrappers[BNODE]);
-
-  for (EDndNodeType n = DNODE; n < NODE_END; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    snprintf(path, sizeof(path), "%s%s%s", pDnode->data.dataDir, TD_DIRSEP, pWrapper->name);
-    pWrapper->path = strdup(path);
-    pWrapper->procShm.id = -1;
-    pWrapper->pDnode = pDnode;
-    pWrapper->ntype = n;
-    pWrapper->procType = DND_PROC_SINGLE;
-    taosInitRWLatch(&pWrapper->latch);
-
-    if (pWrapper->path == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      goto _OVER;
-    }
-
-    if (n != DNODE && dmReadShmFile(pWrapper) != 0) {
-      dError("node:%s, failed to read shm file since %s", pWrapper->name, terrstr());
-      goto _OVER;
-    }
-  }
-
-  if (dmInitMsgHandle(pDnode) != 0) {
-    dError("failed to init msg handles since %s", terrstr());
-    goto _OVER;
-  }
-
-  dInfo("dnode is created, data:%p", pDnode);
-  code = 0;
-
-_OVER:
-  if (code != 0 && pDnode) {
-    dmClearVars(pDnode);
-    pDnode = NULL;
-    dError("failed to create dnode since %s", terrstr());
-  }
-
-  return pDnode;
-}
-
-void dmClose(SDnode *pDnode) {
-  if (pDnode == NULL) return;
-  dmClearVars(pDnode);
-  dInfo("dnode is closed, data:%p", pDnode);
-}

source/dnode/mgmt/interface/inc/dmDef.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_DM_DEF_H_
-#define _TD_DM_DEF_H_
-
-#include "uv.h"
-#include "dmLog.h"
-
-#include "cJSON.h"
-#include "tcache.h"
-#include "tcrc32c.h"
-#include "tdatablock.h"
-#include "tglobal.h"
-#include "thash.h"
-#include "tlockfree.h"
-#include "tlog.h"
-#include "tmsg.h"
-#include "tmsgcb.h"
-#include "tprocess.h"
-#include "tqueue.h"
-#include "trpc.h"
-#include "tthread.h"
-#include "ttime.h"
-#include "tworker.h"
-
-#include "dnode.h"
-#include "mnode.h"
-#include "monitor.h"
-#include "sync.h"
-
-#include "libs/function/function.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum { DNODE, VNODE, QNODE, SNODE, MNODE, BNODE, NODE_END } EDndNodeType;
-typedef enum { DND_STAT_INIT, DND_STAT_RUNNING, DND_STAT_STOPPED } EDndRunStatus;
-typedef enum { DND_ENV_INIT, DND_ENV_READY, DND_ENV_CLEANUP } EDndEnvStatus;
-typedef enum { DND_PROC_SINGLE, DND_PROC_CHILD, DND_PROC_PARENT } EDndProcType;
-
-typedef int32_t (*NodeMsgFp)(struct SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-typedef int32_t (*OpenNodeFp)(struct SMgmtWrapper *pWrapper);
-typedef void (*CloseNodeFp)(struct SMgmtWrapper *pWrapper);
-typedef int32_t (*StartNodeFp)(struct SMgmtWrapper *pWrapper);
-typedef void (*StopNodeFp)(struct SMgmtWrapper *pWrapper);
-typedef int32_t (*CreateNodeFp)(struct SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-typedef int32_t (*DropNodeFp)(struct SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-typedef int32_t (*RequireNodeFp)(struct SMgmtWrapper *pWrapper, bool *required);
-
-typedef struct {
-  SMgmtWrapper *pQndWrapper;
-  SMgmtWrapper *pMndWrapper;
-  SMgmtWrapper *pNdWrapper;
-} SMsgHandle;
-
-typedef struct {
-  OpenNodeFp    openFp;
-  CloseNodeFp   closeFp;
-  StartNodeFp   startFp;
-  StopNodeFp    stopFp;
-  CreateNodeFp  createFp;
-  DropNodeFp    dropFp;
-  RequireNodeFp requiredFp;
-} SMgmtFp;
-
-typedef struct SMgmtWrapper {
-  SDnode *pDnode;
-  struct {
-    const char  *name;
-    char        *path;
-    int32_t      refCount;
-    SRWLatch     latch;
-    EDndNodeType ntype;
-    bool         deployed;
-    bool         required;
-    SMgmtFp      fp;
-    void        *pMgmt;
-  };
-  struct {
-    EDndProcType procType;
-    int32_t      procId;
-    SProcObj    *procObj;
-    SShm         procShm;
-  };
-  struct {
-    int8_t    msgVgIds[TDMT_MAX];  // Handle the case where the same message type is distributed to qnode or vnode
-    NodeMsgFp msgFps[TDMT_MAX];
-  };
-} SMgmtWrapper;
-
-typedef struct {
-  void      *serverRpc;
-  void      *clientRpc;
-  SMsgHandle msgHandles[TDMT_MAX];
-} SDnodeTrans;
-
-typedef struct {
-  int32_t       dnodeId;
-  int64_t       clusterId;
-  int64_t       dnodeVer;
-  int64_t       updateTime;
-  int64_t       rebootTime;
-  int32_t       unsyncedVgId;
-  ESyncState    vndState;
-  ESyncState    mndState;
-  bool          isMnode;
-  bool          dropped;
-  SEpSet        mnodeEps;
-  SArray       *dnodeEps;
-  SHashObj     *dnodeHash;
-  TdThread     *statusThreadId;
-  TdThread     *monitorThreadId;
-  SRWLatch      latch;
-  SSingleWorker mgmtWorker;
-  SMsgCb        msgCb;
-  SDnode       *pDnode;
-  TdFilePtr     lockfile;
-  char         *localEp;
-  char         *localFqdn;
-  char         *firstEp;
-  char         *secondEp;
-  char         *dataDir;
-  SDiskCfg     *disks;
-  int32_t       numOfDisks;
-  int32_t       supportVnodes;
-  uint16_t      serverPort;
-} SDnodeData;
-
-typedef struct {
-  char name[TSDB_STEP_NAME_LEN];
-  char desc[TSDB_STEP_DESC_LEN];
-} SStartupInfo;
-
-typedef struct SUdfdData {
-  bool          startCalled;
-  bool          needCleanUp;
-  uv_loop_t     loop;
-  uv_thread_t   thread;
-  uv_barrier_t  barrier;
-  uv_process_t  process;
-  int           spawnErr;
-  uv_pipe_t     ctrlPipe;
-  uv_async_t    stopAsync;
-  int32_t        stopCalled;
-
-  int32_t         dnodeId;
-} SUdfdData;
-
-typedef struct SDnode {
-  EDndProcType  ptype;
-  EDndNodeType  ntype;
-  EDndRunStatus status;
-  EDndEvent     event;
-  SStartupInfo  startup;
-  SDnodeTrans   trans;
-  SDnodeData    data;
-  SUdfdData     udfdData;
-  TdThreadMutex mutex;
-  SMgmtWrapper  wrappers[NODE_END];
-} SDnode;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DM_DEF_H_*/
\ No newline at end of file

source/dnode/mgmt/interface/inc/dmLog.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_DM_LOG_H_
-#define _TD_DM_LOG_H_
-
-#include "tlog.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define dFatal(...) { if (dDebugFlag & DEBUG_FATAL) { taosPrintLog("DND FATAL ", DEBUG_FATAL, 255, __VA_ARGS__); }}
-#define dError(...) { if (dDebugFlag & DEBUG_ERROR) { taosPrintLog("DND ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }}
-#define dWarn(...)  { if (dDebugFlag & DEBUG_WARN)  { taosPrintLog("DND WARN ", DEBUG_WARN, 255, __VA_ARGS__); }}
-#define dInfo(...)  { if (dDebugFlag & DEBUG_INFO)  { taosPrintLog("DND ", DEBUG_INFO, 255, __VA_ARGS__); }}
-#define dDebug(...) { if (dDebugFlag & DEBUG_DEBUG) { taosPrintLog("DND ", DEBUG_DEBUG, dDebugFlag, __VA_ARGS__); }}
-#define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", DEBUG_TRACE, dDebugFlag, __VA_ARGS__); }}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DM_LOG_H_*/
\ No newline at end of file

source/dnode/mgmt/mgmt_bnode/CMakeLists.txt

@@ -5,5 +5,5 @@ target_include_directories(
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    mgmt_bnode dnode_interface
+    mgmt_bnode node_util
 )
\ No newline at end of file

source/dnode/mgmt/mgmt_bnode/inc/bmInt.h

@@ -16,7 +16,7 @@
 #ifndef _TD_DND_BNODE_INT_H_
 #define _TD_DND_BNODE_INT_H_
 
-#include "dmInt.h"
+#include "dmUtil.h"
 
 #include "bnode.h"
 
@@ -26,24 +26,25 @@ extern "C" {
 
 typedef struct SBnodeMgmt {
   SBnode       *pBnode;
-  SDnode       *pDnode;
-  SMgmtWrapper *pWrapper;  
+  SMsgCb        msgCb;
   const char   *path;
+  const char   *name;
+  int32_t       dnodeId;
   SMultiWorker  writeWorker;
   SSingleWorker monitorWorker;
 } SBnodeMgmt;
 
 // bmHandle.c
-void    bmInitMsgHandle(SMgmtWrapper *pWrapper);
-int32_t bmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t bmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t bmProcessGetMonBmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq);
+SArray *bmGetMsgHandles();
+int32_t bmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg);
+int32_t bmProcessDropReq(SBnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t bmProcessGetMonBmInfoReq(SBnodeMgmt *pMgmt, SNodeMsg *pReq);
 
 // bmWorker.c
 int32_t bmStartWorker(SBnodeMgmt *pMgmt);
 void    bmStopWorker(SBnodeMgmt *pMgmt);
-int32_t bmProcessWriteMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t bmProcessMonitorMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
+int32_t bmPutNodeMsgToWriteQueue(SBnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t bmPutNodeMsgToMonitorQueue(SBnodeMgmt *pMgmt, SNodeMsg *pMsg);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/mgmt_bnode/src/bmHandle.c

@@ -16,12 +16,12 @@
 #define _DEFAULT_SOURCE
 #include "bmInt.h"
 
-void bmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonBmInfo *bmInfo) {}
+static void bmGetMonitorInfo(SBnodeMgmt *pMgmt, SMonBmInfo *bmInfo) {}
 
-int32_t bmProcessGetMonBmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
+int32_t bmProcessGetMonBmInfoReq(SBnodeMgmt *pMgmt, SNodeMsg *pReq) {
   SMonBmInfo bmInfo = {0};
-  bmGetMonitorInfo(pWrapper, &bmInfo);
-  dmGetMonitorSysInfo(&bmInfo.sys);
+  bmGetMonitorInfo(pMgmt, &bmInfo);
+  dmGetMonitorSystemInfo(&bmInfo.sys);
   monGetLogs(&bmInfo.log);
 
   int32_t rspLen = tSerializeSMonBmInfo(NULL, 0, &bmInfo);
@@ -43,8 +43,7 @@ int32_t bmProcessGetMonBmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
   return 0;
 }
 
-int32_t bmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SDnode  *pDnode = pWrapper->pDnode;
+int32_t bmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
   SRpcMsg *pReq = &pMsg->rpcMsg;
 
   SDCreateBnodeReq createReq = {0};
@@ -53,14 +52,14 @@ int32_t bmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (pDnode->data.dnodeId != 0 && createReq.dnodeId != pDnode->data.dnodeId) {
+  if (pInput->dnodeId != 0 && createReq.dnodeId != pInput->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
-    dError("failed to create bnode since %s, input:%d cur:%d", terrstr(), createReq.dnodeId, pDnode->data.dnodeId);
+    dError("failed to create bnode since %s, input:%d cur:%d", terrstr(), createReq.dnodeId, pInput->dnodeId);
     return -1;
   }
 
   bool deployed = true;
-  if (dmWriteFile(pWrapper, deployed) != 0) {
+  if (dmWriteFile(pInput->path, pInput->name, deployed) != 0) {
     dError("failed to write bnode file since %s", terrstr());
     return -1;
   }
@@ -68,8 +67,7 @@ int32_t bmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t bmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SDnode  *pDnode = pWrapper->pDnode;
+int32_t bmProcessDropReq(SBnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   SRpcMsg *pReq = &pMsg->rpcMsg;
 
   SDDropBnodeReq dropReq = {0};
@@ -78,14 +76,14 @@ int32_t bmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (dropReq.dnodeId != pDnode->data.dnodeId) {
+  if (pMgmt->dnodeId != 0 && dropReq.dnodeId != pMgmt->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to drop bnode since %s", terrstr());
     return -1;
   }
 
   bool deployed = false;
-  if (dmWriteFile(pWrapper, deployed) != 0) {
+  if (dmWriteFile(pMgmt->path, pMgmt->name, deployed) != 0) {
     dError("failed to write bnode file since %s", terrstr());
     return -1;
   }
@@ -93,6 +91,19 @@ int32_t bmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
   return 0;
 }
 
-void bmInitMsgHandle(SMgmtWrapper *pWrapper) {
-  dmSetMsgHandle(pWrapper, TDMT_MON_BM_INFO, bmProcessMonitorMsg, DEFAULT_HANDLE);
+SArray *bmGetMsgHandles() {
+  int32_t code = -1;
+  SArray *pArray = taosArrayInit(2, sizeof(SMgmtHandle));
+  if (pArray == NULL) goto _OVER;
+
+  if (dmSetMgmtHandle(pArray, TDMT_MON_BM_INFO, bmPutNodeMsgToMonitorQueue, 0) == NULL) goto _OVER;
+
+  code = 0;
+_OVER:
+  if (code != 0) {
+    taosArrayDestroy(pArray);
+    return NULL;
+  } else {
+    return pArray;
+  }
 }

source/dnode/mgmt/mgmt_bnode/src/bmInt.c

@@ -16,18 +16,13 @@
 #define _DEFAULT_SOURCE
 #include "bmInt.h"
 
-static int32_t bmRequire(SMgmtWrapper *pWrapper, bool *required) { return dmReadFile(pWrapper, required); }
-
-static void bmInitOption(SBnodeMgmt *pMgmt, SBnodeOpt *pOption) {
-  SMsgCb msgCb = pMgmt->pDnode->data.msgCb;
-  msgCb.pWrapper = pMgmt->pWrapper;
-  pOption->msgCb = msgCb;
+static int32_t bmRequire(const SMgmtInputOpt *pInput, bool *required) {
+  return dmReadFile(pInput->path, pInput->name, required);
 }
 
-static void bmClose(SMgmtWrapper *pWrapper) {
-  SBnodeMgmt *pMgmt = pWrapper->pMgmt;
-  if (pMgmt == NULL) return;
+static void bmInitOption(SBnodeMgmt *pMgmt, SBnodeOpt *pOption) { pOption->msgCb = pMgmt->msgCb; }
 
+static void bmClose(SBnodeMgmt *pMgmt) {
   dInfo("bnode-mgmt start to cleanup");
   if (pMgmt->pBnode != NULL) {
     bmStopWorker(pMgmt);
@@ -35,12 +30,11 @@ static void bmClose(SMgmtWrapper *pWrapper) {
     pMgmt->pBnode = NULL;
   }
 
-  pWrapper->pMgmt = NULL;
   taosMemoryFree(pMgmt);
   dInfo("bnode-mgmt is cleaned up");
 }
 
-int32_t bmOpen(SMgmtWrapper *pWrapper) {
+int32_t bmOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
   dInfo("bnode-mgmt start to init");
   SBnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SBnodeMgmt));
   if (pMgmt == NULL) {
@@ -48,40 +42,42 @@ int32_t bmOpen(SMgmtWrapper *pWrapper) {
     return -1;
   }
 
-  pMgmt->path = pWrapper->path;
-  pMgmt->pDnode = pWrapper->pDnode;
-  pMgmt->pWrapper = pWrapper;
-  pWrapper->pMgmt = pMgmt;
+  pMgmt->path = pInput->path;
+  pMgmt->name = pInput->name;
+  pMgmt->dnodeId = pInput->dnodeId;
+  pMgmt->msgCb = pInput->msgCb;
+  pMgmt->msgCb.pMgmt = pMgmt;
 
   SBnodeOpt option = {0};
   bmInitOption(pMgmt, &option);
   pMgmt->pBnode = bndOpen(pMgmt->path, &option);
   if (pMgmt->pBnode == NULL) {
     dError("failed to open bnode since %s", terrstr());
-    bmClose(pWrapper);
+    bmClose(pMgmt);
     return -1;
   }
-  dmReportStartup(pWrapper->pDnode, "bnode-impl", "initialized");
+  tmsgReportStartup("bnode-impl", "initialized");
 
   if (bmStartWorker(pMgmt) != 0) {
     dError("failed to start bnode worker since %s", terrstr());
-    bmClose(pWrapper);
+    bmClose(pMgmt);
     return -1;
   }
-  dmReportStartup(pWrapper->pDnode, "bnode-worker", "initialized");
+  tmsgReportStartup("bnode-worker", "initialized");
 
+  pOutput->pMgmt = pMgmt;
+  dInfo("bnode-mgmt is initialized");
   return 0;
 }
 
-void bmSetMgmtFp(SMgmtWrapper *pWrapper) {
-  SMgmtFp mgmtFp = {0};
-  mgmtFp.openFp = bmOpen;
-  mgmtFp.closeFp = bmClose;
-  mgmtFp.createFp = bmProcessCreateReq;
-  mgmtFp.dropFp = bmProcessDropReq;
-  mgmtFp.requiredFp = bmRequire;
+SMgmtFunc bmGetMgmtFunc() {
+  SMgmtFunc mgmtFunc = {0};
+  mgmtFunc.openFp = bmOpen;
+  mgmtFunc.closeFp = (NodeCloseFp)bmClose;
+  mgmtFunc.createFp = (NodeCreateFp)bmProcessCreateReq;
+  mgmtFunc.dropFp = (NodeDropFp)bmProcessDropReq;
+  mgmtFunc.requiredFp = bmRequire;
+  mgmtFunc.getHandlesFp = bmGetMsgHandles;
 
-  bmInitMsgHandle(pWrapper);
-  pWrapper->name = "bnode";
-  pWrapper->fp = mgmtFp;
+  return mgmtFunc;
 }

source/dnode/mgmt/mgmt_bnode/src/bmWorker.c

@@ -58,7 +58,7 @@ static void bmProcessMonitorQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   int32_t  code = -1;
 
   if (pMsg->rpcMsg.msgType == TDMT_MON_BM_INFO) {
-    code = bmProcessGetMonBmInfoReq(pMgmt->pWrapper, pMsg);
+    code = bmProcessGetMonBmInfoReq(pMgmt, pMsg);
   } else {
     terrno = TSDB_CODE_MSG_NOT_PROCESSED;
   }
@@ -106,8 +106,7 @@ static void bmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
   taosArrayDestroy(pArray);
 }
 
-int32_t bmProcessWriteMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SBnodeMgmt   *pMgmt = pWrapper->pMgmt;
+int32_t bmPutNodeMsgToWriteQueue(SBnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   SMultiWorker *pWorker = &pMgmt->writeWorker;
 
   dTrace("msg:%p, put into worker:%s", pMsg, pWorker->name);
@@ -115,8 +114,7 @@ int32_t bmProcessWriteMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t bmProcessMonitorMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SBnodeMgmt    *pMgmt = pWrapper->pMgmt;
+int32_t bmPutNodeMsgToMonitorQueue(SBnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   SSingleWorker *pWorker = &pMgmt->monitorWorker;
 
   dTrace("msg:%p, put into worker:%s", pMsg, pWorker->name);
@@ -136,7 +134,6 @@ int32_t bmStartWorker(SBnodeMgmt *pMgmt) {
     return -1;
   }
 
-  if (tsMultiProcess) {
   SSingleWorkerCfg mCfg = {
       .min = 1,
       .max = 1,
@@ -148,7 +145,6 @@ int32_t bmStartWorker(SBnodeMgmt *pMgmt) {
     dError("failed to start bnode-monitor worker since %s", terrstr());
     return -1;
   }
-  }
 
   dDebug("bnode workers are initialized");
   return 0;

source/dnode/mgmt/mgmt_dnode/CMakeLists.txt

+aux_source_directory(src MGMT_DNODE)
+add_library(mgmt_dnode STATIC ${MGMT_DNODE})
+target_include_directories(
+    mgmt_dnode
+    PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+target_link_libraries(
+    mgmt_dnode node_util
+)
\ No newline at end of file

source/dnode/mgmt/interface/inc/dmInt.h → source/dnode/mgmt/mgmt_dnode/inc/dmInt.h

@@ -13,42 +13,58 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_DM_INT_H_
-#define _TD_DM_INT_H_
+#ifndef _TD_DND_QNODE_INT_H_
+#define _TD_DND_QNODE_INT_H_
 
-#include "dmDef.h"
+#include "dmUtil.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-// dmInt.c
-SMgmtWrapper *dmAcquireWrapper(SDnode *pDnode, EDndNodeType nType);
-int32_t       dmMarkWrapper(SMgmtWrapper *pWrapper);
-void          dmReleaseWrapper(SMgmtWrapper *pWrapper);
-const char   *dmStatName(EDndRunStatus stat);
-const char   *dmLogName(EDndNodeType ntype);
-const char   *dmProcName(EDndNodeType ntype);
-const char   *dmEventName(EDndEvent ev);
-
-void   dmSetStatus(SDnode *pDnode, EDndRunStatus stat);
-void   dmSetEvent(SDnode *pDnode, EDndEvent event);
-void   dmSetMsgHandle(SMgmtWrapper *pWrapper, tmsg_t msgType, NodeMsgFp nodeMsgFp, int8_t vgId);
-void   dmReportStartup(SDnode *pDnode, const char *pName, const char *pDesc);
-void   dmReportStartupByWrapper(SMgmtWrapper *pWrapper, const char *pName, const char *pDesc);
-void   dmProcessServerStatusReq(SDnode *pDnode, SRpcMsg *pMsg);
-void   dmProcessNetTestReq(SDnode *pDnode, SRpcMsg *pMsg);
-void   dmGetMonitorSysInfo(SMonSysInfo *pInfo);
-
-// dmFile.c
-int32_t   dmReadFile(SMgmtWrapper *pWrapper, bool *pDeployed);
-int32_t   dmWriteFile(SMgmtWrapper *pWrapper, bool deployed);
-TdFilePtr dmCheckRunning(const char *dataDir);
-int32_t   dmReadShmFile(SMgmtWrapper *pWrapper);
-int32_t   dmWriteShmFile(SMgmtWrapper *pWrapper);
+typedef struct SDnodeMgmt {
+  struct SDnode      *pDnode;
+  SMsgCb              msgCb;
+  const char         *path;
+  const char         *name;
+  TdThread            statusThread;
+  TdThread            monitorThread;
+  SSingleWorker       mgmtWorker;
+  ProcessCreateNodeFp processCreateNodeFp;
+  ProcessDropNodeFp   processDropNodeFp;
+  IsNodeDeployedFp    isNodeDeployedFp;
+  SDnodeData          data;
+} SDnodeMgmt;
+
+// dmEps.c
+int32_t dmReadEps(SDnodeMgmt *pMgmt);
+int32_t dmWriteEps(SDnodeMgmt *pMgmt);
+void    dmUpdateEps(SDnodeMgmt *pMgmt, SArray *pDnodeEps);
+
+// dmHandle.c
+SArray *dmGetMsgHandles();
+void    dmSendStatusReq(SDnodeMgmt *pMgmt);
+int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmProcessAuthRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmProcessServerRunStatus(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+
+// dmMonitor.c
+void dmGetVnodeLoads(SDnodeMgmt *pMgmt, SMonVloadInfo *pInfo);
+void dmGetMnodeLoads(SDnodeMgmt *pMgmt, SMonMloadInfo *pInfo);
+void dmSendMonitorReport(SDnodeMgmt *pMgmt);
+
+// dmWorker.c
+int32_t dmPutNodeMsgToMgmtQueue(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmStartStatusThread(SDnodeMgmt *pMgmt);
+void    dmStopStatusThread(SDnodeMgmt *pMgmt);
+int32_t dmStartMonitorThread(SDnodeMgmt *pMgmt);
+void    dmStopMonitorThread(SDnodeMgmt *pMgmt);
+int32_t dmStartWorker(SDnodeMgmt *pMgmt);
+void    dmStopWorker(SDnodeMgmt *pMgmt);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_DM_INT_H_*/
+#endif /*_TD_DND_QNODE_INT_H_*/
\ No newline at end of file

source/dnode/mgmt/implement/src/dmEps.c → source/dnode/mgmt/mgmt_dnode/src/dmEps.c

@@ -14,16 +14,16 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dmImp.h"
+#include "dmInt.h"
 
-static void dmPrintEps(SDnode *pDnode);
-static bool dmIsEpChanged(SDnode *pDnode, int32_t dnodeId, const char *ep);
-static void dmResetEps(SDnode *pDnode, SArray *dnodeEps);
+static void dmPrintEps(SDnodeMgmt *pMgmt);
+static bool dmIsEpChanged(SDnodeMgmt *pMgmt, int32_t dnodeId, const char *ep);
+static void dmResetEps(SDnodeMgmt *pMgmt, SArray *dnodeEps);
 
-static void dmGetDnodeEp(SDnode *pDnode, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t *pPort) {
-  taosRLockLatch(&pDnode->data.latch);
+static void dmGetDnodeEp(SDnodeMgmt *pMgmt, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t *pPort) {
+  taosRLockLatch(&pMgmt->data.latch);
 
-  SDnodeEp *pDnodeEp = taosHashGet(pDnode->data.dnodeHash, &dnodeId, sizeof(int32_t));
+  SDnodeEp *pDnodeEp = taosHashGet(pMgmt->data.dnodeHash, &dnodeId, sizeof(int32_t));
   if (pDnodeEp != NULL) {
     if (pPort != NULL) {
       *pPort = pDnodeEp->ep.port;
@@ -36,10 +36,10 @@ static void dmGetDnodeEp(SDnode *pDnode, int32_t dnodeId, char *pEp, char *pFqdn
     }
   }
 
-  taosRUnLockLatch(&pDnode->data.latch);
+  taosRUnLockLatch(&pMgmt->data.latch);
 }
 
-int32_t dmReadEps(SDnode *pDnode) {
+int32_t dmReadEps(SDnodeMgmt *pMgmt) {
   int32_t   code = TSDB_CODE_INVALID_JSON_FORMAT;
   int32_t   len = 0;
   int32_t   maxLen = 256 * 1024;
@@ -48,16 +48,15 @@ int32_t dmReadEps(SDnode *pDnode) {
   char      file[PATH_MAX] = {0};
   TdFilePtr pFile = NULL;
 
-  pDnode->data.dnodeEps = taosArrayInit(1, sizeof(SDnodeEp));
-  if (pDnode->data.dnodeEps == NULL) {
+  pMgmt->data.dnodeEps = taosArrayInit(1, sizeof(SDnodeEp));
+  if (pMgmt->data.dnodeEps == NULL) {
     dError("failed to calloc dnodeEp array since %s", strerror(errno));
     goto _OVER;
   }
 
-  snprintf(file, sizeof(file), "%s%sdnode.json", pDnode->wrappers[DNODE].path, TD_DIRSEP);
+  snprintf(file, sizeof(file), "%s%sdnode.json", pMgmt->path, TD_DIRSEP);
   pFile = taosOpenFile(file, TD_FILE_READ);
   if (pFile == NULL) {
-    // dDebug("file %s not exist", file);
     code = 0;
     goto _OVER;
   }
@@ -80,21 +79,21 @@ int32_t dmReadEps(SDnode *pDnode) {
     dError("failed to read %s since dnodeId not found", file);
     goto _OVER;
   }
-  pDnode->data.dnodeId = dnodeId->valueint;
+  pMgmt->data.dnodeId = dnodeId->valueint;
 
   cJSON *clusterId = cJSON_GetObjectItem(root, "clusterId");
   if (!clusterId || clusterId->type != cJSON_String) {
     dError("failed to read %s since clusterId not found", file);
     goto _OVER;
   }
-  pDnode->data.clusterId = atoll(clusterId->valuestring);
+  pMgmt->data.clusterId = atoll(clusterId->valuestring);
 
   cJSON *dropped = cJSON_GetObjectItem(root, "dropped");
   if (!dropped || dropped->type != cJSON_Number) {
     dError("failed to read %s since dropped not found", file);
     goto _OVER;
   }
-  pDnode->data.dropped = dropped->valueint;
+  pMgmt->data.dropped = dropped->valueint;
 
   cJSON *dnodes = cJSON_GetObjectItem(root, "dnodes");
   if (!dnodes || dnodes->type != cJSON_Array) {
@@ -144,29 +143,29 @@ int32_t dmReadEps(SDnode *pDnode) {
     }
     dnodeEp.isMnode = isMnode->valueint;
 
-    taosArrayPush(pDnode->data.dnodeEps, &dnodeEp);
+    taosArrayPush(pMgmt->data.dnodeEps, &dnodeEp);
   }
 
   code = 0;
   dDebug("succcessed to read file %s", file);
-  dmPrintEps(pDnode);
+  dmPrintEps(pMgmt);
 
 _OVER:
   if (content != NULL) taosMemoryFree(content);
   if (root != NULL) cJSON_Delete(root);
   if (pFile != NULL) taosCloseFile(&pFile);
 
-  if (taosArrayGetSize(pDnode->data.dnodeEps) == 0) {
+  if (taosArrayGetSize(pMgmt->data.dnodeEps) == 0) {
     SDnodeEp dnodeEp = {0};
     dnodeEp.isMnode = 1;
-    taosGetFqdnPortFromEp(pDnode->data.firstEp, &dnodeEp.ep);
-    taosArrayPush(pDnode->data.dnodeEps, &dnodeEp);
+    taosGetFqdnPortFromEp(pMgmt->data.firstEp, &dnodeEp.ep);
+    taosArrayPush(pMgmt->data.dnodeEps, &dnodeEp);
   }
 
-  dmResetEps(pDnode, pDnode->data.dnodeEps);
+  dmResetEps(pMgmt, pMgmt->data.dnodeEps);
 
-  if (dmIsEpChanged(pDnode, pDnode->data.dnodeId, pDnode->data.localEp)) {
-    dError("localEp %s different with %s and need reconfigured", pDnode->data.localEp, file);
+  if (dmIsEpChanged(pMgmt, pMgmt->data.dnodeId, pMgmt->data.localEp)) {
+    dError("localEp %s different with %s and need reconfigured", pMgmt->data.localEp, file);
     return -1;
   }
 
@@ -174,11 +173,11 @@ _OVER:
   return code;
 }
 
-int32_t dmWriteEps(SDnode *pDnode) {
+int32_t dmWriteEps(SDnodeMgmt *pMgmt) {
   char file[PATH_MAX] = {0};
   char realfile[PATH_MAX] = {0};
-  snprintf(file, sizeof(file), "%s%sdnode.json.bak", pDnode->wrappers[DNODE].path, TD_DIRSEP);
-  snprintf(realfile, sizeof(realfile), "%s%sdnode.json", pDnode->wrappers[DNODE].path, TD_DIRSEP);
+  snprintf(file, sizeof(file), "%s%sdnode.json.bak", pMgmt->path, TD_DIRSEP);
+  snprintf(realfile, sizeof(realfile), "%s%sdnode.json", pMgmt->path, TD_DIRSEP);
 
   TdFilePtr pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC);
   if (pFile == NULL) {
@@ -192,14 +191,14 @@ int32_t dmWriteEps(SDnode *pDnode) {
   char   *content = taosMemoryCalloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
-  len += snprintf(content + len, maxLen - len, "  \"dnodeId\": %d,\n", pDnode->data.dnodeId);
-  len += snprintf(content + len, maxLen - len, "  \"clusterId\": \"%" PRId64 "\",\n", pDnode->data.clusterId);
-  len += snprintf(content + len, maxLen - len, "  \"dropped\": %d,\n", pDnode->data.dropped);
+  len += snprintf(content + len, maxLen - len, "  \"dnodeId\": %d,\n", pMgmt->data.dnodeId);
+  len += snprintf(content + len, maxLen - len, "  \"clusterId\": \"%" PRId64 "\",\n", pMgmt->data.clusterId);
+  len += snprintf(content + len, maxLen - len, "  \"dropped\": %d,\n", pMgmt->data.dropped);
   len += snprintf(content + len, maxLen - len, "  \"dnodes\": [{\n");
 
-  int32_t numOfEps = (int32_t)taosArrayGetSize(pDnode->data.dnodeEps);
+  int32_t numOfEps = (int32_t)taosArrayGetSize(pMgmt->data.dnodeEps);
   for (int32_t i = 0; i < numOfEps; ++i) {
-    SDnodeEp *pDnodeEp = taosArrayGet(pDnode->data.dnodeEps, i);
+    SDnodeEp *pDnodeEp = taosArrayGet(pMgmt->data.dnodeEps, i);
     len += snprintf(content + len, maxLen - len, "    \"id\": %d,\n", pDnodeEp->id);
     len += snprintf(content + len, maxLen - len, "    \"fqdn\": \"%s\",\n", pDnodeEp->ep.fqdn);
     len += snprintf(content + len, maxLen - len, "    \"port\": %u,\n", pDnodeEp->ep.port);
@@ -223,41 +222,41 @@ int32_t dmWriteEps(SDnode *pDnode) {
     return -1;
   }
 
-  pDnode->data.updateTime = taosGetTimestampMs();
+  pMgmt->data.updateTime = taosGetTimestampMs();
   dDebug("successed to write %s", realfile);
   return 0;
 }
 
-void dmUpdateEps(SDnode *pDnode, SArray *eps) {
+void dmUpdateEps(SDnodeMgmt *pMgmt, SArray *eps) {
   int32_t numOfEps = taosArrayGetSize(eps);
   if (numOfEps <= 0) return;
 
-  taosWLockLatch(&pDnode->data.latch);
+  taosWLockLatch(&pMgmt->data.latch);
 
-  int32_t numOfEpsOld = (int32_t)taosArrayGetSize(pDnode->data.dnodeEps);
+  int32_t numOfEpsOld = (int32_t)taosArrayGetSize(pMgmt->data.dnodeEps);
   if (numOfEps != numOfEpsOld) {
-    dmResetEps(pDnode, eps);
-    dmWriteEps(pDnode);
+    dmResetEps(pMgmt, eps);
+    dmWriteEps(pMgmt);
   } else {
     int32_t size = numOfEps * sizeof(SDnodeEp);
-    if (memcmp(pDnode->data.dnodeEps->pData, eps->pData, size) != 0) {
-      dmResetEps(pDnode, eps);
-      dmWriteEps(pDnode);
+    if (memcmp(pMgmt->data.dnodeEps->pData, eps->pData, size) != 0) {
+      dmResetEps(pMgmt, eps);
+      dmWriteEps(pMgmt);
     }
   }
 
-  taosWUnLockLatch(&pDnode->data.latch);
+  taosWUnLockLatch(&pMgmt->data.latch);
 }
 
-static void dmResetEps(SDnode *pDnode, SArray *dnodeEps) {
-  if (pDnode->data.dnodeEps != dnodeEps) {
-    SArray *tmp = pDnode->data.dnodeEps;
-    pDnode->data.dnodeEps = taosArrayDup(dnodeEps);
+static void dmResetEps(SDnodeMgmt *pMgmt, SArray *dnodeEps) {
+  if (pMgmt->data.dnodeEps != dnodeEps) {
+    SArray *tmp = pMgmt->data.dnodeEps;
+    pMgmt->data.dnodeEps = taosArrayDup(dnodeEps);
     taosArrayDestroy(tmp);
   }
 
-  pDnode->data.mnodeEps.inUse = 0;
-  pDnode->data.mnodeEps.numOfEps = 0;
+  pMgmt->data.mnodeEps.inUse = 0;
+  pMgmt->data.mnodeEps.numOfEps = 0;
 
   int32_t mIndex = 0;
   int32_t numOfEps = (int32_t)taosArrayGetSize(dnodeEps);
@@ -266,35 +265,35 @@ static void dmResetEps(SDnode *pDnode, SArray *dnodeEps) {
     SDnodeEp *pDnodeEp = taosArrayGet(dnodeEps, i);
     if (!pDnodeEp->isMnode) continue;
     if (mIndex >= TSDB_MAX_REPLICA) continue;
-    pDnode->data.mnodeEps.numOfEps++;
+    pMgmt->data.mnodeEps.numOfEps++;
 
-    pDnode->data.mnodeEps.eps[mIndex] = pDnodeEp->ep;
+    pMgmt->data.mnodeEps.eps[mIndex] = pDnodeEp->ep;
     mIndex++;
   }
 
   for (int32_t i = 0; i < numOfEps; i++) {
     SDnodeEp *pDnodeEp = taosArrayGet(dnodeEps, i);
-    taosHashPut(pDnode->data.dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp));
+    taosHashPut(pMgmt->data.dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp));
   }
 
-  dmPrintEps(pDnode);
+  dmPrintEps(pMgmt);
 }
 
-static void dmPrintEps(SDnode *pDnode) {
-  int32_t numOfEps = (int32_t)taosArrayGetSize(pDnode->data.dnodeEps);
+static void dmPrintEps(SDnodeMgmt *pMgmt) {
+  int32_t numOfEps = (int32_t)taosArrayGetSize(pMgmt->data.dnodeEps);
   dDebug("print dnode ep list, num:%d", numOfEps);
   for (int32_t i = 0; i < numOfEps; i++) {
-    SDnodeEp *pEp = taosArrayGet(pDnode->data.dnodeEps, i);
+    SDnodeEp *pEp = taosArrayGet(pMgmt->data.dnodeEps, i);
     dDebug("dnode:%d, fqdn:%s port:%u isMnode:%d", pEp->id, pEp->ep.fqdn, pEp->ep.port, pEp->isMnode);
   }
 }
 
-static bool dmIsEpChanged(SDnode *pDnode, int32_t dnodeId, const char *ep) {
+static bool dmIsEpChanged(SDnodeMgmt *pMgmt, int32_t dnodeId, const char *ep) {
   bool changed = false;
   if (dnodeId == 0) return changed;
-  taosRLockLatch(&pDnode->data.latch);
+  taosRLockLatch(&pMgmt->data.latch);
 
-  SDnodeEp *pDnodeEp = taosHashGet(pDnode->data.dnodeHash, &dnodeId, sizeof(int32_t));
+  SDnodeEp *pDnodeEp = taosHashGet(pMgmt->data.dnodeHash, &dnodeId, sizeof(int32_t));
   if (pDnodeEp != NULL) {
     char epstr[TSDB_EP_LEN + 1] = {0};
     snprintf(epstr, TSDB_EP_LEN, "%s:%u", pDnodeEp->ep.fqdn, pDnodeEp->ep.port);
@@ -304,6 +303,6 @@ static bool dmIsEpChanged(SDnode *pDnode, int32_t dnodeId, const char *ep) {
     }
   }
 
-  taosRUnLockLatch(&pDnode->data.latch);
+  taosRUnLockLatch(&pMgmt->data.latch);
   return changed;
 }

source/dnode/mgmt/mgmt_dnode/src/dmHandle.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 "dmInt.h"
+
+static void dmUpdateDnodeCfg(SDnodeMgmt *pMgmt, SDnodeCfg *pCfg) {
+  if (pMgmt->data.dnodeId == 0 || pMgmt->data.clusterId == 0) {
+    dInfo("set dnodeId:%d clusterId:%" PRId64, pCfg->dnodeId, pCfg->clusterId);
+    taosWLockLatch(&pMgmt->data.latch);
+    pMgmt->data.dnodeId = pCfg->dnodeId;
+    pMgmt->data.clusterId = pCfg->clusterId;
+    dmWriteEps(pMgmt);
+    taosWUnLockLatch(&pMgmt->data.latch);
+  }
+}
+
+static void dmProcessStatusRsp(SDnodeMgmt *pMgmt, SRpcMsg *pRsp) {
+  if (pRsp->code != 0) {
+    if (pRsp->code == TSDB_CODE_MND_DNODE_NOT_EXIST && !pMgmt->data.dropped && pMgmt->data.dnodeId > 0) {
+      dInfo("dnode:%d, set to dropped since not exist in mnode", pMgmt->data.dnodeId);
+      pMgmt->data.dropped = 1;
+      dmWriteEps(pMgmt);
+    }
+  } else {
+    SStatusRsp statusRsp = {0};
+    if (pRsp->pCont != NULL && pRsp->contLen > 0 &&
+        tDeserializeSStatusRsp(pRsp->pCont, pRsp->contLen, &statusRsp) == 0) {
+      pMgmt->data.dnodeVer = statusRsp.dnodeVer;
+      dmUpdateDnodeCfg(pMgmt, &statusRsp.dnodeCfg);
+      dmUpdateEps(pMgmt, statusRsp.pDnodeEps);
+    }
+    rpcFreeCont(pRsp->pCont);
+    tFreeSStatusRsp(&statusRsp);
+  }
+}
+
+void dmSendStatusReq(SDnodeMgmt *pMgmt) {
+  SStatusReq req = {0};
+
+  taosRLockLatch(&pMgmt->data.latch);
+  req.sver = tsVersion;
+  req.dnodeVer = pMgmt->data.dnodeVer;
+  req.dnodeId = pMgmt->data.dnodeId;
+  req.clusterId = pMgmt->data.clusterId;
+  if (req.clusterId == 0) req.dnodeId = 0;
+  req.rebootTime = pMgmt->data.rebootTime;
+  req.updateTime = pMgmt->data.updateTime;
+  req.numOfCores = tsNumOfCores;
+  req.numOfSupportVnodes = pMgmt->data.supportVnodes;
+  tstrncpy(req.dnodeEp, pMgmt->data.localEp, TSDB_EP_LEN);
+
+  req.clusterCfg.statusInterval = tsStatusInterval;
+  req.clusterCfg.checkTime = 0;
+  char timestr[32] = "1970-01-01 00:00:00.00";
+  (void)taosParseTime(timestr, &req.clusterCfg.checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
+  memcpy(req.clusterCfg.timezone, tsTimezoneStr, TD_TIMEZONE_LEN);
+  memcpy(req.clusterCfg.locale, tsLocale, TD_LOCALE_LEN);
+  memcpy(req.clusterCfg.charset, tsCharset, TD_LOCALE_LEN);
+  taosRUnLockLatch(&pMgmt->data.latch);
+
+  SMonVloadInfo vinfo = {0};
+  dmGetVnodeLoads(pMgmt, &vinfo);
+  req.pVloads = vinfo.pVloads;
+  pMgmt->data.unsyncedVgId = 0;
+  pMgmt->data.vndState = TAOS_SYNC_STATE_LEADER;
+  for (int32_t i = 0; i < taosArrayGetSize(req.pVloads); ++i) {
+    SVnodeLoad *pLoad = taosArrayGet(req.pVloads, i);
+    if (pLoad->syncState != TAOS_SYNC_STATE_LEADER && pLoad->syncState != TAOS_SYNC_STATE_FOLLOWER) {
+      pMgmt->data.unsyncedVgId = pLoad->vgId;
+      pMgmt->data.vndState = pLoad->syncState;
+    }
+  }
+
+  SMonMloadInfo minfo = {0};
+  dmGetMnodeLoads(pMgmt, &minfo);
+  pMgmt->data.mndState = minfo.load.syncState;
+
+  int32_t contLen = tSerializeSStatusReq(NULL, 0, &req);
+  void   *pHead = rpcMallocCont(contLen);
+  tSerializeSStatusReq(pHead, contLen, &req);
+  tFreeSStatusReq(&req);
+
+  SRpcMsg rpcMsg = {.pCont = pHead, .contLen = contLen, .msgType = TDMT_MND_STATUS, .ahandle = (void *)0x9527};
+  SRpcMsg rpcRsp = {0};
+
+  dTrace("send req:%s to mnode, app:%p", TMSG_INFO(rpcMsg.msgType), rpcMsg.ahandle);
+  tmsgSendMnodeRecv(&rpcMsg, &rpcRsp);
+  dmProcessStatusRsp(pMgmt, &rpcRsp);
+}
+
+int32_t dmProcessAuthRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  SRpcMsg *pRsp = &pMsg->rpcMsg;
+  dError("auth rsp is received, but not supported yet");
+  return 0;
+}
+
+int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  SRpcMsg *pRsp = &pMsg->rpcMsg;
+  dError("grant rsp is received, but not supported yet");
+  return 0;
+}
+
+int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  SRpcMsg       *pReq = &pMsg->rpcMsg;
+  SDCfgDnodeReq *pCfg = pReq->pCont;
+  dError("config req is received, but not supported yet");
+  return TSDB_CODE_OPS_NOT_SUPPORT;
+}
+
+static void dmGetServerRunStatus(SDnodeMgmt *pMgmt, SServerStatusRsp *pStatus) {
+  pStatus->statusCode = TSDB_SRV_STATUS_SERVICE_OK;
+  pStatus->details[0] = 0;
+
+  SServerStatusRsp statusRsp = {0};
+  SMonMloadInfo    minfo = {0};
+  dmGetMnodeLoads(pMgmt, &minfo);
+  if (minfo.isMnode && minfo.load.syncState != TAOS_SYNC_STATE_LEADER &&
+      minfo.load.syncState != TAOS_SYNC_STATE_CANDIDATE) {
+    pStatus->statusCode = TSDB_SRV_STATUS_SERVICE_DEGRADED;
+    snprintf(pStatus->details, sizeof(pStatus->details), "mnode sync state is %s", syncStr(minfo.load.syncState));
+    return;
+  }
+
+  SMonVloadInfo vinfo = {0};
+  dmGetVnodeLoads(pMgmt, &vinfo);
+  for (int32_t i = 0; i < taosArrayGetSize(vinfo.pVloads); ++i) {
+    SVnodeLoad *pLoad = taosArrayGet(vinfo.pVloads, i);
+    if (pLoad->syncState != TAOS_SYNC_STATE_LEADER && pLoad->syncState != TAOS_SYNC_STATE_FOLLOWER) {
+      pStatus->statusCode = TSDB_SRV_STATUS_SERVICE_DEGRADED;
+      snprintf(pStatus->details, sizeof(pStatus->details), "vnode:%d sync state is %s", pLoad->vgId,
+               syncStr(pLoad->syncState));
+      break;
+    }
+  }
+
+  taosArrayDestroy(vinfo.pVloads);
+}
+
+int32_t dmProcessServerRunStatus(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  dDebug("server run status req is received");
+  SServerStatusRsp statusRsp = {0};
+  dmGetServerRunStatus(pMgmt, &statusRsp);
+
+  SRpcMsg rspMsg = {.handle = pMsg->rpcMsg.handle, .ahandle = pMsg->rpcMsg.ahandle, .refId = pMsg->rpcMsg.refId};
+  int32_t rspLen = tSerializeSServerStatusRsp(NULL, 0, &statusRsp);
+  if (rspLen < 0) {
+    rspMsg.code = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  void *pRsp = rpcMallocCont(rspLen);
+  if (pRsp == NULL) {
+    rspMsg.code = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  tSerializeSServerStatusRsp(pRsp, rspLen, &statusRsp);
+  pMsg->pRsp = pRsp;
+  pMsg->rspLen = rspLen;
+  return 0;
+}
+
+SArray *dmGetMsgHandles() {
+  int32_t code = -1;
+  SArray *pArray = taosArrayInit(16, sizeof(SMgmtHandle));
+  if (pArray == NULL) goto _OVER;
+
+  // Requests handled by DNODE
+  if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_MNODE, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_MNODE, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_QNODE, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_QNODE, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_SNODE, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_SNODE, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_BNODE, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_BNODE, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_CONFIG_DNODE, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_SERVER_STATUS, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+
+  // Requests handled by MNODE
+  if (dmSetMgmtHandle(pArray, TDMT_MND_GRANT_RSP, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_AUTH_RSP, dmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
+
+  code = 0;
+
+_OVER:
+  if (code != 0) {
+    taosArrayDestroy(pArray);
+    return NULL;
+  } else {
+    return pArray;
+  }
+}

source/dnode/mgmt/mgmt_dnode/src/dmInt.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 "dmInt.h"
+
+static int32_t dmStartMgmt(SDnodeMgmt *pMgmt) {
+  if (dmStartStatusThread(pMgmt) != 0) {
+    return -1;
+  }
+  if (dmStartMonitorThread(pMgmt) != 0) {
+    return -1;
+  }
+  return 0;
+}
+
+static void dmStopMgmt(SDnodeMgmt *pMgmt) {
+  pMgmt->data.stopped = true;
+  dmStopMonitorThread(pMgmt);
+  dmStopStatusThread(pMgmt);
+}
+
+static int32_t dmOpenMgmt(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
+  dInfo("dnode-mgmt start to init");
+  SDnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SDnodeMgmt));
+  if (pMgmt == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  pMgmt->data.dnodeId = 0;
+  pMgmt->data.clusterId = 0;
+  pMgmt->data.dnodeVer = 0;
+  pMgmt->data.updateTime = 0;
+  pMgmt->data.rebootTime = taosGetTimestampMs();
+  pMgmt->data.dropped = 0;
+  pMgmt->data.localEp = pInput->localEp;
+  pMgmt->data.localFqdn = pInput->localFqdn;
+  pMgmt->data.firstEp = pInput->firstEp;
+  pMgmt->data.secondEp = pInput->secondEp;
+  pMgmt->data.supportVnodes = pInput->supportVnodes;
+  pMgmt->data.serverPort = pInput->serverPort;
+  pMgmt->pDnode = pInput->pDnode;
+  pMgmt->msgCb = pInput->msgCb;
+  pMgmt->path = pInput->path;
+  pMgmt->name = pInput->name;
+  pMgmt->processCreateNodeFp = pInput->processCreateNodeFp;
+  pMgmt->processDropNodeFp = pInput->processDropNodeFp;
+  pMgmt->isNodeDeployedFp = pInput->isNodeDeployedFp;
+  taosInitRWLatch(&pMgmt->data.latch);
+
+  pMgmt->data.dnodeHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
+  if (pMgmt->data.dnodeHash == NULL) {
+    dError("failed to init dnode hash");
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  if (dmReadEps(pMgmt) != 0) {
+    dError("failed to read file since %s", terrstr());
+    return -1;
+  }
+
+  if (pMgmt->data.dropped) {
+    dError("dnode will not start since its already dropped");
+    return -1;
+  }
+
+  if (dmStartWorker(pMgmt) != 0) {
+    return -1;
+  }
+
+  if (udfStartUdfd(pMgmt->data.dnodeId) != 0) {
+    dError("failed to start udfd");
+  }
+
+  pOutput->pMgmt = pMgmt;
+  pOutput->mnodeEps = pMgmt->data.mnodeEps;
+  dInfo("dnode-mgmt is initialized");
+  return 0;
+}
+
+static void dmCloseMgmt(SDnodeMgmt *pMgmt) {
+  dInfo("dnode-mgmt start to clean up");
+  dmStopWorker(pMgmt);
+
+  taosWLockLatch(&pMgmt->data.latch);
+  if (pMgmt->data.dnodeEps != NULL) {
+    taosArrayDestroy(pMgmt->data.dnodeEps);
+    pMgmt->data.dnodeEps = NULL;
+  }
+  if (pMgmt->data.dnodeHash != NULL) {
+    taosHashCleanup(pMgmt->data.dnodeHash);
+    pMgmt->data.dnodeHash = NULL;
+  }
+  taosWUnLockLatch(&pMgmt->data.latch);
+  taosMemoryFree(pMgmt);
+
+  dInfo("dnode-mgmt is cleaned up");
+}
+
+static int32_t dmRequireMgmt(const SMgmtInputOpt *pInput, bool *required) {
+  *required = true;
+  return 0;
+}
+
+SMgmtFunc dmGetMgmtFunc() {
+  SMgmtFunc mgmtFunc = {0};
+  mgmtFunc.openFp = dmOpenMgmt;
+  mgmtFunc.closeFp = (NodeCloseFp)dmCloseMgmt;
+  mgmtFunc.startFp = (NodeStartFp)dmStartMgmt;
+  mgmtFunc.stopFp = (NodeStopFp)dmStopMgmt;
+  mgmtFunc.requiredFp = dmRequireMgmt;
+  mgmtFunc.getHandlesFp = dmGetMsgHandles;
+
+  return mgmtFunc;
+}

source/dnode/mgmt/mgmt_dnode/src/dmMonitor.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 "dmInt.h"
+
+#define dmSendLocalRecv(pMgmt, mtype, func, pInfo)                     \
+  if (!tsMultiProcess) {                                                \
+    SRpcMsg rsp = {0};                                                 \
+    SRpcMsg req = {.msgType = mtype};                                  \
+    SEpSet  epset = {.inUse = 0, .numOfEps = 1};                       \
+    tstrncpy(epset.eps[0].fqdn, pMgmt->data.localFqdn, TSDB_FQDN_LEN); \
+    epset.eps[0].port = pMgmt->data.serverPort;                        \
+                                                                       \
+    rpcSendRecv(pMgmt->msgCb.clientRpc, &epset, &req, &rsp);           \
+    if (rsp.code == 0 && rsp.contLen > 0) {                            \
+      func(rsp.pCont, rsp.contLen, pInfo);                             \
+    }                                                                  \
+    rpcFreeCont(rsp.pCont);                                            \
+  }
+
+static void dmGetMonitorBasicInfo(SDnodeMgmt *pMgmt, SMonBasicInfo *pInfo) {
+  pInfo->protocol = 1;
+  pInfo->dnode_id = pMgmt->data.dnodeId;
+  pInfo->cluster_id = pMgmt->data.clusterId;
+  tstrncpy(pInfo->dnode_ep, tsLocalEp, TSDB_EP_LEN);
+}
+
+static void dmGetMonitorDnodeInfo(SDnodeMgmt *pMgmt, SMonDnodeInfo *pInfo) {
+  pInfo->uptime = (taosGetTimestampMs() - pMgmt->data.rebootTime) / (86400000.0f);
+  pInfo->has_mnode = (*pMgmt->isNodeDeployedFp)(pMgmt->pDnode, MNODE);
+  pInfo->has_qnode = (*pMgmt->isNodeDeployedFp)(pMgmt->pDnode, QNODE);
+  pInfo->has_snode = (*pMgmt->isNodeDeployedFp)(pMgmt->pDnode, SNODE);
+  pInfo->has_bnode = (*pMgmt->isNodeDeployedFp)(pMgmt->pDnode, BNODE);
+  tstrncpy(pInfo->logdir.name, tsLogDir, sizeof(pInfo->logdir.name));
+  pInfo->logdir.size = tsLogSpace.size;
+  tstrncpy(pInfo->tempdir.name, tsTempDir, sizeof(pInfo->tempdir.name));
+  pInfo->tempdir.size = tsTempSpace.size;
+}
+
+static void dmGetMonitorInfo(SDnodeMgmt *pMgmt, SMonDmInfo *pInfo) {
+  dmGetMonitorBasicInfo(pMgmt, &pInfo->basic);
+  dmGetMonitorDnodeInfo(pMgmt, &pInfo->dnode);
+  dmGetMonitorSystemInfo(&pInfo->sys);
+}
+
+void dmSendMonitorReport(SDnodeMgmt *pMgmt) {
+  if (!tsEnableMonitor || tsMonitorFqdn[0] == 0 || tsMonitorPort == 0) return;
+  dTrace("send monitor report to %s:%u", tsMonitorFqdn, tsMonitorPort);
+
+  SMonDmInfo dmInfo = {0};
+  SMonMmInfo mmInfo = {0};
+  SMonVmInfo vmInfo = {0};
+  SMonQmInfo qmInfo = {0};
+  SMonSmInfo smInfo = {0};
+  SMonBmInfo bmInfo = {0};
+
+  dmGetMonitorInfo(pMgmt, &dmInfo);
+  dmSendLocalRecv(pMgmt, TDMT_MON_VM_INFO, tDeserializeSMonVmInfo, &vmInfo);
+  if (dmInfo.dnode.has_mnode) {
+    dmSendLocalRecv(pMgmt, TDMT_MON_MM_INFO, tDeserializeSMonMmInfo, &mmInfo);
+  }
+  if (dmInfo.dnode.has_qnode) {
+    dmSendLocalRecv(pMgmt, TDMT_MON_QM_INFO, tDeserializeSMonQmInfo, &qmInfo);
+  }
+  if (dmInfo.dnode.has_snode) {
+    dmSendLocalRecv(pMgmt, TDMT_MON_SM_INFO, tDeserializeSMonSmInfo, &smInfo);
+  }
+  if (dmInfo.dnode.has_bnode) {
+    dmSendLocalRecv(pMgmt, TDMT_MON_BM_INFO, tDeserializeSMonBmInfo, &bmInfo);
+  }
+
+  monSetDmInfo(&dmInfo);
+  monSetMmInfo(&mmInfo);
+  monSetVmInfo(&vmInfo);
+  monSetQmInfo(&qmInfo);
+  monSetSmInfo(&smInfo);
+  monSetBmInfo(&bmInfo);
+  tFreeSMonMmInfo(&mmInfo);
+  tFreeSMonVmInfo(&vmInfo);
+  tFreeSMonQmInfo(&qmInfo);
+  tFreeSMonSmInfo(&smInfo);
+  tFreeSMonBmInfo(&bmInfo);
+  monSendReport();
+}
+
+void dmGetVnodeLoads(SDnodeMgmt *pMgmt, SMonVloadInfo *pInfo) {
+  dmSendLocalRecv(pMgmt, TDMT_MON_VM_LOAD, tDeserializeSMonVloadInfo, pInfo);
+}
+
+void dmGetMnodeLoads(SDnodeMgmt *pMgmt, SMonMloadInfo *pInfo) {
+  dmSendLocalRecv(pMgmt, TDMT_MON_MM_LOAD, tDeserializeSMonMloadInfo, pInfo);
+}

source/dnode/mgmt/implement/src/dmWorker.c → source/dnode/mgmt/mgmt_dnode/src/dmWorker.c

@@ -14,26 +14,22 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dmImp.h"
+#include "dmInt.h"
 
 static void *dmStatusThreadFp(void *param) {
-  SDnode *pDnode = param;
+  SDnodeMgmt *pMgmt = param;
   int64_t     lastTime = taosGetTimestampMs();
 
   setThreadName("dnode-status");
 
   while (1) {
-    taosThreadTestCancel();
     taosMsleep(200);
-
-    if (pDnode->status != DND_STAT_RUNNING || pDnode->data.dropped) {
-      continue;
-    }
+    if (pMgmt->data.dropped || pMgmt->data.stopped) break;
 
     int64_t curTime = taosGetTimestampMs();
     float   interval = (curTime - lastTime) / 1000.0f;
     if (interval >= tsStatusInterval) {
-      dmSendStatusReq(pDnode);
+      dmSendStatusReq(pMgmt);
       lastTime = curTime;
     }
   }
@@ -42,23 +38,19 @@ static void *dmStatusThreadFp(void *param) {
 }
 
 static void *dmMonitorThreadFp(void *param) {
-  SDnode *pDnode = param;
+  SDnodeMgmt *pMgmt = param;
   int64_t     lastTime = taosGetTimestampMs();
 
   setThreadName("dnode-monitor");
 
   while (1) {
-    taosThreadTestCancel();
     taosMsleep(200);
-
-    if (pDnode->status != DND_STAT_RUNNING || pDnode->data.dropped) {
-      continue;
-    }
+    if (pMgmt->data.dropped || pMgmt->data.stopped) break;
 
     int64_t curTime = taosGetTimestampMs();
     float   interval = (curTime - lastTime) / 1000.0f;
     if (interval >= tsMonitorInterval) {
-      dmSendMonitorReport(pDnode);
+      dmSendMonitorReport(pMgmt);
       lastTime = curTime;
     }
   }
@@ -66,96 +58,104 @@ static void *dmMonitorThreadFp(void *param) {
   return NULL;
 }
 
-int32_t dmStartStatusThread(SDnode *pDnode) {
-  pDnode->data.statusThreadId = taosCreateThread(dmStatusThreadFp, pDnode);
-  if (pDnode->data.statusThreadId == NULL) {
-    dError("failed to init dnode status thread");
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+int32_t dmStartStatusThread(SDnodeMgmt *pMgmt) {
+  TdThreadAttr thAttr;
+  taosThreadAttrInit(&thAttr);
+  taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
+  if (taosThreadCreate(&pMgmt->statusThread, &thAttr, dmStatusThreadFp, pMgmt) != 0) {
+    dError("failed to create status thread since %s", strerror(errno));
     return -1;
   }
 
-  dmReportStartup(pDnode, "dnode-status", "initialized");
+  taosThreadAttrDestroy(&thAttr);
+  tmsgReportStartup("dnode-status", "initialized");
   return 0;
 }
 
-void dmStopStatusThread(SDnode *pDnode) {
-  if (pDnode->data.statusThreadId != NULL) {
-    taosDestoryThread(pDnode->data.statusThreadId);
-    pDnode->data.statusThreadId = NULL;
+void dmStopStatusThread(SDnodeMgmt *pMgmt) {
+  if (taosCheckPthreadValid(pMgmt->statusThread)) {
+    taosThreadJoin(pMgmt->statusThread, NULL);
   }
 }
 
-int32_t dmStartMonitorThread(SDnode *pDnode) {
-  pDnode->data.monitorThreadId = taosCreateThread(dmMonitorThreadFp, pDnode);
-  if (pDnode->data.monitorThreadId == NULL) {
-    dError("failed to init dnode monitor thread");
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+int32_t dmStartMonitorThread(SDnodeMgmt *pMgmt) {
+  TdThreadAttr thAttr;
+  taosThreadAttrInit(&thAttr);
+  taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
+  if (taosThreadCreate(&pMgmt->monitorThread, &thAttr, dmMonitorThreadFp, pMgmt) != 0) {
+    dError("failed to create monitor thread since %s", strerror(errno));
     return -1;
   }
 
-  dmReportStartup(pDnode, "dnode-monitor", "initialized");
+  taosThreadAttrDestroy(&thAttr);
+  tmsgReportStartup("dnode-monitor", "initialized");
   return 0;
 }
 
-void dmStopMonitorThread(SDnode *pDnode) {
-  if (pDnode->data.monitorThreadId != NULL) {
-    taosDestoryThread(pDnode->data.monitorThreadId);
-    pDnode->data.monitorThreadId = NULL;
+void dmStopMonitorThread(SDnodeMgmt *pMgmt) {
+  if (taosCheckPthreadValid(pMgmt->monitorThread)) {
+    taosThreadJoin(pMgmt->monitorThread, NULL);
   }
 }
 
 static void dmProcessMgmtQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
-  SDnode *pDnode = pInfo->ahandle;
-
+  SDnodeMgmt *pMgmt = pInfo->ahandle;
   int32_t     code = -1;
   tmsg_t      msgType = pMsg->rpcMsg.msgType;
-  dTrace("msg:%p, will be processed in dnode-mgmt queue", pMsg);
+  bool        isRequest = msgType & 1u;
+  dTrace("msg:%p, will be processed in dnode-mgmt queue, type:%s", pMsg, TMSG_INFO(msgType));
 
   switch (msgType) {
     case TDMT_DND_CONFIG_DNODE:
-      code = dmProcessConfigReq(pDnode, pMsg);
+      code = dmProcessConfigReq(pMgmt, pMsg);
       break;
     case TDMT_MND_AUTH_RSP:
-      code = dmProcessAuthRsp(pDnode, pMsg);
+      code = dmProcessAuthRsp(pMgmt, pMsg);
       break;
     case TDMT_MND_GRANT_RSP:
-      code = dmProcessGrantRsp(pDnode, pMsg);
+      code = dmProcessGrantRsp(pMgmt, pMsg);
       break;
     case TDMT_DND_CREATE_MNODE:
-      code = dmProcessCreateNodeReq(pDnode, MNODE, pMsg);
+      code = (*pMgmt->processCreateNodeFp)(pMgmt->pDnode, MNODE, pMsg);
       break;
     case TDMT_DND_DROP_MNODE:
-      code = dmProcessDropNodeReq(pDnode, MNODE, pMsg);
+      code = (*pMgmt->processDropNodeFp)(pMgmt->pDnode, MNODE, pMsg);
       break;
     case TDMT_DND_CREATE_QNODE:
-      code = dmProcessCreateNodeReq(pDnode, QNODE, pMsg);
+      code = (*pMgmt->processCreateNodeFp)(pMgmt->pDnode, QNODE, pMsg);
       break;
     case TDMT_DND_DROP_QNODE:
-      code = dmProcessDropNodeReq(pDnode, QNODE, pMsg);
+      code = (*pMgmt->processDropNodeFp)(pMgmt->pDnode, QNODE, pMsg);
       break;
     case TDMT_DND_CREATE_SNODE:
-      code = dmProcessCreateNodeReq(pDnode, SNODE, pMsg);
+      code = (*pMgmt->processCreateNodeFp)(pMgmt->pDnode, SNODE, pMsg);
       break;
     case TDMT_DND_DROP_SNODE:
-      code = dmProcessDropNodeReq(pDnode, SNODE, pMsg);
+      code = (*pMgmt->processDropNodeFp)(pMgmt->pDnode, SNODE, pMsg);
       break;
     case TDMT_DND_CREATE_BNODE:
-      code = dmProcessCreateNodeReq(pDnode, BNODE, pMsg);
+      code = (*pMgmt->processCreateNodeFp)(pMgmt->pDnode, BNODE, pMsg);
       break;
     case TDMT_DND_DROP_BNODE:
-      code = dmProcessDropNodeReq(pDnode, BNODE, pMsg);
+      code = (*pMgmt->processDropNodeFp)(pMgmt->pDnode, BNODE, pMsg);
+      break;
+    case TDMT_DND_SERVER_STATUS:
+      code = dmProcessServerRunStatus(pMgmt, pMsg);
       break;
     default:
+      terrno = TSDB_CODE_MSG_NOT_PROCESSED;
       break;
   }
 
-  if (msgType & 1u) {
+  if (isRequest) {
     if (code != 0 && terrno != 0) code = terrno;
     SRpcMsg rsp = {
         .handle = pMsg->rpcMsg.handle,
         .ahandle = pMsg->rpcMsg.ahandle,
         .code = code,
         .refId = pMsg->rpcMsg.refId,
+        .pCont = pMsg->pRsp,
+        .contLen = pMsg->rspLen,
     };
     rpcSendResponse(&rsp);
   }
@@ -165,15 +165,15 @@ static void dmProcessMgmtQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   taosFreeQitem(pMsg);
 }
 
-int32_t dmStartWorker(SDnode *pDnode) {
+int32_t dmStartWorker(SDnodeMgmt *pMgmt) {
   SSingleWorkerCfg cfg = {
       .min = 1,
       .max = 1,
       .name = "dnode-mgmt",
       .fp = (FItem)dmProcessMgmtQueue,
-      .param = pDnode,
+      .param = pMgmt,
   };
-  if (tSingleWorkerInit(&pDnode->data.mgmtWorker, &cfg) != 0) {
+  if (tSingleWorkerInit(&pMgmt->mgmtWorker, &cfg) != 0) {
     dError("failed to start dnode-mgmt worker since %s", terrstr());
     return -1;
   }
@@ -182,13 +182,13 @@ int32_t dmStartWorker(SDnode *pDnode) {
   return 0;
 }
 
-void dmStopWorker(SDnode *pDnode) {
-  tSingleWorkerCleanup(&pDnode->data.mgmtWorker);
+void dmStopWorker(SDnodeMgmt *pMgmt) {
+  tSingleWorkerCleanup(&pMgmt->mgmtWorker);
   dDebug("dnode workers are closed");
 }
 
-int32_t dmProcessMgmtMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SSingleWorker *pWorker = &pWrapper->pDnode->data.mgmtWorker;
+int32_t dmPutNodeMsgToMgmtQueue(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  SSingleWorker *pWorker = &pMgmt->mgmtWorker;
   dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
   taosWriteQitem(pWorker->queue, pMsg);
   return 0;

source/dnode/mgmt/mgmt_mnode/CMakeLists.txt

@@ -5,5 +5,5 @@ target_include_directories(
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    mgmt_mnode dnode_interface
+    mgmt_mnode node_util
 )
\ No newline at end of file

source/dnode/mgmt/mgmt_mnode/inc/mmInt.h

@@ -16,8 +16,7 @@
 #ifndef _TD_DND_MNODE_INT_H_
 #define _TD_DND_MNODE_INT_H_
 
-#include "dmInt.h"
-
+#include "dmUtil.h"
 #include "mnode.h"
 
 #ifdef __cplusplus
@@ -26,9 +25,10 @@ extern "C" {
 
 typedef struct SMnodeMgmt {
   SMnode       *pMnode;
-  SDnode       *pDnode;
-  SMgmtWrapper *pWrapper;
+  SMsgCb        msgCb;
   const char   *path;
+  const char   *name;
+  int32_t       dnodeId;
   SSingleWorker queryWorker;
   SSingleWorker readWorker;
   SSingleWorker writeWorker;
@@ -41,33 +41,31 @@ typedef struct SMnodeMgmt {
 
 // mmFile.c
 int32_t mmReadFile(SMnodeMgmt *pMgmt, bool *pDeployed);
-int32_t mmWriteFile(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq, bool deployed);
+int32_t mmWriteFile(SMnodeMgmt *pMgmt, SDCreateMnodeReq *pReq, bool deployed);
 
 // mmInt.c
 int32_t mmAlter(SMnodeMgmt *pMgmt, SDAlterMnodeReq *pReq);
 
 // mmHandle.c
-void    mmInitMsgHandle(SMgmtWrapper *pWrapper);
-int32_t mmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t mmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
+SArray *mmGetMsgHandles();
+int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg);
+int32_t mmProcessDropReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
-int32_t mmProcessGetMonMmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq);
-int32_t mmProcessGetMnodeLoadsReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq);
-void    mmGetMnodeLoads(SMgmtWrapper *pWrapper, SMonMloadInfo *pInfo);
+int32_t mmProcessGetMonitorInfoReq(SMnodeMgmt *pMgmt, SNodeMsg *pReq);
+int32_t mmProcessGetLoadsReq(SMnodeMgmt *pMgmt, SNodeMsg *pReq);
 
 // mmWorker.c
 int32_t mmStartWorker(SMnodeMgmt *pMgmt);
 void    mmStopWorker(SMnodeMgmt *pMgmt);
-int32_t mmProcessWriteMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t mmProcessSyncMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t mmProcessReadMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t mmProcessQueryMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t mmProcessMonitorMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-
-int32_t mmPutMsgToQueryQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc);
-int32_t mmPutMsgToReadQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc);
-int32_t mmPutMsgToWriteQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc);
-int32_t mmPutMsgToSyncQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc);
+int32_t mmPutNodeMsgToWriteQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmPutNodeMsgToSyncQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmPutNodeMsgToReadQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmPutNodeMsgToQueryQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmPutNodeMsgToMonitorQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmPutRpcMsgToQueryQueue(SMnodeMgmt *pMgmt, SRpcMsg *pRpc);
+int32_t mmPutRpcMsgToReadQueue(SMnodeMgmt *pMgmt, SRpcMsg *pRpc);
+int32_t mmPutRpcMsgToWriteQueue(SMnodeMgmt *pMgmt, SRpcMsg *pRpc);
+int32_t mmPutRpcMsgToSyncQueue(SMnodeMgmt *pMgmt, SRpcMsg *pRpc);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/mgmt_mnode/src/mmFile.c

@@ -28,7 +28,6 @@ int32_t mmReadFile(SMnodeMgmt *pMgmt, bool *pDeployed) {
   snprintf(file, sizeof(file), "%s%smnode.json", pMgmt->path, TD_DIRSEP);
   pFile = taosOpenFile(file, TD_FILE_READ);
   if (pFile == NULL) {
-    // dDebug("file %s not exist", file);
     code = 0;
     goto _OVER;
   }
@@ -105,11 +104,11 @@ _OVER:
   return code;
 }
 
-int32_t mmWriteFile(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq, bool deployed) {
+int32_t mmWriteFile(SMnodeMgmt *pMgmt, SDCreateMnodeReq *pReq, bool deployed) {
   char file[PATH_MAX] = {0};
   char realfile[PATH_MAX] = {0};
-  snprintf(file, sizeof(file), "%s%smnode.json.bak", pWrapper->path, TD_DIRSEP);
-  snprintf(realfile, sizeof(realfile), "%s%smnode.json", pWrapper->path, TD_DIRSEP);
+  snprintf(file, sizeof(file), "%s%smnode.json.bak", pMgmt->path, TD_DIRSEP);
+  snprintf(realfile, sizeof(realfile), "%s%smnode.json", pMgmt->path, TD_DIRSEP);
 
   TdFilePtr pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC);
   if (pFile == NULL) {
@@ -125,8 +124,6 @@ int32_t mmWriteFile(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq, bool deploye
   len += snprintf(content + len, maxLen - len, "{\n");
   len += snprintf(content + len, maxLen - len, "  \"mnodes\": [{\n");
 
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
-  if (pReq != NULL || pMgmt != NULL) {
   int8_t replica = (pReq != NULL ? pReq->replica : pMgmt->replica);
   for (int32_t i = 0; i < replica; ++i) {
     SReplica *pReplica = &pMgmt->replicas[i];
@@ -142,7 +139,6 @@ int32_t mmWriteFile(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq, bool deploye
       len += snprintf(content + len, maxLen - len, "  }],\n");
     }
   }
-  }
 
   len += snprintf(content + len, maxLen - len, "  \"deployed\": %d\n", deployed);
   len += snprintf(content + len, maxLen - len, "}\n");

source/dnode/mgmt/mgmt_mnode/src/mmHandle.c

@@ -16,15 +16,14 @@
 #define _DEFAULT_SOURCE
 #include "mmInt.h"
 
-void mmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonMmInfo *mmInfo) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
+static void mmGetMonitorInfo(SMnodeMgmt *pMgmt, SMonMmInfo *mmInfo) {
   mndGetMonitorInfo(pMgmt->pMnode, &mmInfo->cluster, &mmInfo->vgroup, &mmInfo->grant);
 }
 
-int32_t mmProcessGetMonMmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
+int32_t mmProcessGetMonitorInfoReq(SMnodeMgmt *pMgmt, SNodeMsg *pReq) {
   SMonMmInfo mmInfo = {0};
-  mmGetMonitorInfo(pWrapper, &mmInfo);
-  dmGetMonitorSysInfo(&mmInfo.sys);
+  mmGetMonitorInfo(pMgmt, &mmInfo);
+  dmGetMonitorSystemInfo(&mmInfo.sys);
   monGetLogs(&mmInfo.log);
 
   int32_t rspLen = tSerializeSMonMmInfo(NULL, 0, &mmInfo);
@@ -46,15 +45,14 @@ int32_t mmProcessGetMonMmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
   return 0;
 }
 
-void mmGetMnodeLoads(SMgmtWrapper *pWrapper, SMonMloadInfo *pInfo) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
+static void mmGetMnodeLoads(SMnodeMgmt *pMgmt, SMonMloadInfo *pInfo) {
   pInfo->isMnode = 1;
   mndGetLoad(pMgmt->pMnode, &pInfo->load);
 }
 
-int32_t mmProcessGetMnodeLoadsReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
+int32_t mmProcessGetLoadsReq(SMnodeMgmt *pMgmt, SNodeMsg *pReq) {
   SMonMloadInfo mloads = {0};
-  mmGetMnodeLoads(pWrapper, &mloads);
+  mmGetMnodeLoads(pMgmt, &mloads);
 
   int32_t rspLen = tSerializeSMonMloadInfo(NULL, 0, &mloads);
   if (rspLen < 0) {
@@ -74,8 +72,7 @@ int32_t mmProcessGetMnodeLoadsReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
   return 0;
 }
 
-int32_t mmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SDnode  *pDnode = pWrapper->pDnode;
+int32_t mmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
   SRpcMsg *pReq = &pMsg->rpcMsg;
 
   SDCreateMnodeReq createReq = {0};
@@ -84,14 +81,18 @@ int32_t mmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (createReq.replica <= 1 || createReq.dnodeId != pDnode->data.dnodeId) {
+  if (createReq.replica <= 1 || (createReq.dnodeId != pInput->dnodeId && pInput->dnodeId != 0)) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to create mnode since %s", terrstr());
     return -1;
   }
 
   bool deployed = true;
-  if (mmWriteFile(pWrapper, &createReq, deployed) != 0) {
+
+  SMnodeMgmt mgmt = {0};
+  mgmt.path = pInput->path;
+  mgmt.name = pInput->name;
+  if (mmWriteFile(&mgmt, &createReq, deployed) != 0) {
     dError("failed to write mnode file since %s", terrstr());
     return -1;
   }
@@ -99,8 +100,7 @@ int32_t mmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t mmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SDnode  *pDnode = pWrapper->pDnode;
+int32_t mmProcessDropReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   SRpcMsg *pReq = &pMsg->rpcMsg;
 
   SDDropMnodeReq dropReq = {0};
@@ -109,14 +109,14 @@ int32_t mmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (dropReq.dnodeId != pDnode->data.dnodeId) {
+  if (pMgmt->dnodeId != 0 && dropReq.dnodeId != pMgmt->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to drop mnode since %s", terrstr());
     return -1;
   }
 
   bool deployed = false;
-  if (mmWriteFile(pWrapper, NULL, deployed) != 0) {
+  if (mmWriteFile(pMgmt, NULL, deployed) != 0) {
     dError("failed to write mnode file since %s", terrstr());
     return -1;
   }
@@ -125,7 +125,6 @@ int32_t mmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
 }
 
 int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
-  SDnode  *pDnode = pMgmt->pDnode;
   SRpcMsg *pReq = &pMsg->rpcMsg;
 
   SDAlterMnodeReq alterReq = {0};
@@ -134,104 +133,118 @@ int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (pDnode->data.dnodeId != 0 && alterReq.dnodeId != pDnode->data.dnodeId) {
+  if (pMgmt->dnodeId != 0 && alterReq.dnodeId != pMgmt->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
-    dError("failed to alter mnode since %s, input:%d cur:%d", terrstr(), alterReq.dnodeId, pDnode->data.dnodeId);
+    dError("failed to alter mnode since %s, input:%d cur:%d", terrstr(), alterReq.dnodeId, pMgmt->dnodeId);
     return -1;
   } else {
     return mmAlter(pMgmt, &alterReq);
   }
 }
 
-void mmInitMsgHandle(SMgmtWrapper *pWrapper) {
-  dmSetMsgHandle(pWrapper, TDMT_MON_MM_INFO, mmProcessMonitorMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MON_MM_LOAD, mmProcessMonitorMsg, DEFAULT_HANDLE);
+SArray *mmGetMsgHandles() {
+  int32_t code = -1;
+  SArray *pArray = taosArrayInit(64, sizeof(SMgmtHandle));
+  if (pArray == NULL) goto _OVER;
+
+  if (dmSetMgmtHandle(pArray, TDMT_MON_MM_INFO, mmPutNodeMsgToMonitorQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MON_MM_LOAD, mmPutNodeMsgToMonitorQueue, 0) == NULL) goto _OVER;
 
   // Requests handled by DNODE
-  dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_MNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_ALTER_MNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_DROP_MNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_QNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_DROP_QNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_SNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_DROP_SNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_BNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_DROP_BNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_DROP_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_CONFIG_DNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_MNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_ALTER_MNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_MNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_QNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_QNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_SNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_SNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_BNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_BNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_VNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_VNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_CONFIG_DNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
 
   // Requests handled by MNODE
-  dmSetMsgHandle(pWrapper, TDMT_MND_CONNECT, mmProcessReadMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_ACCT, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_ALTER_ACCT, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_ACCT, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_USER, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_ALTER_USER, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_USER, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_GET_USER_AUTH, mmProcessReadMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_DNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CONFIG_DNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_DNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_MNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_MNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_QNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_QNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_QNODE_LIST, mmProcessReadMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_SNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_SNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_BNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_BNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_USE_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_ALTER_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_COMPACT_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_FUNC, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_RETRIEVE_FUNC, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_FUNC, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_STB, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_ALTER_STB, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_STB, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_SMA, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_SMA, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_TABLE_META, mmProcessReadMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_VGROUP_LIST, mmProcessReadMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_KILL_QUERY, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_KILL_CONN, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_HEARTBEAT, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_SYSTABLE_RETRIEVE, mmProcessReadMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_STATUS, mmProcessReadMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_KILL_TRANS, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_GRANT, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_AUTH, mmProcessReadMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_ALTER_MNODE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_TOPIC, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_ALTER_TOPIC, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_DROP_TOPIC, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_SUBSCRIBE, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_MQ_COMMIT_OFFSET, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_MQ_ASK_EP, mmProcessReadMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_VG_CHANGE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_STREAM, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_DEPLOY_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_GET_DB_CFG, mmProcessReadMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_GET_INDEX, mmProcessReadMsg, DEFAULT_HANDLE);
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CONNECT, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_ACCT, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_ALTER_ACCT, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_ACCT, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_USER, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_ALTER_USER, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_USER, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_GET_USER_AUTH, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_DNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CONFIG_DNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_DNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_MNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_MNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_QNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_QNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_QNODE_LIST, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_SNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_SNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_BNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_BNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_DB, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_DB, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_USE_DB, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_ALTER_DB, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_COMPACT_DB, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_FUNC, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_RETRIEVE_FUNC, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_FUNC, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_STB, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_ALTER_STB, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_STB, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_SMA, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_SMA, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_TABLE_META, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_VGROUP_LIST, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_KILL_QUERY, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_KILL_CONN, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_HEARTBEAT, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_SYSTABLE_RETRIEVE, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_STATUS, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_KILL_TRANS, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_GRANT, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_AUTH, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_DND_ALTER_MNODE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_TOPIC, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_ALTER_TOPIC, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_DROP_TOPIC, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_SUBSCRIBE, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_MQ_COMMIT_OFFSET, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_MQ_ASK_EP, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_MQ_VG_CHANGE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_CREATE_STREAM, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_DEPLOY_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_GET_DB_CFG, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_MND_GET_INDEX, mmPutNodeMsgToReadQueue, 0) == NULL) goto _OVER;
 
   // Requests handled by VNODE
-  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_STB_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_STB_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_STB_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_SMA_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_SMA_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY, mmProcessQueryMsg, MNODE_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, mmProcessQueryMsg, MNODE_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH, mmProcessQueryMsg, MNODE_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, mmProcessQueryMsg, MNODE_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, mmProcessQueryMsg, MNODE_HANDLE);
-
-  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_SYNC_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_COMPACT_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  if (dmSetMgmtHandle(pArray, TDMT_VND_CREATE_STB_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_STB_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_DROP_STB_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_CREATE_SMA_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_DROP_SMA_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+
+  if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY, mmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY_CONTINUE, mmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_FETCH, mmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_DROP_TASK, mmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY_HEARTBEAT, mmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
+
+  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_VNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_SYNC_VNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_COMPACT_VNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+
+  code = 0;
+
+_OVER:
+  if (code != 0) {
+    taosArrayDestroy(pArray);
+    return NULL;
+  } else {
+    return pArray;
+  }
 }

source/dnode/mgmt/mgmt_mnode/src/mmInt.c

@@ -17,45 +17,35 @@
 #include "mmInt.h"
 #include "wal.h"
 
-static bool mmDeployRequired(SDnode *pDnode) {
-  if (pDnode->data.dnodeId > 0) return false;
-  if (pDnode->data.clusterId > 0) return false;
-  if (strcmp(pDnode->data.localEp, pDnode->data.firstEp) != 0) return false;
+static bool mmDeployRequired(const SMgmtInputOpt *pInput) {
+  if (pInput->dnodeId > 0) return false;
+  if (pInput->clusterId > 0) return false;
+  if (strcmp(pInput->localEp, pInput->firstEp) != 0) return false;
   return true;
 }
 
-static int32_t mmRequire(SMgmtWrapper *pWrapper, bool *required) {
+static int32_t mmRequire(const SMgmtInputOpt *pInput, bool *required) {
   SMnodeMgmt mgmt = {0};
-  mgmt.path = pWrapper->path;
+  mgmt.path = pInput->path;
   if (mmReadFile(&mgmt, required) != 0) {
     return -1;
   }
 
   if (!(*required)) {
-    *required = mmDeployRequired(pWrapper->pDnode);
+    *required = mmDeployRequired(pInput);
   }
 
   return 0;
 }
 
-static void mmInitOption(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {
-  SMsgCb msgCb = pMgmt->pDnode->data.msgCb;
-  msgCb.pWrapper = pMgmt->pWrapper;
-  msgCb.queueFps[QUERY_QUEUE] = mmPutMsgToQueryQueue;
-  msgCb.queueFps[READ_QUEUE] = mmPutMsgToReadQueue;
-  msgCb.queueFps[WRITE_QUEUE] = mmPutMsgToWriteQueue;
-  msgCb.queueFps[SYNC_QUEUE] = mmPutMsgToWriteQueue;
-  pOption->msgCb = msgCb;
-}
-
-static void mmBuildOptionForDeploy(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {
-  mmInitOption(pMgmt, pOption);
+static void mmBuildOptionForDeploy(SMnodeMgmt *pMgmt, const SMgmtInputOpt *pInput, SMnodeOpt *pOption) {
+  pOption->msgCb = pMgmt->msgCb;
   pOption->replica = 1;
   pOption->selfIndex = 0;
   SReplica *pReplica = &pOption->replicas[0];
   pReplica->id = 1;
-  pReplica->port = pMgmt->pDnode->data.serverPort;
-  tstrncpy(pReplica->fqdn, pMgmt->pDnode->data.localFqdn, TSDB_FQDN_LEN);
+  pReplica->port = pInput->serverPort;
+  tstrncpy(pReplica->fqdn, pInput->localFqdn, TSDB_FQDN_LEN);
   pOption->deploy = true;
 
   pMgmt->selfIndex = pOption->selfIndex;
@@ -64,7 +54,7 @@ static void mmBuildOptionForDeploy(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {
 }
 
 static void mmBuildOptionForOpen(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {
-  mmInitOption(pMgmt, pOption);
+  pOption->msgCb = pMgmt->msgCb;
   pOption->selfIndex = pMgmt->selfIndex;
   pOption->replica = pMgmt->replica;
   memcpy(&pOption->replicas, pMgmt->replicas, sizeof(SReplica) * TSDB_MAX_REPLICA);
@@ -72,8 +62,7 @@ static void mmBuildOptionForOpen(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {
 }
 
 static int32_t mmBuildOptionFromReq(SMnodeMgmt *pMgmt, SMnodeOpt *pOption, SDCreateMnodeReq *pCreate) {
-  mmInitOption(pMgmt, pOption);
-
+  pOption->msgCb = pMgmt->msgCb;
   pOption->replica = pCreate->replica;
   pOption->selfIndex = -1;
   for (int32_t i = 0; i < pCreate->replica; ++i) {
@@ -81,7 +70,7 @@ static int32_t mmBuildOptionFromReq(SMnodeMgmt *pMgmt, SMnodeOpt *pOption, SDCre
     pReplica->id = pCreate->replicas[i].id;
     pReplica->port = pCreate->replicas[i].port;
     memcpy(pReplica->fqdn, pCreate->replicas[i].fqdn, TSDB_FQDN_LEN);
-    if (pReplica->id == pMgmt->pDnode->data.dnodeId) {
+    if (pReplica->id == pMgmt->dnodeId) {
       pOption->selfIndex = i;
     }
   }
@@ -109,7 +98,7 @@ int32_t mmAlter(SMnodeMgmt *pMgmt, SDAlterMnodeReq *pReq) {
   }
 
   bool deployed = true;
-  if (mmWriteFile(pMgmt->pWrapper, pReq, deployed) != 0) {
+  if (mmWriteFile(pMgmt, pReq, deployed) != 0) {
     dError("failed to write mnode file since %s", terrstr());
     return -1;
   }
@@ -117,10 +106,7 @@ int32_t mmAlter(SMnodeMgmt *pMgmt, SDAlterMnodeReq *pReq) {
   return 0;
 }
 
-static void mmClose(SMgmtWrapper *pWrapper) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
-  if (pMgmt == NULL) return;
-
+static void mmClose(SMnodeMgmt *pMgmt) {
   dInfo("mnode-mgmt start to cleanup");
   if (pMgmt->pMnode != NULL) {
     mmStopWorker(pMgmt);
@@ -128,12 +114,11 @@ static void mmClose(SMgmtWrapper *pWrapper) {
     pMgmt->pMnode = NULL;
   }
 
-  pWrapper->pMgmt = NULL;
   taosMemoryFree(pMgmt);
   dInfo("mnode-mgmt is cleaned up");
 }
 
-static int32_t mmOpen(SMgmtWrapper *pWrapper) {
+static int32_t mmOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
   dInfo("mnode-mgmt start to init");
   if (walInit() != 0) {
     dError("failed to init wal since %s", terrstr());
@@ -146,23 +131,28 @@ static int32_t mmOpen(SMgmtWrapper *pWrapper) {
     return -1;
   }
 
-  pMgmt->path = pWrapper->path;
-  pMgmt->pDnode = pWrapper->pDnode;
-  pMgmt->pWrapper = pWrapper;
-  pWrapper->pMgmt = pMgmt;
+  pMgmt->path = pInput->path;
+  pMgmt->name = pInput->name;
+  pMgmt->dnodeId = pInput->dnodeId;
+  pMgmt->msgCb = pInput->msgCb;
+  pMgmt->msgCb.queueFps[QUERY_QUEUE] = (PutToQueueFp)mmPutRpcMsgToQueryQueue;
+  pMgmt->msgCb.queueFps[READ_QUEUE] = (PutToQueueFp)mmPutRpcMsgToReadQueue;
+  pMgmt->msgCb.queueFps[WRITE_QUEUE] = (PutToQueueFp)mmPutRpcMsgToWriteQueue;
+  pMgmt->msgCb.queueFps[SYNC_QUEUE] = (PutToQueueFp)mmPutRpcMsgToWriteQueue;
+  pMgmt->msgCb.pMgmt = pMgmt;
 
   bool deployed = false;
   if (mmReadFile(pMgmt, &deployed) != 0) {
     dError("failed to read file since %s", terrstr());
-    mmClose(pWrapper);
+    mmClose(pMgmt);
     return -1;
   }
 
   SMnodeOpt option = {0};
   if (!deployed) {
     dInfo("mnode start to deploy");
-    pWrapper->pDnode->data.dnodeId = 1;
-    mmBuildOptionForDeploy(pMgmt, &option);
+    pMgmt->dnodeId = 1;
+    mmBuildOptionForDeploy(pMgmt, pInput, &option);
   } else {
     dInfo("mnode start to open");
     mmBuildOptionForOpen(pMgmt, &option);
@@ -171,55 +161,52 @@ static int32_t mmOpen(SMgmtWrapper *pWrapper) {
   pMgmt->pMnode = mndOpen(pMgmt->path, &option);
   if (pMgmt->pMnode == NULL) {
     dError("failed to open mnode since %s", terrstr());
-    mmClose(pWrapper);
+    mmClose(pMgmt);
     return -1;
   }
-  dmReportStartup(pWrapper->pDnode, "mnode-impl", "initialized");
+  tmsgReportStartup("mnode-impl", "initialized");
 
   if (mmStartWorker(pMgmt) != 0) {
     dError("failed to start mnode worker since %s", terrstr());
-    mmClose(pWrapper);
+    mmClose(pMgmt);
     return -1;
   }
-  dmReportStartup(pWrapper->pDnode, "mnode-worker", "initialized");
+  tmsgReportStartup("mnode-worker", "initialized");
 
   if (!deployed) {
     deployed = true;
-    if (mmWriteFile(pWrapper, NULL, deployed) != 0) {
+    if (mmWriteFile(pMgmt, NULL, deployed) != 0) {
       dError("failed to write mnode file since %s", terrstr());
       return -1;
     }
   }
 
+  pOutput->dnodeId = pMgmt->dnodeId;
+  pOutput->pMgmt = pMgmt;
   dInfo("mnode-mgmt is initialized");
   return 0;
 }
 
-static int32_t mmStart(SMgmtWrapper *pWrapper) {
+static int32_t mmStart(SMnodeMgmt *pMgmt) {
   dDebug("mnode-mgmt start to run");
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
   return mndStart(pMgmt->pMnode);
 }
 
-static void mmStop(SMgmtWrapper *pWrapper) {
+static void mmStop(SMnodeMgmt *pMgmt) {
   dDebug("mnode-mgmt start to stop");
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
-  if (pMgmt != NULL) {
   mndStop(pMgmt->pMnode);
-  }
 }
 
-void mmSetMgmtFp(SMgmtWrapper *pWrapper) {
-  SMgmtFp mgmtFp = {0};
-  mgmtFp.openFp = mmOpen;
-  mgmtFp.closeFp = mmClose;
-  mgmtFp.startFp = mmStart;
-  mgmtFp.stopFp = mmStop;
-  mgmtFp.createFp = mmProcessCreateReq;
-  mgmtFp.dropFp = mmProcessDropReq;
-  mgmtFp.requiredFp = mmRequire;
-
-  mmInitMsgHandle(pWrapper);
-  pWrapper->name = "mnode";
-  pWrapper->fp = mgmtFp;
+SMgmtFunc mmGetMgmtFunc() {
+  SMgmtFunc mgmtFunc = {0};
+  mgmtFunc.openFp = mmOpen;
+  mgmtFunc.closeFp = (NodeCloseFp)mmClose;
+  mgmtFunc.startFp = (NodeStartFp)mmStart;
+  mgmtFunc.stopFp = (NodeStopFp)mmStop;
+  mgmtFunc.createFp = (NodeCreateFp)mmProcessCreateReq;
+  mgmtFunc.dropFp = (NodeDropFp)mmProcessDropReq;
+  mgmtFunc.requiredFp = mmRequire;
+  mgmtFunc.getHandlesFp = mmGetMsgHandles;
+
+  return mgmtFunc;
 }

source/dnode/mgmt/mgmt_mnode/src/mmWorker.c

@@ -30,27 +30,27 @@ static inline void mmSendRsp(SNodeMsg *pMsg, int32_t code) {
 
 static void mmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   SMnodeMgmt *pMgmt = pInfo->ahandle;
-
   int32_t     code = -1;
   tmsg_t      msgType = pMsg->rpcMsg.msgType;
-  dTrace("msg:%p, get from mnode queue", pMsg);
+  bool        isRequest = msgType & 1U;
+  dTrace("msg:%p, get from mnode queue, type:%s", pMsg, TMSG_INFO(msgType));
 
   switch (msgType) {
     case TDMT_DND_ALTER_MNODE:
       code = mmProcessAlterReq(pMgmt, pMsg);
       break;
     case TDMT_MON_MM_INFO:
-      code = mmProcessGetMonMmInfoReq(pMgmt->pWrapper, pMsg);
+      code = mmProcessGetMonitorInfoReq(pMgmt, pMsg);
       break;
     case TDMT_MON_MM_LOAD:
-      code = mmProcessGetMnodeLoadsReq(pMgmt->pWrapper, pMsg);
+      code = mmProcessGetLoadsReq(pMgmt, pMsg);
       break;
     default:
       pMsg->pNode = pMgmt->pMnode;
       code = mndProcessMsg(pMsg);
   }
 
-  if (msgType & 1U) {
+  if (isRequest) {
     if (pMsg->rpcMsg.handle != NULL && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
       if (code != 0 && terrno != 0) code = terrno;
       mmSendRsp(pMsg, code);
@@ -64,62 +64,46 @@ static void mmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
 
 static void mmProcessQueryQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   SMnodeMgmt *pMgmt = pInfo->ahandle;
-
-  dTrace("msg:%p, get from mnode-query queue", pMsg);
-  SRpcMsg *pRpc = &pMsg->rpcMsg;
   int32_t     code = -1;
+  tmsg_t      msgType = pMsg->rpcMsg.msgType;
+  bool        isRequest = msgType & 1U;
+  dTrace("msg:%p, get from mnode-query queue", pMsg);
 
   pMsg->pNode = pMgmt->pMnode;
   code = mndProcessMsg(pMsg);
 
-  if (pRpc->msgType & 1U) {
-    if (pRpc->handle != NULL && code != 0) {
-      dError("msg:%p, failed to process since %s", pMsg, terrstr());
+  if (isRequest) {
+    if (pMsg->rpcMsg.handle != NULL && code != 0) {
+      if (code != 0 && terrno != 0) code = terrno;
       mmSendRsp(pMsg, code);
     }
   }
 
   dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-  rpcFreeCont(pRpc->pCont);
+  rpcFreeCont(pMsg->rpcMsg.pCont);
   taosFreeQitem(pMsg);
 }
 
-static void mmPutNodeMsgToWorker(SSingleWorker *pWorker, SNodeMsg *pMsg) {
-  dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
+static int32_t mmPutNodeMsgToWorker(SSingleWorker *pWorker, SNodeMsg *pMsg) {
+  dTrace("msg:%p, put into worker %s, type:%s", pMsg, pWorker->name, TMSG_INFO(pMsg->rpcMsg.msgType));
   taosWriteQitem(pWorker->queue, pMsg);
-}
-
-int32_t mmProcessWriteMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
-  mmPutNodeMsgToWorker(&pMgmt->writeWorker, pMsg);
   return 0;
 }
 
-int32_t mmProcessSyncMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
-  mmPutNodeMsgToWorker(&pMgmt->syncWorker, pMsg);
-  return 0;
-}
+int32_t mmPutNodeMsgToWriteQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->writeWorker, pMsg); }
 
-int32_t mmProcessReadMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
-  mmPutNodeMsgToWorker(&pMgmt->readWorker, pMsg);
-  return 0;
-}
+int32_t mmPutNodeMsgToSyncQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->syncWorker, pMsg); }
 
-int32_t mmProcessQueryMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
-  mmPutNodeMsgToWorker(&pMgmt->queryWorker, pMsg);
-  return 0;
+int32_t mmPutNodeMsgToReadQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->readWorker, pMsg); }
+
+int32_t mmPutNodeMsgToQueryQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) { return mmPutNodeMsgToWorker(&pMgmt->queryWorker, pMsg);
 }
 
-int32_t mmProcessMonitorMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
-  mmPutNodeMsgToWorker(&pMgmt->monitorWorker, pMsg);
-  return 0;
+int32_t mmPutNodeMsgToMonitorQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  return mmPutNodeMsgToWorker(&pMgmt->monitorWorker, pMsg);
 }
 
-static int32_t mmPutRpcMsgToWorker(SSingleWorker *pWorker, SRpcMsg *pRpc) {
+static inline int32_t mmPutRpcMsgToWorker(SSingleWorker *pWorker, SRpcMsg *pRpc) {
   SNodeMsg *pMsg = taosAllocateQitem(sizeof(SNodeMsg));
   if (pMsg == NULL) return -1;
 
@@ -129,25 +113,19 @@ static int32_t mmPutRpcMsgToWorker(SSingleWorker *pWorker, SRpcMsg *pRpc) {
   return 0;
 }
 
-int32_t mmPutMsgToQueryQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
+int32_t mmPutRpcMsgToQueryQueue(SMnodeMgmt *pMgmt, SRpcMsg *pRpc) {
   return mmPutRpcMsgToWorker(&pMgmt->queryWorker, pRpc);
 }
 
-int32_t mmPutMsgToWriteQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
+int32_t mmPutRpcMsgToWriteQueue(SMnodeMgmt *pMgmt, SRpcMsg *pRpc) {
   return mmPutRpcMsgToWorker(&pMgmt->writeWorker, pRpc);
 }
 
-int32_t mmPutMsgToReadQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
+int32_t mmPutRpcMsgToReadQueue(SMnodeMgmt *pMgmt, SRpcMsg *pRpc) {
   return mmPutRpcMsgToWorker(&pMgmt->readWorker, pRpc);
 }
 
-int32_t mmPutMsgToSyncQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
-  return mmPutRpcMsgToWorker(&pMgmt->syncWorker, pRpc);
-}
+int32_t mmPutMsgToSyncQueue(SMnodeMgmt *pMgmt, SRpcMsg *pRpc) { return mmPutRpcMsgToWorker(&pMgmt->syncWorker, pRpc); }
 
 int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
   SSingleWorkerCfg qCfg = {
@@ -198,7 +176,6 @@ int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
     return -1;
   }
 
-  if (tsMultiProcess) {
   SSingleWorkerCfg mCfg = {
       .min = 1,
       .max = 1,
@@ -210,7 +187,6 @@ int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
     dError("failed to start mnode mnode-monitor worker since %s", terrstr());
     return -1;
   }
-  }
 
   dDebug("mnode workers are initialized");
   return 0;

source/dnode/mgmt/mgmt_qnode/CMakeLists.txt

@@ -5,5 +5,5 @@ target_include_directories(
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    mgmt_qnode dnode_interface
+    mgmt_qnode node_util
 )
\ No newline at end of file

source/dnode/mgmt/mgmt_qnode/inc/qmInt.h

@@ -16,7 +16,7 @@
 #ifndef _TD_DND_QNODE_INT_H_
 #define _TD_DND_QNODE_INT_H_
 
-#include "dmInt.h"
+#include "dmUtil.h"
 
 #include "qnode.h"
 
@@ -26,30 +26,31 @@ extern "C" {
 
 typedef struct SQnodeMgmt {
   SQnode       *pQnode;
-  SDnode       *pDnode;
-  SMgmtWrapper *pWrapper;
+  SMsgCb        msgCb;
   const char   *path;
+  const char   *name;
+  int32_t       dnodeId;
   SSingleWorker queryWorker;
   SSingleWorker fetchWorker;
   SSingleWorker monitorWorker;
 } SQnodeMgmt;
 
 // qmHandle.c
-void    qmInitMsgHandle(SMgmtWrapper *pWrapper);
-int32_t qmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t qmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t qmProcessGetMonQmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq);
+SArray *qmGetMsgHandles();
+int32_t qmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg);
+int32_t qmProcessDropReq(SQnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t qmProcessGetMonitorInfoReq(SQnodeMgmt *pMgmt, SNodeMsg *pReq);
 
 // qmWorker.c
-int32_t qmPutMsgToQueryQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
-int32_t qmPutMsgToFetchQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
-int32_t qmGetQueueSize(SMgmtWrapper *pWrapper, int32_t vgId, EQueueType qtype);
+int32_t qmPutRpcMsgToQueryQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg);
+int32_t qmPutRpcMsgToFetchQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg);
+int32_t qmGetQueueSize(SQnodeMgmt *pMgmt, int32_t vgId, EQueueType qtype);
 
 int32_t qmStartWorker(SQnodeMgmt *pMgmt);
 void    qmStopWorker(SQnodeMgmt *pMgmt);
-int32_t qmProcessQueryMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t qmProcessFetchMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t qmProcessMonitorMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
+int32_t qmPutNodeMsgToQueryQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t qmPutNodeMsgToFetchQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t qmPutNodeMsgToMonitorQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/mgmt_qnode/src/qmHandle.c

@@ -16,12 +16,12 @@
 #define _DEFAULT_SOURCE
 #include "qmInt.h"
 
-void qmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonQmInfo *qmInfo) {}
+static void qmGetMonitorInfo(SQnodeMgmt *pMgmt, SMonQmInfo *qmInfo) {}
 
-int32_t qmProcessGetMonQmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
+int32_t qmProcessGetMonitorInfoReq(SQnodeMgmt *pMgmt, SNodeMsg *pReq) {
   SMonQmInfo qmInfo = {0};
-  qmGetMonitorInfo(pWrapper, &qmInfo);
-  dmGetMonitorSysInfo(&qmInfo.sys);
+  qmGetMonitorInfo(pMgmt, &qmInfo);
+  dmGetMonitorSystemInfo(&qmInfo.sys);
   monGetLogs(&qmInfo.log);
 
   int32_t rspLen = tSerializeSMonQmInfo(NULL, 0, &qmInfo);
@@ -43,8 +43,7 @@ int32_t qmProcessGetMonQmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
   return 0;
 }
 
-int32_t qmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SDnode  *pDnode = pWrapper->pDnode;
+int32_t qmProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg) {
   SRpcMsg *pReq = &pMsg->rpcMsg;
 
   SDCreateQnodeReq createReq = {0};
@@ -53,14 +52,14 @@ int32_t qmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (createReq.dnodeId != pDnode->data.dnodeId) {
+  if (pInput->dnodeId != 0 && createReq.dnodeId != pInput->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to create qnode since %s", terrstr());
     return -1;
   }
 
   bool deployed = true;
-  if (dmWriteFile(pWrapper, deployed) != 0) {
+  if (dmWriteFile(pInput->path, pInput->name, deployed) != 0) {
     dError("failed to write qnode file since %s", terrstr());
     return -1;
   }
@@ -68,8 +67,7 @@ int32_t qmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t qmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SDnode  *pDnode = pWrapper->pDnode;
+int32_t qmProcessDropReq(SQnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   SRpcMsg *pReq = &pMsg->rpcMsg;
 
   SDDropQnodeReq dropReq = {0};
@@ -78,14 +76,14 @@ int32_t qmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (dropReq.dnodeId != pDnode->data.dnodeId) {
+  if (pMgmt->dnodeId != 0 && dropReq.dnodeId != pMgmt->dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to drop qnode since %s", terrstr());
     return -1;
   }
 
   bool deployed = false;
-  if (dmWriteFile(pWrapper, deployed) != 0) {
+  if (dmWriteFile(pMgmt->path, pMgmt->name, deployed) != 0) {
     dError("failed to write qnode file since %s", terrstr());
     return -1;
   }
@@ -93,18 +91,31 @@ int32_t qmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
   return 0;
 }
 
-void qmInitMsgHandle(SMgmtWrapper *pWrapper) {
-  dmSetMsgHandle(pWrapper, TDMT_MON_QM_INFO, qmProcessMonitorMsg, DEFAULT_HANDLE);
+SArray *qmGetMsgHandles() {
+  int32_t code = -1;
+  SArray *pArray = taosArrayInit(16, sizeof(SMgmtHandle));
+  if (pArray == NULL) goto _OVER;
+
+  if (dmSetMgmtHandle(pArray, TDMT_MON_QM_INFO, qmPutNodeMsgToMonitorQueue, 0) == NULL) goto _OVER;
 
   // Requests handled by VNODE
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY, qmProcessQueryMsg, QNODE_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, qmProcessQueryMsg, QNODE_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH, qmProcessFetchMsg, QNODE_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, qmProcessFetchMsg, QNODE_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, qmProcessFetchMsg, QNODE_HANDLE);
-
-  dmSetMsgHandle(pWrapper, TDMT_VND_RES_READY, qmProcessFetchMsg, QNODE_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASKS_STATUS, qmProcessFetchMsg, QNODE_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CANCEL_TASK, qmProcessFetchMsg, QNODE_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, qmProcessFetchMsg, QNODE_HANDLE);
+  if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY, qmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY_CONTINUE, qmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_FETCH, qmPutNodeMsgToFetchQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_FETCH_RSP, qmPutNodeMsgToFetchQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY_HEARTBEAT, qmPutNodeMsgToFetchQueue, 1) == NULL) goto _OVER;
+
+  if (dmSetMgmtHandle(pArray, TDMT_VND_RES_READY, qmPutNodeMsgToFetchQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_TASKS_STATUS, qmPutNodeMsgToFetchQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_CANCEL_TASK, qmPutNodeMsgToFetchQueue, 1) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_DROP_TASK, qmPutNodeMsgToFetchQueue, 1) == NULL) goto _OVER;
+
+  code = 0;
+_OVER:
+  if (code != 0) {
+    taosArrayDestroy(pArray);
+    return NULL;
+  } else {
+    return pArray;
+  }
 }

source/dnode/mgmt/mgmt_qnode/src/qmInt.c

@@ -16,21 +16,13 @@
 #define _DEFAULT_SOURCE
 #include "qmInt.h"
 
-static int32_t qmRequire(SMgmtWrapper *pWrapper, bool *required) { return dmReadFile(pWrapper, required); }
-
-static void qmInitOption(SQnodeMgmt *pMgmt, SQnodeOpt *pOption) {
-  SMsgCb msgCb = pMgmt->pDnode->data.msgCb;
-  msgCb.pWrapper = pMgmt->pWrapper;
-  msgCb.queueFps[QUERY_QUEUE] = qmPutMsgToQueryQueue;
-  msgCb.queueFps[FETCH_QUEUE] = qmPutMsgToFetchQueue;
-  msgCb.qsizeFp = qmGetQueueSize;
-  pOption->msgCb = msgCb;
+static int32_t qmRequire(const SMgmtInputOpt *pInput, bool *required) {
+  return dmReadFile(pInput->path, pInput->name, required);
 }
 
-static void qmClose(SMgmtWrapper *pWrapper) {
-  SQnodeMgmt *pMgmt = pWrapper->pMgmt;
-  if (pMgmt == NULL) return;
+static void qmInitOption(SQnodeMgmt *pMgmt, SQnodeOpt *pOption) { pOption->msgCb = pMgmt->msgCb; }
 
+static void qmClose(SQnodeMgmt *pMgmt) {
   dInfo("qnode-mgmt start to cleanup");
   if (pMgmt->pQnode != NULL) {
     qmStopWorker(pMgmt);
@@ -38,12 +30,11 @@ static void qmClose(SMgmtWrapper *pWrapper) {
     pMgmt->pQnode = NULL;
   }
 
-  pWrapper->pMgmt = NULL;
   taosMemoryFree(pMgmt);
   dInfo("qnode-mgmt is cleaned up");
 }
 
-static int32_t qmOpen(SMgmtWrapper *pWrapper) {
+static int32_t qmOpen(const SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
   dInfo("qnode-mgmt start to init");
   SQnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SQnodeMgmt));
   if (pMgmt == NULL) {
@@ -51,41 +42,51 @@ static int32_t qmOpen(SMgmtWrapper *pWrapper) {
     return -1;
   }
 
-  pMgmt->path = pWrapper->path;
-  pMgmt->pDnode = pWrapper->pDnode;
-  pMgmt->pWrapper = pWrapper;
-  pWrapper->pMgmt = pMgmt;
+  pMgmt->path = pInput->path;
+  pMgmt->name = pInput->name;
+  pMgmt->dnodeId = pInput->dnodeId;
+  pMgmt->msgCb = pInput->msgCb;
+  pMgmt->msgCb.queueFps[QUERY_QUEUE] = (PutToQueueFp)qmPutRpcMsgToQueryQueue;
+  pMgmt->msgCb.queueFps[FETCH_QUEUE] = (PutToQueueFp)qmPutRpcMsgToFetchQueue;
+  pMgmt->msgCb.qsizeFp = (GetQueueSizeFp)qmGetQueueSize;
+  pMgmt->msgCb.pMgmt = pMgmt;
 
   SQnodeOpt option = {0};
   qmInitOption(pMgmt, &option);
   pMgmt->pQnode = qndOpen(&option);
   if (pMgmt->pQnode == NULL) {
     dError("failed to open qnode since %s", terrstr());
-    qmClose(pWrapper);
+    qmClose(pMgmt);
+    return -1;
+  }
+  tmsgReportStartup("qnode-impl", "initialized");
+
+  if (udfcOpen() != 0) {
+    dError("qnode can not open udfc");
+    qmClose(pMgmt);
     return -1;
   }
-  dmReportStartup(pWrapper->pDnode, "qnode-impl", "initialized");
 
   if (qmStartWorker(pMgmt) != 0) {
     dError("failed to start qnode worker since %s", terrstr());
-    qmClose(pWrapper);
+    qmClose(pMgmt);
     return -1;
   }
-  dmReportStartup(pWrapper->pDnode, "qnode-worker", "initialized");
+  tmsgReportStartup("qnode-worker", "initialized");
 
+  pOutput->pMgmt = pMgmt;
   dInfo("qnode-mgmt is initialized");
   return 0;
 }
 
-void qmSetMgmtFp(SMgmtWrapper *pWrapper) {
-  SMgmtFp mgmtFp = {0};
-  mgmtFp.openFp = qmOpen;
-  mgmtFp.closeFp = qmClose;
-  mgmtFp.createFp = qmProcessCreateReq;
-  mgmtFp.dropFp = qmProcessDropReq;
-  mgmtFp.requiredFp = qmRequire;
+SMgmtFunc qmGetMgmtFunc() {
+  SMgmtFunc mgmtFunc = {0};
+  mgmtFunc.openFp = qmOpen;
+  mgmtFunc.closeFp = (NodeCloseFp)qmClose;
+  mgmtFunc.createFp = (NodeCreateFp)qmProcessCreateReq;
+  mgmtFunc.dropFp = (NodeDropFp)qmProcessDropReq;
+  mgmtFunc.requiredFp = qmRequire;
+  mgmtFunc.getHandlesFp = qmGetMsgHandles;
 
-  qmInitMsgHandle(pWrapper);
-  pWrapper->name = "qnode";
-  pWrapper->fp = mgmtFp;
+  return mgmtFunc;
 }

source/dnode/mgmt/mgmt_qnode/src/qmWorker.c

@@ -36,7 +36,7 @@ static void qmProcessMonitorQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   int32_t  code = -1;
 
   if (pMsg->rpcMsg.msgType == TDMT_MON_QM_INFO) {
-    code = qmProcessGetMonQmInfoReq(pMgmt->pWrapper, pMsg);
+    code = qmProcessGetMonitorInfoReq(pMgmt, pMsg);
   } else {
     terrno = TSDB_CODE_MSG_NOT_PROCESSED;
   }
@@ -83,27 +83,22 @@ static void qmProcessFetchQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   taosFreeQitem(pMsg);
 }
 
-static void qmPutMsgToWorker(SSingleWorker *pWorker, SNodeMsg *pMsg) {
+static int32_t qmPutNodeMsgToWorker(SSingleWorker *pWorker, SNodeMsg *pMsg) {
   dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
   taosWriteQitem(pWorker->queue, pMsg);
+  return 0;
 }
 
-int32_t qmProcessQueryMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SQnodeMgmt *pMgmt = pWrapper->pMgmt;
-  qmPutMsgToWorker(&pMgmt->queryWorker, pMsg);
-  return 0;
+int32_t qmPutNodeMsgToQueryQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  return qmPutNodeMsgToWorker(&pMgmt->queryWorker, pMsg);
 }
 
-int32_t qmProcessFetchMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SQnodeMgmt *pMgmt = pWrapper->pMgmt;
-  qmPutMsgToWorker(&pMgmt->fetchWorker, pMsg);
-  return 0;
+int32_t qmPutNodeMsgToFetchQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  return qmPutNodeMsgToWorker(&pMgmt->fetchWorker, pMsg);
 }
 
-int32_t qmProcessMonitorMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SQnodeMgmt *pMgmt = pWrapper->pMgmt;
-  qmPutMsgToWorker(&pMgmt->monitorWorker, pMsg);
-  return 0;
+int32_t qmPutNodeMsgToMonitorQueue(SQnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  return qmPutNodeMsgToWorker(&pMgmt->monitorWorker, pMsg);
 }
 
 static int32_t qmPutRpcMsgToWorker(SQnodeMgmt *pMgmt, SSingleWorker *pWorker, SRpcMsg *pRpc) {
@@ -118,19 +113,16 @@ static int32_t qmPutRpcMsgToWorker(SQnodeMgmt *pMgmt, SSingleWorker *pWorker, SR
   return 0;
 }
 
-int32_t qmPutMsgToQueryQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
-  SQnodeMgmt *pMgmt = pWrapper->pMgmt;
+int32_t qmPutRpcMsgToQueryQueue(SQnodeMgmt *pMgmt, SRpcMsg *pRpc) {
   return qmPutRpcMsgToWorker(pMgmt, &pMgmt->queryWorker, pRpc);
 }
 
-int32_t qmPutMsgToFetchQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
-  SQnodeMgmt *pMgmt = pWrapper->pMgmt;
+int32_t qmPutRpcMsgToFetchQueue(SQnodeMgmt *pMgmt, SRpcMsg *pRpc) {
   return qmPutRpcMsgToWorker(pMgmt, &pMgmt->fetchWorker, pRpc);
 }
 
-int32_t qmGetQueueSize(SMgmtWrapper *pWrapper, int32_t vgId, EQueueType qtype) {
+int32_t qmGetQueueSize(SQnodeMgmt *pMgmt, int32_t vgId, EQueueType qtype) {
   int32_t size = -1;
-  SQnodeMgmt *pMgmt = pWrapper->pMgmt;
 
   switch (qtype) {
     case QUERY_QUEUE:
@@ -173,7 +165,6 @@ int32_t qmStartWorker(SQnodeMgmt *pMgmt) {
     return -1;
   }
 
-  if (tsMultiProcess) {
   SSingleWorkerCfg mCfg = {
       .min = 1,
       .max = 1,
@@ -185,7 +176,6 @@ int32_t qmStartWorker(SQnodeMgmt *pMgmt) {
     dError("failed to start qnode-monitor worker since %s", terrstr());
     return -1;
   }
-  }
 
   dDebug("qnode workers are initialized");
   return 0;

source/dnode/mgmt/mgmt_snode/CMakeLists.txt

@@ -5,5 +5,5 @@ target_include_directories(
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    mgmt_snode dnode_interface
+    mgmt_snode node_util
 )
\ No newline at end of file

source/dnode/mgmt/mgmt_snode/inc/smInt.h

@@ -16,7 +16,7 @@
 #ifndef _TD_DND_SNODE_INT_H_
 #define _TD_DND_SNODE_INT_H_
 
-#include "dmInt.h"
+#include "dmUtil.h"
 
 #include "snode.h"
 
@@ -26,9 +26,10 @@ extern "C" {
 
 typedef struct SSnodeMgmt {
   SSnode       *pSnode;
-  SDnode       *pDnode;
-  SMgmtWrapper *pWrapper;
+  SMsgCb        msgCb;
   const char   *path;
+  const char   *name;
+  int32_t       dnodeId;
   SRWLatch      latch;
   int8_t        uniqueWorkerInUse;
   SArray       *uniqueWorkers;  // SArray<SMultiWorker*>
@@ -37,19 +38,19 @@ typedef struct SSnodeMgmt {
 } SSnodeMgmt;
 
 // smHandle.c
-void    smInitMsgHandle(SMgmtWrapper *pWrapper);
-int32_t smProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t smProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t smProcessGetMonSmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq);
+SArray *smGetMsgHandles();
+int32_t smProcessCreateReq(const SMgmtInputOpt *pInput, SNodeMsg *pMsg);
+int32_t smProcessDropReq(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t smProcessGetMonitorInfoReq(SSnodeMgmt *pMgmt, SNodeMsg *pReq);
 
 // smWorker.c
 int32_t smStartWorker(SSnodeMgmt *pMgmt);
 void    smStopWorker(SSnodeMgmt *pMgmt);
-int32_t smProcessMgmtMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t smProcessUniqueMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t smProcessSharedMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t smProcessExecMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t smProcessMonitorMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
+int32_t smPutNodeMsgToMgmtQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t smPutNodeMsgToUniqueQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t smPutNodeMsgToSharedQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t smPutNodeMsgToExecQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t smPutNodeMsgToMonitorQueue(SSnodeMgmt *pMgmt, SNodeMsg *pMsg);
 
 #ifdef __cplusplus
 }

source/dnode/mgmt/mgmt_vnode/CMakeLists.txt

@@ -5,5 +5,5 @@ target_include_directories(
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    mgmt_vnode dnode_interface
+    mgmt_vnode node_util
 )
\ No newline at end of file

source/dnode/mgmt/mgmt_vnode/src/vmFile.c

@@ -16,7 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "vmInt.h"
 
-SVnodeObj **vmGetVnodeListFromHash(SVnodesMgmt *pMgmt, int32_t *numOfVnodes) {
+SVnodeObj **vmGetVnodeListFromHash(SVnodeMgmt *pMgmt, int32_t *numOfVnodes) {
   taosRLockLatch(&pMgmt->latch);
 
   int32_t     num = 0;
@@ -44,7 +44,7 @@ SVnodeObj **vmGetVnodeListFromHash(SVnodesMgmt *pMgmt, int32_t *numOfVnodes) {
   return pVnodes;
 }
 
-int32_t vmGetVnodeListFromFile(SVnodesMgmt *pMgmt, SWrapperCfg **ppCfgs, int32_t *numOfVnodes) {
+int32_t vmGetVnodeListFromFile(SVnodeMgmt *pMgmt, SWrapperCfg **ppCfgs, int32_t *numOfVnodes) {
   int32_t      code = TSDB_CODE_INVALID_JSON_FORMAT;
   int32_t      len = 0;
   int32_t      maxLen = 1024 * 1024;
@@ -139,9 +139,9 @@ _OVER:
   return code;
 }
 
-int32_t vmWriteVnodeListToFile(SVnodesMgmt *pMgmt) {
-  char file[PATH_MAX];
-  char realfile[PATH_MAX];
+int32_t vmWriteVnodeListToFile(SVnodeMgmt *pMgmt) {
+  char file[PATH_MAX] = {0};
+  char realfile[PATH_MAX] = {0};
   snprintf(file, sizeof(file), "%s%svnodes.json.bak", pMgmt->path, TD_DIRSEP);
   snprintf(realfile, sizeof(file), "%s%svnodes.json", pMgmt->path, TD_DIRSEP);
 

source/dnode/mgmt/implement/CMakeLists.txt → source/dnode/mgmt/node_mgmt/CMakeLists.txt

 aux_source_directory(src IMPLEMENT_SRC)
 add_library(dnode STATIC ${IMPLEMENT_SRC})
 target_link_libraries(
-    dnode mgmt_bnode mgmt_mnode mgmt_qnode mgmt_snode mgmt_vnode
+    dnode mgmt_bnode mgmt_mnode mgmt_qnode mgmt_snode mgmt_vnode mgmt_dnode
 )
 target_include_directories(
     dnode

source/dnode/mgmt/interface/CMakeLists.txt → source/dnode/mgmt/node_util/CMakeLists.txt

-aux_source_directory(src DNODE_INTERFACE)
-add_library(dnode_interface STATIC ${DNODE_INTERFACE})
+aux_source_directory(src NODE_UTIL)
+add_library(node_util STATIC ${NODE_UTIL})
 target_include_directories(
-    dnode_interface
+    node_util
     PUBLIC "${TD_SOURCE_DIR}/include/dnode/mgmt"
     PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    dnode_interface cjson mnode vnode qnode snode bnode wal sync taos_static tfs monitor
+    node_util cjson mnode vnode qnode snode bnode wal sync taos_static tfs monitor
 )
\ No newline at end of file

source/dnode/mgmt/test/CMakeLists.txt

@@ -3,7 +3,7 @@ if(${BUILD_TEST})
     add_subdirectory(qnode)
     add_subdirectory(bnode)
     add_subdirectory(snode)
-    add_subdirectory(mnode)
+    #add_subdirectory(mnode)
     add_subdirectory(vnode)
     add_subdirectory(sut)
 endif(${BUILD_TEST})