Merge branch '3.0' into 3.0_udfd

.devcontainer/Dockerfile

@@ -7,4 +7,4 @@ FROM mcr.microsoft.com/vscode/devcontainers/cpp:0-${VARIANT}
 # [Optional] Uncomment this section to install additional packages.
 # RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
 #     && apt-get -y install --no-install-recommends <your-package-list-here>
-RUN apt-get update && apt-get -y install tree vim
+RUN apt-get update && apt-get -y install tree vim tmux

.devcontainer/devcontainer.json

@@ -32,7 +32,7 @@
 	// Use 'forwardPorts' to make a list of ports inside the container available locally.
 	// "forwardPorts": [],
 	// Use 'postCreateCommand' to run commands after the container is created.
-	// "postCreateCommand": "gcc -v",
+	"postCreateCommand": "wget https://raw.githubusercontent.com/hzcheng/config/master/.tmux.conf -P /root",
 	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
 	"remoteUser": "root"
 }

cmake/cmake.define

@@ -1,5 +1,15 @@
 cmake_minimum_required(VERSION 3.16)
 
+if (NOT DEFINED TD_GRANT)
+  SET(TD_GRANT FALSE)
+endif()
+if (NOT DEFINED TD_USB_DONGLE)
+  SET(TD_USB_DONGLE FALSE)
+endif()
+IF (TD_GRANT)
+  ADD_DEFINITIONS(-D_GRANT)
+ENDIF ()
+
 IF ("${BUILD_TOOLS}" STREQUAL "")
   IF (TD_LINUX)
     IF (TD_ARM_32)
@@ -35,11 +45,15 @@ IF (TD_WINDOWS)
       SET(COMMON_FLAGS "${COMMON_FLAGS} /Wv:18")
     ENDIF ()
 
+ELSE ()
+    IF (${SANITIZER} MATCHES "true")
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}     -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment -static-libasan -g3")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment -static-libasan -g3")
+	MESSAGE(STATUS "Will compile with Address Sanitizer!")
     ELSE ()
         SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -g3")
         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -g3")
-    #SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment -static-libasan -g3")
+    ENDIF ()
-    #SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment -static-libasan -g3")
 
     MESSAGE("System processor ID: ${CMAKE_SYSTEM_PROCESSOR}")
     IF (${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm64" OR ${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")

example/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_executable(tmq "")
 add_executable(tstream "")
+add_executable(demoapi "")
 
 target_sources(tmq
     PRIVATE
@@ -10,6 +11,12 @@ target_sources(tstream
     PRIVATE
     "src/tstream.c"
 )
+
+target_sources(demoapi
+    PRIVATE
+    "src/demoapi.c"
+)
+
 target_link_libraries(tmq
     taos
 )
@@ -18,6 +25,10 @@ target_link_libraries(tstream
     taos
 )
 
+target_link_libraries(demoapi
+    taos
+)
+
 target_include_directories(tmq
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
@@ -26,5 +37,11 @@ target_include_directories(tstream
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 
+target_include_directories(demoapi
+    PUBLIC "${TD_SOURCE_DIR}/include/client"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+
 SET_TARGET_PROPERTIES(tmq PROPERTIES OUTPUT_NAME tmq)
 SET_TARGET_PROPERTIES(tstream PROPERTIES OUTPUT_NAME tstream)
+SET_TARGET_PROPERTIES(demoapi PROPERTIES OUTPUT_NAME demoapi)

example/src/demoapi.c

@@ -0,0 +1,214 @@
+// C api call sequence demo
+// to compile: gcc -o apidemo apidemo.c -ltaos
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <argp.h>
+
+#include "taos.h"
+
+#define debugPrint(fmt, ...) \
+    do { if (g_args.debug_print || g_args.verbose_print) \
+      fprintf(stdout, "DEBG: "fmt, __VA_ARGS__); } while(0)
+
+#define warnPrint(fmt, ...) \
+    do { fprintf(stderr, "\033[33m"); \
+        fprintf(stderr, "WARN: "fmt, __VA_ARGS__); \
+        fprintf(stderr, "\033[0m"); } while(0)
+
+#define errorPrint(fmt, ...) \
+    do { fprintf(stderr, "\033[31m"); \
+        fprintf(stderr, "ERROR: "fmt, __VA_ARGS__); \
+        fprintf(stderr, "\033[0m"); } while(0)
+
+#define okPrint(fmt, ...) \
+    do { fprintf(stderr, "\033[32m"); \
+        fprintf(stderr, "OK: "fmt, __VA_ARGS__); \
+        fprintf(stderr, "\033[0m"); } while(0)
+
+int64_t g_num_of_tb = 2;
+int64_t g_num_of_rec = 2;
+
+static struct argp_option options[] = {
+    {"tables", 't', "NUMBER", 0, "Number of child tables, default is 10000."},
+    {"records", 'n', "NUMBER", 0,
+     "Number of records for each table, default is 10000."},
+    {0}};
+
+static error_t parse_opt(int key, char *arg, struct argp_state *state) {
+    switch (key) {
+        case 't':
+            g_num_of_tb = atoll(arg);
+            break;
+
+        case 'n':
+            g_num_of_rec = atoll(arg);
+            break;
+    }
+
+    return 0;
+}
+
+static struct argp argp = {options, parse_opt, "", ""};
+
+static void prepare_data(TAOS* taos) {
+    TAOS_RES *res;
+    res = taos_query(taos, "drop database if exists test;");
+    taos_free_result(res);
+    usleep(100000);
+
+    res = taos_query(taos, "create database test;");
+    taos_free_result(res);
+    usleep(100000);
+    taos_select_db(taos, "test");
+
+    res = taos_query(taos, "create table meters(ts timestamp, f float, n int, b binary(20), c nchar(20)) tags(area int, city binary(20), dist nchar(20));");
+    taos_free_result(res);
+
+    char command[1024] = {0};
+    for (int64_t i = 0; i < g_num_of_tb; i ++) {
+//        sprintf(command, "create table t%"PRId64" using meters tags(%"PRId64", '%s', '%s');",
+//                i, i, (i%2)?"beijing":"shanghai", (i%2)?"朝阳区":"黄浦区");
+        sprintf(command, "create table t%"PRId64" using meters tags(%"PRId64", '%s', '%s');",
+                i, i, (i%2)?"beijing":"shanghai", (i%2)?"chaoyang":"huangpu");
+        res = taos_query(taos,  command);
+        if ((res) && (0 == taos_errno(res))) {
+            okPrint("t%" PRId64 " created\n", i);
+        } else {
+            errorPrint("%s() LN%d: %s\n",
+                    __func__, __LINE__, taos_errstr(res));
+        }
+        taos_free_result(res);
+
+        int64_t j = 0;
+        int64_t total = 0;
+        int64_t affected;
+        for (; j < g_num_of_rec -1; j ++) {
+            sprintf(command, "insert into t%"PRId64" "
+                    "values(%" PRId64 ", %f, %"PRId64", '%c%d', '%c%d')",
+                    i, 1650000000000+j, (float)j, j, 'a'+(int)j%25, rand(),
+                    'z' - (int)j%25, rand());
+            res = taos_query(taos,  command);
+            if ((res) && (0 == taos_errno(res))) {
+                affected = taos_affected_rows(res);
+                total += affected;
+            } else {
+                errorPrint("%s() LN%d: %s\n",
+                        __func__, __LINE__, taos_errstr(res));
+            }
+            taos_free_result(res);
+        }
+        sprintf(command, "insert into t%"PRId64" values(%" PRId64 ", NULL, NULL, NULL, NULL)",
+                i, 1650000000000+j+1);
+        res = taos_query(taos,  command);
+        if ((res) && (0 == taos_errno(res))) {
+            affected = taos_affected_rows(res);
+            total += affected;
+        } else {
+            errorPrint("%s() LN%d: %s\n",
+                    __func__, __LINE__, taos_errstr(res));
+        }
+        taos_free_result(res);
+
+        printf("insert %"PRId64" records into t%"PRId64", total affected rows: %"PRId64"\n", j, i, total);
+    }
+}
+
+static int print_result(char *tbname, TAOS_RES* res, int block) {
+    int64_t num_rows = 0;
+    TAOS_ROW    row = NULL;
+    int         num_fields = taos_num_fields(res);
+    TAOS_FIELD* fields = taos_fetch_fields(res);
+
+    for (int f = 0; f < num_fields; f++) {
+        printf("fields[%d].name=%s, fields[%d].type=%d, fields[%d].bytes=%d\n",
+                f, fields[f].name, f, fields[f].type, f, fields[f].bytes);
+    }
+    if (block) {
+        warnPrint("%s() LN%d, call taos_fetch_block()\n", __func__, __LINE__);
+        int rows = 0;
+        while ((rows = taos_fetch_block(res, &row))) {
+            num_rows += rows;
+        }
+    } else {
+        warnPrint("%s() LN%d, call taos_fetch_rows()\n", __func__, __LINE__);
+        while ((row = taos_fetch_row(res))) {
+            char temp[256] = {0};
+            taos_print_row(temp, row, fields, num_fields);
+            puts(temp);
+            num_rows ++;
+
+            int* lengths = taos_fetch_lengths(res);
+            if (lengths) {
+                for (int c = 0; c < num_fields; c++) {
+                    printf("length of column %d is %d\n", c, lengths[c]);
+                }
+            } else {
+                errorPrint("%s() LN%d: %s's lengths is NULL\n",
+                        __func__, __LINE__, tbname);
+            }
+        }
+    }
+
+    return num_rows;
+}
+
+static void verify_query(TAOS* taos) {
+    // TODO: select count(tbname) from stable once stable query work
+    //
+    char tbname[193] = {0};
+    char command[1024] = {0};
+
+    for (int64_t i = 0; i < g_num_of_tb; i++) {
+        sprintf(tbname, "t%"PRId64"", i);
+        sprintf(command, "select * from %s", tbname);
+        TAOS_RES* res = taos_query(taos, command);
+
+        if (res) {
+            if (0 == taos_errno(res)) {
+                int field_count = taos_field_count(res);
+                printf("field_count: %d\n", field_count);
+                int64_t rows = print_result(tbname, res, i % 2);
+                printf("rows is: %"PRId64"\n", rows);
+
+            } else {
+                errorPrint("%s() LN%d: %s\n",
+                        __func__, __LINE__, taos_errstr(res));
+            }
+        } else {
+            errorPrint("%s() LN%d: %s\n",
+                    __func__, __LINE__, taos_errstr(res));
+        }
+    }
+}
+
+int main(int argc, char *argv[]) {
+    const char* host = "127.0.0.1";
+    const char* user = "root";
+    const char* passwd = "taosdata";
+
+    argp_parse(&argp, argc, argv, 0, 0, NULL);
+    TAOS* taos = taos_connect(host, user, passwd, "", 0);
+    if (taos == NULL) {
+        printf("\033[31mfailed to connect to db, reason:%s\033[0m\n", taos_errstr(taos));
+        exit(1);
+    }
+
+    const char* info = taos_get_server_info(taos);
+    printf("server info: %s\n", info);
+    info = taos_get_client_info(taos);
+    printf("client info: %s\n", info);
+
+    prepare_data(taos);
+
+    verify_query(taos);
+
+    taos_close(taos);
+    printf("done\n");
+
+    return 0;
+}
+

example/src/tmq.c

@@ -20,7 +20,19 @@
 #include "taos.h"
 
 static int  running = 1;
-static void msg_process(tmq_message_t* message) { tmqShowMsg(message); }
+static void msg_process(TAOS_RES* msg) {
+  char buf[1024];
+  printf("topic: %s\n", tmq_get_topic_name(msg));
+  printf("vg:%d\n", tmq_get_vgroup_id(msg));
+  while (1) {
+    TAOS_ROW row = taos_fetch_row(msg);
+    if (row == NULL) break;
+    TAOS_FIELD* fields = taos_fetch_fields(msg);
+    int32_t     numOfFields = taos_field_count(msg);
+    taos_print_row(buf, row, fields, numOfFields);
+    printf("%s\n", buf);
+  }
+}
 
 int32_t init_env() {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
@@ -90,7 +102,7 @@ int32_t create_topic() {
 
   /*const char* sql = "select * from tu1";*/
   /*pRes = tmq_create_topic(pConn, "test_stb_topic_1", sql, strlen(sql));*/
-  pRes = taos_query(pConn, "create topic topic_ctb_column as select ts, c1 from ct1");
+  pRes = taos_query(pConn, "create topic topic_ctb_column as select ts, c1, c2, c3 from ct1");
   if (taos_errno(pRes) != 0) {
     printf("failed to create topic topic_ctb_column, reason:%s\n", taos_errstr(pRes));
     return -1;
@@ -133,6 +145,7 @@ void tmq_commit_cb_print(tmq_t* tmq, tmq_resp_err_t resp, tmq_topic_vgroup_list_
 }
 
 tmq_t* build_consumer() {
+#if 0
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   assert(pConn != NULL);
 
@@ -141,11 +154,15 @@ tmq_t* build_consumer() {
     printf("error in use db, reason:%s\n", taos_errstr(pRes));
   }
   taos_free_result(pRes);
+#endif
 
   tmq_conf_t* conf = tmq_conf_new();
   tmq_conf_set(conf, "group.id", "tg2");
+  tmq_conf_set(conf, "td.connect.user", "root");
+  tmq_conf_set(conf, "td.connect.pass", "taosdata");
+  tmq_conf_set(conf, "td.connect.db", "abc1");
   tmq_conf_set_offset_commit_cb(conf, tmq_commit_cb_print);
-  tmq_t* tmq = tmq_consumer_new(pConn, conf, NULL, 0);
+  tmq_t* tmq = tmq_consumer_new1(conf, NULL, 0);
   return tmq;
 }
 
@@ -163,13 +180,14 @@ void basic_consume_loop(tmq_t* tmq, tmq_list_t* topics) {
     printf("subscribe err\n");
     return;
   }
-  /*int32_t cnt = 0;*/
+  int32_t cnt = 0;
   /*clock_t startTime = clock();*/
   while (running) {
-    tmq_message_t* tmqmessage = tmq_consumer_poll(tmq, 500);
+    TAOS_RES* tmqmessage = tmq_consumer_poll(tmq, 500);
     if (tmqmessage) {
-      /*cnt++;*/
+      cnt++;
-      msg_process(tmqmessage);
+      /*printf("get data\n");*/
+      /*msg_process(tmqmessage);*/
       tmq_message_destroy(tmqmessage);
       /*} else {*/
       /*break;*/
@@ -197,7 +215,7 @@ void sync_consume_loop(tmq_t* tmq, tmq_list_t* topics) {
   }
 
   while (running) {
-    tmq_message_t* tmqmessage = tmq_consumer_poll(tmq, 1000);
+    TAOS_RES* tmqmessage = tmq_consumer_poll(tmq, 1000);
     if (tmqmessage) {
       msg_process(tmqmessage);
       tmq_message_destroy(tmqmessage);
@@ -225,10 +243,10 @@ void perf_loop(tmq_t* tmq, tmq_list_t* topics) {
   int32_t skipLogNum = 0;
   clock_t startTime = clock();
   while (running) {
-    tmq_message_t* tmqmessage = tmq_consumer_poll(tmq, 500);
+    TAOS_RES* tmqmessage = tmq_consumer_poll(tmq, 500);
     if (tmqmessage) {
       batchCnt++;
-      skipLogNum += tmqGetSkipLogNum(tmqmessage);
+      /*skipLogNum += tmqGetSkipLogNum(tmqmessage);*/
       /*msg_process(tmqmessage);*/
       tmq_message_destroy(tmqmessage);
     } else {

include/client/taos.h

@@ -239,7 +239,7 @@ typedef struct tmq_topic_vgroup_list_t tmq_topic_vgroup_list_t;
 
 typedef struct tmq_conf_t tmq_conf_t;
 typedef struct tmq_list_t tmq_list_t;
-typedef struct tmq_message_t tmq_message_t;
+// typedef struct tmq_message_t tmq_message_t;
 
 typedef void(tmq_commit_cb(tmq_t *, tmq_resp_err_t, tmq_topic_vgroup_list_t *, void *param));
 
@@ -247,10 +247,10 @@ DLL_EXPORT tmq_list_t *tmq_list_new();
 DLL_EXPORT int32_t     tmq_list_append(tmq_list_t *, const char *);
 DLL_EXPORT void        tmq_list_destroy(tmq_list_t *);
 
-// will be removed in 3.0
+#if 1
 DLL_EXPORT tmq_t *tmq_consumer_new(void *conn, tmq_conf_t *conf, char *errstr, int32_t errstrLen);
+#endif
 
-// will replace last one
 DLL_EXPORT tmq_t *tmq_consumer_new1(tmq_conf_t *conf, char *errstr, int32_t errstrLen);
 
 DLL_EXPORT const char *tmq_err2str(tmq_resp_err_t);
@@ -259,7 +259,7 @@ DLL_EXPORT const char *tmq_err2str(tmq_resp_err_t);
 DLL_EXPORT tmq_resp_err_t tmq_subscribe(tmq_t *tmq, tmq_list_t *topic_list);
 DLL_EXPORT tmq_resp_err_t tmq_unsubscribe(tmq_t *tmq);
 DLL_EXPORT tmq_resp_err_t tmq_subscription(tmq_t *tmq, tmq_list_t **topics);
-DLL_EXPORT tmq_message_t *tmq_consumer_poll(tmq_t *tmq, int64_t blocking_time);
+DLL_EXPORT TAOS_RES      *tmq_consumer_poll(tmq_t *tmq, int64_t blocking_time);
 DLL_EXPORT tmq_resp_err_t tmq_consumer_close(tmq_t *tmq);
 #if 0
 DLL_EXPORT tmq_resp_err_t tmq_assign(tmq_t* tmq, const tmq_topic_vgroup_list_t* vgroups);
@@ -268,8 +268,8 @@ DLL_EXPORT tmq_resp_err_t tmq_assignment(tmq_t* tmq, tmq_topic_vgroup_list_t** v
 DLL_EXPORT tmq_resp_err_t tmq_commit(tmq_t *tmq, const tmq_topic_vgroup_list_t *offsets, int32_t async);
 #if 0
 DLL_EXPORT tmq_resp_err_t tmq_commit_message(tmq_t* tmq, const tmq_message_t* tmqmessage, int32_t async);
-#endif
 DLL_EXPORT tmq_resp_err_t tmq_seek(tmq_t *tmq, const tmq_topic_vgroup_t *offset);
+#endif
 /* ----------------------TMQ CONFIGURATION INTERFACE---------------------- */
 
 enum tmq_conf_res_t {
@@ -285,21 +285,24 @@ DLL_EXPORT tmq_conf_res_t tmq_conf_set(tmq_conf_t *conf, const char *key, const
 DLL_EXPORT void           tmq_conf_destroy(tmq_conf_t *conf);
 DLL_EXPORT void           tmq_conf_set_offset_commit_cb(tmq_conf_t *conf, tmq_commit_cb *cb);
 
+#if 0
 // temporary used function for demo only
 void    tmqShowMsg(tmq_message_t *tmq_message);
 int32_t tmqGetSkipLogNum(tmq_message_t *tmq_message);
+#endif
 
 /* -------------------------TMQ MSG HANDLE INTERFACE---------------------- */
 
+DLL_EXPORT char   *tmq_get_topic_name(TAOS_RES *res);
+DLL_EXPORT int32_t tmq_get_vgroup_id(TAOS_RES *res);
+#if 0
 DLL_EXPORT TAOS_ROW    tmq_get_row(tmq_message_t *message);
-DLL_EXPORT char       *tmq_get_topic_name(tmq_message_t *message);
-DLL_EXPORT int32_t     tmq_get_vgroup_id(tmq_message_t *message);
 DLL_EXPORT int64_t     tmq_get_request_offset(tmq_message_t *message);
 DLL_EXPORT int64_t     tmq_get_response_offset(tmq_message_t *message);
 DLL_EXPORT TAOS_FIELD *tmq_get_fields(tmq_t *tmq, const char *topic);
 DLL_EXPORT int32_t     tmq_field_count(tmq_t *tmq, const char *topic);
-DLL_EXPORT void        tmq_message_destroy(tmq_message_t *tmq_message);
+#endif
-
+DLL_EXPORT void tmq_message_destroy(TAOS_RES *res);
 /* --------------------TMPORARY INTERFACE FOR TESTING--------------------- */
 #if 0
 DLL_EXPORT TAOS_RES *tmq_create_topic(TAOS *taos, const char *name, const char *sql, int sqlLen);

include/common/taosdef.h

@@ -57,6 +57,8 @@ typedef enum {
   TD_ROW_PARTIAL_UPDATE = 2,
 } TDUpdateConfig;
 
+#define TD_SUPPORT_UPDATE(u) ((u) > 0)
+
 typedef enum {
   TSDB_STATIS_OK = 0,    // statis part exist and load successfully
   TSDB_STATIS_NONE = 1,  // statis part not exist

include/common/tcommon.h

@@ -222,7 +222,7 @@ typedef struct SFunctParam {
 // the structure for sql function in select clause
 typedef struct SResSchame {
   int8_t  type;
-  int32_t colId;
+  int32_t slotId;
   int32_t bytes;
   int32_t precision;
   int32_t scale;

include/common/tdatablock.h

@@ -136,7 +136,8 @@ static FORCE_INLINE void colDataAppendInt8(SColumnInfoData* pColumnInfoData, uin
 }
 
 static FORCE_INLINE void colDataAppendInt16(SColumnInfoData* pColumnInfoData, uint32_t currentRow, int16_t* v) {
-  ASSERT(pColumnInfoData->info.type == TSDB_DATA_TYPE_SMALLINT || pColumnInfoData->info.type == TSDB_DATA_TYPE_USMALLINT);
+  ASSERT(pColumnInfoData->info.type == TSDB_DATA_TYPE_SMALLINT ||
+         pColumnInfoData->info.type == TSDB_DATA_TYPE_USMALLINT);
   char* p = pColumnInfoData->pData + pColumnInfoData->info.bytes * currentRow;
   *(int16_t*)p = *(int16_t*)v;
 }
@@ -202,14 +203,17 @@ void    colInfoDataCleanup(SColumnInfoData* pColumn, uint32_t numOfRows);
 void blockDataCleanup(SSDataBlock* pDataBlock);
 
 size_t blockDataGetCapacityInRow(const SSDataBlock* pBlock, size_t pageSize);
-void*   blockDataDestroy(SSDataBlock* pBlock);
 
 int32_t blockDataTrimFirstNRows(SSDataBlock* pBlock, size_t n);
 
-SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock);
+SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock, bool copyData);
 
 void blockDebugShowData(const SArray* dataBlocks);
 
+static FORCE_INLINE int32_t blockGetEncodeSize(const SSDataBlock* pBlock) {
+  return blockDataGetSerialMetaSize(pBlock) + blockDataGetSize(pBlock);
+}
+
 static FORCE_INLINE int32_t blockCompressColData(SColumnInfoData* pColRes, int32_t numOfRows, char* data,
                                                  int8_t compressed) {
   int32_t colSize = colDataGetLength(pColRes, numOfRows);

include/common/tdataformat.h

@@ -482,7 +482,7 @@ void       tdResetDataCols(SDataCols *pCols);
 int32_t    tdInitDataCols(SDataCols *pCols, STSchema *pSchema);
 SDataCols *tdDupDataCols(SDataCols *pCols, bool keepData);
 SDataCols *tdFreeDataCols(SDataCols *pCols);
-int32_t tdMergeDataCols(SDataCols *target, SDataCols *source, int32_t rowsToMerge, int32_t *pOffset, bool forceSetNull);
+int32_t tdMergeDataCols(SDataCols *target, SDataCols *source, int32_t rowsToMerge, int32_t *pOffset, bool forceSetNull, TDRowVerT maxVer);
 
 // ----------------- K-V data row structure
 /* |<-------------------------------------- len -------------------------------------------->|

include/common/tglobal.h

@@ -18,6 +18,7 @@
 
 #include "tarray.h"
 #include "tdef.h"
+#include "tconfig.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -129,6 +130,7 @@ void    taosCfgDynamicOptions(const char *option, const char *value);
 void    taosAddDataDir(int32_t index, char *v1, int32_t level, int32_t primary);
 
 struct SConfig *taosGetCfg();
+int32_t taosAddClientLogCfg(SConfig *pCfg);
 
 #ifdef __cplusplus
 }

include/common/tmsg.h

@@ -86,30 +86,31 @@ enum {
 
 typedef enum _mgmt_table {
   TSDB_MGMT_TABLE_START,
-  TSDB_MGMT_TABLE_ACCT,
-  TSDB_MGMT_TABLE_USER,
-  TSDB_MGMT_TABLE_DB,
-  TSDB_MGMT_TABLE_TABLE,
   TSDB_MGMT_TABLE_DNODE,
   TSDB_MGMT_TABLE_MNODE,
+  TSDB_MGMT_TABLE_MODULE,
   TSDB_MGMT_TABLE_QNODE,
   TSDB_MGMT_TABLE_SNODE,
   TSDB_MGMT_TABLE_BNODE,
-  TSDB_MGMT_TABLE_VGROUP,
-  TSDB_MGMT_TABLE_STB,
-  TSDB_MGMT_TABLE_MODULE,
-  TSDB_MGMT_TABLE_QUERIES,
-  TSDB_MGMT_TABLE_STREAMS,
-  TSDB_MGMT_TABLE_VARIABLES,
-  TSDB_MGMT_TABLE_CONNS,
-  TSDB_MGMT_TABLE_TRANS,
-  TSDB_MGMT_TABLE_GRANTS,
-  TSDB_MGMT_TABLE_VNODES,
   TSDB_MGMT_TABLE_CLUSTER,
-  TSDB_MGMT_TABLE_STREAMTABLES,
+  TSDB_MGMT_TABLE_DB,
-  TSDB_MGMT_TABLE_TP,
   TSDB_MGMT_TABLE_FUNC,
   TSDB_MGMT_TABLE_INDEX,
+  TSDB_MGMT_TABLE_STB,
+  TSDB_MGMT_TABLE_STREAMS,
+  TSDB_MGMT_TABLE_TABLE,
+  TSDB_MGMT_TABLE_USER,
+  TSDB_MGMT_TABLE_GRANTS,
+  TSDB_MGMT_TABLE_VGROUP,
+  TSDB_MGMT_TABLE_TOPICS,
+  TSDB_MGMT_TABLE_CONSUMERS,
+  TSDB_MGMT_TABLE_SUBSCRIBES,
+  TSDB_MGMT_TABLE_TRANS,
+  TSDB_MGMT_TABLE_SMAS,
+  TSDB_MGMT_TABLE_CONFIGS,
+  TSDB_MGMT_TABLE_CONNS,
+  TSDB_MGMT_TABLE_QUERIES,
+  TSDB_MGMT_TABLE_VNODES,
   TSDB_MGMT_TABLE_MAX,
 } EShowType;
 
@@ -260,6 +261,7 @@ typedef struct {
 
 typedef struct SSchema {
   int8_t   type;
+  int8_t   index;  // default is 0, not index created
   col_id_t colId;
   int32_t  bytes;
   char     name[TSDB_COL_NAME_LEN];
@@ -331,6 +333,7 @@ int32_t taosEncodeSEpSet(void** buf, const SEpSet* pEp);
 void*   taosDecodeSEpSet(void* buf, SEpSet* pEp);
 
 typedef struct {
+  int8_t  connType;
   int32_t pid;
   char    app[TSDB_APP_NAME_LEN];
   char    db[TSDB_DB_NAME_LEN];
@@ -345,6 +348,7 @@ typedef struct {
   int64_t clusterId;
   int32_t connId;
   int8_t  superUser;
+  int8_t  connType;
   SEpSet  epSet;
   char    sVersion[128];
 } SConnectRsp;
@@ -360,7 +364,7 @@ typedef struct {
   int32_t maxTimeSeries;
   int32_t maxStreams;
   int32_t accessState;  // Configured only by command
-  int64_t maxStorage;   // In unit of GB
+  int64_t maxStorage;
 } SCreateAcctReq, SAlterAcctReq;
 
 int32_t tSerializeSCreateAcctReq(void* buf, int32_t bufLen, SCreateAcctReq* pReq);
@@ -745,7 +749,7 @@ typedef struct {
 
 typedef struct {
   int32_t     sver;      // software version
-  int64_t     dver;  // dnode table version in sdb
+  int64_t     dnodeVer;  // dnode table version in sdb
   int32_t     dnodeId;
   int64_t     clusterId;
   int64_t     rebootTime;
@@ -759,6 +763,7 @@ typedef struct {
 
 int32_t tSerializeSStatusReq(void* buf, int32_t bufLen, SStatusReq* pReq);
 int32_t tDeserializeSStatusReq(void* buf, int32_t bufLen, SStatusReq* pReq);
+void    tFreeSStatusReq(SStatusReq* pReq);
 
 typedef struct {
   int32_t dnodeId;
@@ -772,7 +777,7 @@ typedef struct {
 } SDnodeEp;
 
 typedef struct {
-  int64_t   dver;
+  int64_t   dnodeVer;
   SDnodeCfg dnodeCfg;
   SArray*   pDnodeEps;  // Array of SDnodeEp
 } SStatusRsp;
@@ -952,9 +957,14 @@ typedef struct {
   char    db[TSDB_DB_FNAME_LEN];
   char    tb[TSDB_TABLE_NAME_LEN];
   int64_t showId;
-  int8_t  free;
 } SRetrieveTableReq;
 
+typedef struct SSysTableSchema {
+  int8_t   type;
+  col_id_t colId;
+  int32_t  bytes;
+} SSysTableSchema;
+
 int32_t tSerializeSRetrieveTableReq(void* buf, int32_t bufLen, SRetrieveTableReq* pReq);
 int32_t tDeserializeSRetrieveTableReq(void* buf, int32_t bufLen, SRetrieveTableReq* pReq);
 
@@ -1875,7 +1885,6 @@ typedef struct {
   char    topicName[TSDB_TOPIC_FNAME_LEN];
   char    cgroup[TSDB_CGROUP_LEN];
   char*   sql;
-  char*   logicalPlan;
   char*   physicalPlan;
   char*   qmsg;
 } SMqSetCVgReq;
@@ -1889,7 +1898,6 @@ static FORCE_INLINE int32_t tEncodeSMqSetCVgReq(void** buf, const SMqSetCVgReq*
   tlen += taosEncodeString(buf, pReq->topicName);
   tlen += taosEncodeString(buf, pReq->cgroup);
   tlen += taosEncodeString(buf, pReq->sql);
-  tlen += taosEncodeString(buf, pReq->logicalPlan);
   tlen += taosEncodeString(buf, pReq->physicalPlan);
   tlen += taosEncodeString(buf, pReq->qmsg);
   return tlen;
@@ -1903,7 +1911,6 @@ static FORCE_INLINE void* tDecodeSMqSetCVgReq(void* buf, SMqSetCVgReq* pReq) {
   buf = taosDecodeStringTo(buf, pReq->topicName);
   buf = taosDecodeStringTo(buf, pReq->cgroup);
   buf = taosDecodeString(buf, &pReq->sql);
-  buf = taosDecodeString(buf, &pReq->logicalPlan);
   buf = taosDecodeString(buf, &pReq->physicalPlan);
   buf = taosDecodeString(buf, &pReq->qmsg);
   return buf;
@@ -2015,6 +2022,7 @@ typedef struct {
 static FORCE_INLINE int32_t taosEncodeSSchema(void** buf, const SSchema* pSchema) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI8(buf, pSchema->type);
+  tlen += taosEncodeFixedI8(buf, pSchema->index);
   tlen += taosEncodeFixedI32(buf, pSchema->bytes);
   tlen += taosEncodeFixedI16(buf, pSchema->colId);
   tlen += taosEncodeString(buf, pSchema->name);
@@ -2023,6 +2031,7 @@ static FORCE_INLINE int32_t taosEncodeSSchema(void** buf, const SSchema* pSchema
 
 static FORCE_INLINE void* taosDecodeSSchema(void* buf, SSchema* pSchema) {
   buf = taosDecodeFixedI8(buf, &pSchema->type);
+  buf = taosDecodeFixedI8(buf, &pSchema->index);
   buf = taosDecodeFixedI32(buf, &pSchema->bytes);
   buf = taosDecodeFixedI16(buf, &pSchema->colId);
   buf = taosDecodeStringTo(buf, pSchema->name);
@@ -2031,6 +2040,7 @@ static FORCE_INLINE void* taosDecodeSSchema(void* buf, SSchema* pSchema) {
 
 static FORCE_INLINE int32_t tEncodeSSchema(SCoder* pEncoder, const SSchema* pSchema) {
   if (tEncodeI8(pEncoder, pSchema->type) < 0) return -1;
+  if (tEncodeI8(pEncoder, pSchema->index) < 0) return -1;
   if (tEncodeI32(pEncoder, pSchema->bytes) < 0) return -1;
   if (tEncodeI16(pEncoder, pSchema->colId) < 0) return -1;
   if (tEncodeCStr(pEncoder, pSchema->name) < 0) return -1;
@@ -2039,6 +2049,7 @@ static FORCE_INLINE int32_t tEncodeSSchema(SCoder* pEncoder, const SSchema* pSch
 
 static FORCE_INLINE int32_t tDecodeSSchema(SCoder* pDecoder, SSchema* pSchema) {
   if (tDecodeI8(pDecoder, &pSchema->type) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pSchema->index) < 0) return -1;
   if (tDecodeI32(pDecoder, &pSchema->bytes) < 0) return -1;
   if (tDecodeI16(pDecoder, &pSchema->colId) < 0) return -1;
   if (tDecodeCStrTo(pDecoder, pSchema->name) < 0) return -1;
@@ -2363,8 +2374,7 @@ typedef struct {
   char           topic[TSDB_TOPIC_FNAME_LEN];
   int8_t         isSchemaAdaptive;
   SArray*        vgs;  // SArray<SMqSubVgEp>
-  int32_t     numOfFields;
+  SSchemaWrapper schema;
-  TAOS_FIELD* fields;
 } SMqSubTopicEp;
 
 typedef struct {
@@ -2379,6 +2389,53 @@ typedef struct {
   SArray*         pBlockData;  // SArray<SSDataBlock>
 } SMqPollRsp;
 
+typedef struct {
+  SMqRspHead head;
+  int64_t    reqOffset;
+  int64_t    rspOffset;
+  int32_t    skipLogNum;
+  int32_t    dataLen;
+  SArray*    blockPos;   // beginning pos for each SRetrieveTableRsp
+  void*      blockData;  // serialized batched SRetrieveTableRsp
+} SMqPollRspV2;
+
+static FORCE_INLINE int32_t tEncodeSMqPollRspV2(void** buf, const SMqPollRspV2* pRsp) {
+  int32_t tlen = 0;
+  tlen += taosEncodeFixedI64(buf, pRsp->reqOffset);
+  tlen += taosEncodeFixedI64(buf, pRsp->rspOffset);
+  tlen += taosEncodeFixedI32(buf, pRsp->skipLogNum);
+  tlen += taosEncodeFixedI32(buf, pRsp->dataLen);
+  if (pRsp->dataLen != 0) {
+    int32_t sz = taosArrayGetSize(pRsp->blockPos);
+    tlen += taosEncodeFixedI32(buf, sz);
+    for (int32_t i = 0; i < sz; i++) {
+      int32_t blockPos = *(int32_t*)taosArrayGet(pRsp->blockPos, i);
+      tlen += taosEncodeFixedI32(buf, blockPos);
+    }
+    tlen += taosEncodeBinary(buf, pRsp->blockData, pRsp->dataLen);
+  }
+  return tlen;
+}
+
+static FORCE_INLINE void* tDecodeSMqPollRspV2(const void* buf, SMqPollRspV2* pRsp) {
+  buf = taosDecodeFixedI64(buf, &pRsp->reqOffset);
+  buf = taosDecodeFixedI64(buf, &pRsp->rspOffset);
+  buf = taosDecodeFixedI32(buf, &pRsp->skipLogNum);
+  buf = taosDecodeFixedI32(buf, &pRsp->dataLen);
+  if (pRsp->dataLen != 0) {
+    int32_t sz;
+    buf = taosDecodeFixedI32(buf, &sz);
+    pRsp->blockPos = taosArrayInit(sz, sizeof(int32_t));
+    for (int32_t i = 0; i < sz; i++) {
+      int32_t blockPos;
+      buf = taosDecodeFixedI32(buf, &blockPos);
+      taosArrayPush(pRsp->blockPos, &blockPos);
+    }
+    buf = taosDecodeBinary(buf, &pRsp->blockData, pRsp->dataLen);
+  }
+  return (void*)buf;
+}
+
 typedef struct {
   SMqRspHead head;
   char       cgroup[TSDB_CGROUP_LEN];
@@ -2416,8 +2473,7 @@ static FORCE_INLINE int32_t tEncodeSMqSubTopicEp(void** buf, const SMqSubTopicEp
     SMqSubVgEp* pVgEp = (SMqSubVgEp*)taosArrayGet(pTopicEp->vgs, i);
     tlen += tEncodeSMqSubVgEp(buf, pVgEp);
   }
-  tlen += taosEncodeFixedI32(buf, pTopicEp->numOfFields);
+  tlen += taosEncodeSSchemaWrapper(buf, &pTopicEp->schema);
-  // tlen += taosEncodeBinary(buf, pTopicEp->fields, pTopicEp->numOfFields * sizeof(TAOS_FIELD));
   return tlen;
 }
 
@@ -2435,8 +2491,7 @@ static FORCE_INLINE void* tDecodeSMqSubTopicEp(void* buf, SMqSubTopicEp* pTopicE
     buf = tDecodeSMqSubVgEp(buf, &vgEp);
     taosArrayPush(pTopicEp->vgs, &vgEp);
   }
-  buf = taosDecodeFixedI32(buf, &pTopicEp->numOfFields);
+  buf = taosDecodeSSchemaWrapper(buf, &pTopicEp->schema);
-  // buf = taosDecodeBinary(buf, (void**)&pTopicEp->fields, pTopicEp->numOfFields * sizeof(TAOS_FIELD));
   return buf;
 }
 

include/common/tmsgdef.h

@@ -136,7 +136,6 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_KILL_CONN, "mnode-kill-conn", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_HEARTBEAT, "mnode-heartbeat", SClientHbBatchReq, SClientHbBatchRsp)
   TD_DEF_MSG_TYPE(TDMT_MND_SHOW, "mnode-show", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_SHOW_RETRIEVE, "mnode-retrieve", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_SYSTABLE_RETRIEVE, "mnode-systable-retrieve", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_STATUS, "mnode-status", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_TRANS_TIMER, "mnode-trans-tmr", NULL, NULL)
@@ -189,8 +188,8 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_CREATE_TOPIC, "vnode-create-topic", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_ALTER_TOPIC, "vnode-alter-topic", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_DROP_TOPIC, "vnode-drop-topic", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_SHOW_TABLES, "vnode-show-tables", SVShowTablesReq, SVShowTablesRsp)
+//  TD_DEF_MSG_TYPE(TDMT_VND_SHOW_TABLES, "vnode-show-tables", SVShowTablesReq, SVShowTablesRsp)
-  TD_DEF_MSG_TYPE(TDMT_VND_SHOW_TABLES_FETCH, "vnode-show-tables-fetch", SVShowTablesFetchReq, SVShowTablesFetchRsp)
+//  TD_DEF_MSG_TYPE(TDMT_VND_SHOW_TABLES_FETCH, "vnode-show-tables-fetch", SVShowTablesFetchReq, SVShowTablesFetchRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_QUERY_CONTINUE, "vnode-query-continue", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_QUERY_HEARTBEAT, "vnode-query-heartbeat", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_EXPLAIN, "vnode-explain", NULL, NULL)

include/common/trow.h

@@ -230,7 +230,7 @@ static FORCE_INLINE int32_t tdAppendColValToTpRow(SRowBuilder *pBuilder, TDRowVa
 static FORCE_INLINE int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowValT valType, const void *val,
                                                   bool isCopyVarData, int8_t colType, int16_t colIdx, int32_t offset,
                                                   col_id_t colId);
-int32_t tdAppendSTSRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols *pCols, bool forceSetNull);
+int32_t tdAppendSTSRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols *pCols);
 
 /**
  * @brief

include/common/ttime.h

@@ -40,6 +40,7 @@ extern "C" {
  * @return timestamp decided by global conf variable, tsTimePrecision
  * if precision == TSDB_TIME_PRECISION_MICRO, it returns timestamp in microsecond.
  *    precision == TSDB_TIME_PRECISION_MILLI, it returns timestamp in millisecond.
+ *    precision == TSDB_TIME_PRECISION_NANO,  it returns timestamp in nanosecond.
  */
 static FORCE_INLINE int64_t taosGetTimestamp(int32_t precision) {
   if (precision == TSDB_TIME_PRECISION_MICRO) {
@@ -51,6 +52,24 @@ static FORCE_INLINE int64_t taosGetTimestamp(int32_t precision) {
   }
 }
 
+/*
+ * @return timestamp of today at 00:00:00 in given precision
+ * if precision == TSDB_TIME_PRECISION_MICRO, it returns timestamp in microsecond.
+ *    precision == TSDB_TIME_PRECISION_MILLI, it returns timestamp in millisecond.
+ *    precision == TSDB_TIME_PRECISION_NANO,  it returns timestamp in nanosecond.
+ */
+static FORCE_INLINE int64_t taosGetTimestampToday(int32_t precision) {
+  int64_t factor = (precision == TSDB_TIME_PRECISION_MILLI) ? 1000 :
+                   (precision == TSDB_TIME_PRECISION_MICRO) ? 1000000 : 1000000000;
+  time_t t = taosTime(NULL);
+  struct tm * tm= taosLocalTime(&t, NULL);
+  tm->tm_hour = 0;
+  tm->tm_min = 0;
+  tm->tm_sec = 0;
+
+  return (int64_t)taosMktime(tm) * factor;
+}
+
 int64_t taosTimeAdd(int64_t t, int64_t duration, char unit, int32_t precision);
 int64_t taosTimeTruncate(int64_t t, const SInterval* pInterval, int32_t precision);
 int32_t taosTimeCountInterval(int64_t skey, int64_t ekey, int64_t interval, char unit, int32_t precision);
@@ -64,6 +83,7 @@ char getPrecisionUnit(int32_t precision);
 
 int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrecision);
 int64_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char toUnit);
+int32_t convertStringToTimestamp(int16_t type, char *inputData, int64_t timePrec, int64_t *timeVal);
 
 void taosFormatUtcTime(char *buf, int32_t bufLen, int64_t time, int32_t precision);
 

include/common/ttokendef.h

@@ -140,88 +140,91 @@
 #define TK_APPS                           122
 #define TK_CONNECTIONS                    123
 #define TK_LICENCE                        124
-#define TK_QUERIES                        125
+#define TK_GRANTS                         125
-#define TK_SCORES                         126
+#define TK_QUERIES                        126
-#define TK_TOPICS                         127
+#define TK_SCORES                         127
-#define TK_VARIABLES                      128
+#define TK_TOPICS                         128
-#define TK_BNODES                         129
+#define TK_VARIABLES                      129
-#define TK_SNODES                         130
+#define TK_BNODES                         130
-#define TK_LIKE                           131
+#define TK_SNODES                         131
-#define TK_INDEX                          132
+#define TK_LIKE                           132
-#define TK_FULLTEXT                       133
+#define TK_INDEX                          133
-#define TK_FUNCTION                       134
+#define TK_FULLTEXT                       134
-#define TK_INTERVAL                       135
+#define TK_FUNCTION                       135
-#define TK_TOPIC                          136
+#define TK_INTERVAL                       136
-#define TK_AS                             137
+#define TK_TOPIC                          137
-#define TK_DESC                           138
+#define TK_AS                             138
-#define TK_DESCRIBE                       139
+#define TK_DESC                           139
-#define TK_RESET                          140
+#define TK_DESCRIBE                       140
-#define TK_QUERY                          141
+#define TK_RESET                          141
-#define TK_EXPLAIN                        142
+#define TK_QUERY                          142
-#define TK_ANALYZE                        143
+#define TK_EXPLAIN                        143
-#define TK_VERBOSE                        144
+#define TK_ANALYZE                        144
-#define TK_NK_BOOL                        145
+#define TK_VERBOSE                        145
-#define TK_RATIO                          146
+#define TK_NK_BOOL                        146
-#define TK_COMPACT                        147
+#define TK_RATIO                          147
-#define TK_VNODES                         148
+#define TK_COMPACT                        148
-#define TK_IN                             149
+#define TK_VNODES                         149
-#define TK_OUTPUTTYPE                     150
+#define TK_IN                             150
-#define TK_AGGREGATE                      151
+#define TK_OUTPUTTYPE                     151
-#define TK_BUFSIZE                        152
+#define TK_AGGREGATE                      152
-#define TK_STREAM                         153
+#define TK_BUFSIZE                        153
-#define TK_INTO                           154
+#define TK_STREAM                         154
-#define TK_KILL                           155
+#define TK_INTO                           155
-#define TK_CONNECTION                     156
+#define TK_KILL                           156
-#define TK_MERGE                          157
+#define TK_CONNECTION                     157
-#define TK_VGROUP                         158
+#define TK_MERGE                          158
-#define TK_REDISTRIBUTE                   159
+#define TK_VGROUP                         159
-#define TK_SPLIT                          160
+#define TK_REDISTRIBUTE                   160
-#define TK_SYNCDB                         161
+#define TK_SPLIT                          161
-#define TK_NULL                           162
+#define TK_SYNCDB                         162
-#define TK_FIRST                          163
+#define TK_NULL                           163
-#define TK_LAST                           164
+#define TK_FIRST                          164
-#define TK_NOW                            165
+#define TK_LAST                           165
-#define TK_ROWTS                          166
+#define TK_CAST                           166
-#define TK_TBNAME                         167
+#define TK_NOW                            167
-#define TK_QSTARTTS                       168
+#define TK_TODAY                          168
-#define TK_QENDTS                         169
+#define TK_ROWTS                          169
-#define TK_WSTARTTS                       170
+#define TK_TBNAME                         170
-#define TK_WENDTS                         171
+#define TK_QSTARTTS                       171
-#define TK_WDURATION                      172
+#define TK_QENDTS                         172
-#define TK_BETWEEN                        173
+#define TK_WSTARTTS                       173
-#define TK_IS                             174
+#define TK_WENDTS                         174
-#define TK_NK_LT                          175
+#define TK_WDURATION                      175
-#define TK_NK_GT                          176
+#define TK_BETWEEN                        176
-#define TK_NK_LE                          177
+#define TK_IS                             177
-#define TK_NK_GE                          178
+#define TK_NK_LT                          178
-#define TK_NK_NE                          179
+#define TK_NK_GT                          179
-#define TK_MATCH                          180
+#define TK_NK_LE                          180
-#define TK_NMATCH                         181
+#define TK_NK_GE                          181
-#define TK_JOIN                           182
+#define TK_NK_NE                          182
-#define TK_INNER                          183
+#define TK_MATCH                          183
-#define TK_SELECT                         184
+#define TK_NMATCH                         184
-#define TK_DISTINCT                       185
+#define TK_JOIN                           185
-#define TK_WHERE                          186
+#define TK_INNER                          186
-#define TK_PARTITION                      187
+#define TK_SELECT                         187
-#define TK_BY                             188
+#define TK_DISTINCT                       188
-#define TK_SESSION                        189
+#define TK_WHERE                          189
-#define TK_STATE_WINDOW                   190
+#define TK_PARTITION                      190
-#define TK_SLIDING                        191
+#define TK_BY                             191
-#define TK_FILL                           192
+#define TK_SESSION                        192
-#define TK_VALUE                          193
+#define TK_STATE_WINDOW                   193
-#define TK_NONE                           194
+#define TK_SLIDING                        194
-#define TK_PREV                           195
+#define TK_FILL                           195
-#define TK_LINEAR                         196
+#define TK_VALUE                          196
-#define TK_NEXT                           197
+#define TK_NONE                           197
-#define TK_GROUP                          198
+#define TK_PREV                           198
-#define TK_HAVING                         199
+#define TK_LINEAR                         199
-#define TK_ORDER                          200
+#define TK_NEXT                           200
-#define TK_SLIMIT                         201
+#define TK_GROUP                          201
-#define TK_SOFFSET                        202
+#define TK_HAVING                         202
-#define TK_LIMIT                          203
+#define TK_ORDER                          203
-#define TK_OFFSET                         204
+#define TK_SLIMIT                         204
-#define TK_ASC                            205
+#define TK_SOFFSET                        205
-#define TK_NULLS                          206
+#define TK_LIMIT                          206
+#define TK_OFFSET                         207
+#define TK_ASC                            208
+#define TK_NULLS                          209
 
 #define TK_NK_SPACE                       300
 #define TK_NK_COMMENT                     301

include/common/ttypes.h

@@ -24,9 +24,9 @@ extern "C" {
 #include "types.h"
 
 // ----------------- For variable data types such as TSDB_DATA_TYPE_BINARY and TSDB_DATA_TYPE_NCHAR
-typedef int32_t  VarDataOffsetT;
 typedef uint32_t TDRowLenT;
 typedef uint8_t  TDRowValT;
+typedef uint64_t TDRowVerT;
 typedef int16_t  col_id_t;
 typedef int8_t   col_type_t;
 typedef int32_t  col_bytes_t;
@@ -141,9 +141,47 @@ typedef struct {
     }                                          \
   } while (0)
 
+#define NUM_TO_STRING(_inputType, _input, _outputBytes, _output)     \
+  do {                                         \
+    switch (_inputType) {                      \
+      case TSDB_DATA_TYPE_TINYINT:             \
+        snprintf(_output, (int32_t)(_outputBytes), "%d", *(int8_t *)(_input));     \
+        break;                                 \
+      case TSDB_DATA_TYPE_UTINYINT:            \
+        snprintf(_output, (int32_t)(_outputBytes), "%d", *(uint8_t *)(_input));     \
+        break;                                 \
+      case TSDB_DATA_TYPE_SMALLINT:            \
+        snprintf(_output, (int32_t)(_outputBytes), "%d", *(int16_t *)(_input));     \
+        break;                                 \
+      case TSDB_DATA_TYPE_USMALLINT:           \
+        snprintf(_output, (int32_t)(_outputBytes), "%d", *(uint16_t *)(_input));     \
+        break;                                 \
+      case TSDB_DATA_TYPE_TIMESTAMP:           \
+      case TSDB_DATA_TYPE_BIGINT:              \
+        snprintf(_output, (int32_t)(_outputBytes), "%" PRId64, *(int64_t *)(_input));     \
+        break;                                 \
+      case TSDB_DATA_TYPE_UBIGINT:             \
+        snprintf(_output, (int32_t)(_outputBytes), "%" PRIu64, *(uint64_t *)(_input));     \
+        break;                                 \
+      case TSDB_DATA_TYPE_FLOAT:               \
+        snprintf(_output, (int32_t)(_outputBytes), "%f", *(float *)(_input));     \
+        break;                                 \
+      case TSDB_DATA_TYPE_DOUBLE:              \
+        snprintf(_output, (int32_t)(_outputBytes), "%f", *(double *)(_input));     \
+        break;                                 \
+      case TSDB_DATA_TYPE_UINT:                \
+        snprintf(_output, (int32_t)(_outputBytes), "%u", *(uint32_t *)(_input));     \
+        break;                                 \
+      default:                                 \
+        snprintf(_output, (int32_t)(_outputBytes), "%d", *(int32_t *)(_input));     \
+        break;                                 \
+    }                                          \
+  } while (0)
+
 #define IS_SIGNED_NUMERIC_TYPE(_t)   ((_t) >= TSDB_DATA_TYPE_TINYINT && (_t) <= TSDB_DATA_TYPE_BIGINT)
 #define IS_UNSIGNED_NUMERIC_TYPE(_t) ((_t) >= TSDB_DATA_TYPE_UTINYINT && (_t) <= TSDB_DATA_TYPE_UBIGINT)
 #define IS_FLOAT_TYPE(_t)            ((_t) == TSDB_DATA_TYPE_FLOAT || (_t) == TSDB_DATA_TYPE_DOUBLE)
+#define IS_INTEGER_TYPE(_t)          ((IS_SIGNED_NUMERIC_TYPE(_t)) || (IS_UNSIGNED_NUMERIC_TYPE(_t)))
 
 #define IS_NUMERIC_TYPE(_t) ((IS_SIGNED_NUMERIC_TYPE(_t)) || (IS_UNSIGNED_NUMERIC_TYPE(_t)) || (IS_FLOAT_TYPE(_t)))
 #define IS_MATHABLE_TYPE(_t) (IS_NUMERIC_TYPE(_t) || (_t) == (TSDB_DATA_TYPE_BOOL) || (_t) == (TSDB_DATA_TYPE_TIMESTAMP))

include/dnode/mgmt/dnode.h

@@ -30,12 +30,12 @@ typedef struct SDnode SDnode;
  *
  * @return int32_t 0 for success and -1 for failure
  */
-int32_t dndInit();
+int32_t dmInit();
 
 /**
  * @brief Clear the environment
  */
-void dndCleanup();
+void dmCleanup();
 
 /* ------------------------ SDnode ----------------------- */
 typedef struct {
@@ -51,7 +51,7 @@ typedef struct {
   int8_t    ntype;
 } SDnodeOpt;
 
-typedef enum { DND_EVENT_START, DND_EVENT_STOP = 1, DND_EVENT_CHILD } EDndEvent;
+typedef enum { DND_EVENT_START = 0, DND_EVENT_STOP = 1, DND_EVENT_CHILD = 2 } EDndEvent;
 
 /**
  * @brief Initialize and start the dnode.
@@ -59,21 +59,21 @@ typedef enum { DND_EVENT_START, DND_EVENT_STOP = 1, DND_EVENT_CHILD } EDndEvent;
  * @param pOption Option of the dnode.
  * @return SDnode* The dnode object.
  */
-SDnode *dndCreate(const SDnodeOpt *pOption);
+SDnode *dmCreate(const SDnodeOpt *pOption);
 
 /**
  * @brief Stop and cleanup the dnode.
  *
  * @param pDnode The dnode object to close.
  */
-void dndClose(SDnode *pDnode);
+void dmClose(SDnode *pDnode);
 
 /**
  * @brief Run dnode until specific event is receive.
  *
  * @param pDnode The dnode object to run.
  */
-int32_t dndRun(SDnode *pDnode);
+int32_t dmRun(SDnode *pDnode);
 
 /**
  * @brief Handle event in the dnode.
@@ -81,7 +81,7 @@ int32_t dndRun(SDnode *pDnode);
  * @param pDnode The dnode object to close.
  * @param event The event to handle.
  */
-void dndHandleEvent(SDnode *pDnode, EDndEvent event);
+void dmSetEvent(SDnode *pDnode, EDndEvent event);
 
 #ifdef __cplusplus
 }

include/dnode/mnode/mnode.h

@@ -68,31 +68,18 @@ int32_t mndAlter(SMnode *pMnode, const SMnodeOpt *pOption);
  * @param pMnode The mnode object.
  */
 int32_t mndStart(SMnode *pMnode);
+void    mndStop(SMnode *pMnode);
 
 /**
  * @brief Get mnode monitor info.
  *
  * @param pMnode The mnode object.
- * @param pClusterInfo
+ * @param pCluster
- * @param pVgroupInfo
+ * @param pVgroup
- * @param pGrantInfo
+ * @param pGrant
  * @return int32_t 0 for success, -1 for failure.
  */
-int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgroupInfo *pVgroupInfo,
+int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pCluster, SMonVgroupInfo *pVgroup, SMonGrantInfo *pGrant);
-                          SMonGrantInfo *pGrantInfo);
-
-/**
- * @brief Get user authentication info.
- *
- * @param pMnode The mnode object.
- * @param user
- * @param spi
- * @param encrypt
- * @param secret
- * @param ckey
- * @return int32_t 0 for success, -1 for failure.
- */
-int32_t mndRetriveAuth(SMnode *pMnode, char *user, char *spi, char *encrypt, char *secret, char *ckey);
 
 /**
  * @brief Process the read, write, sync request.
@@ -102,6 +89,11 @@ int32_t mndRetriveAuth(SMnode *pMnode, char *user, char *spi, char *encrypt, cha
  */
 int32_t mndProcessMsg(SNodeMsg *pMsg);
 
+/**
+ * @brief Generate machine code
+ */
+void mndGenerateMachineCode();
+
 #ifdef __cplusplus
 }
 #endif

include/libs/command/command.h

@@ -22,7 +22,7 @@ typedef struct SExplainCtx SExplainCtx;
 int32_t qExecCommand(SNode* pStmt, SRetrieveTableRsp** pRsp);
 
 int32_t qExecStaticExplain(SQueryPlan *pDag, SRetrieveTableRsp **pRsp);
-int32_t qExecExplainBegin(SQueryPlan *pDag, SExplainCtx **pCtx, int32_t startTs);
+int32_t qExecExplainBegin(SQueryPlan *pDag, SExplainCtx **pCtx, int64_t startTs);
 int32_t qExecExplainEnd(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp);
 int32_t qExplainUpdateExecInfo(SExplainCtx        *pCtx, SExplainRsp *pRspMsg, int32_t groupId, SRetrieveTableRsp **pRsp);
 void    qExplainFreeCtx(SExplainCtx *pCtx);

include/libs/function/functionMgt.h

@@ -85,8 +85,8 @@ typedef enum EFunctionType {
   // conversion function
   FUNCTION_TYPE_CAST = 2000,
   FUNCTION_TYPE_TO_ISO8601,
+  FUNCTION_TYPE_TO_UNIXTIMESTAMP,
   FUNCTION_TYPE_TO_JSON,
-  FUNCTION_TYPE_UNIXTIMESTAMP,
 
   // date and time function
   FUNCTION_TYPE_NOW = 2500,
@@ -123,7 +123,7 @@ void fmFuncMgtDestroy();
 
 int32_t fmGetFuncInfo(const char* pFuncName, int32_t* pFuncId, int32_t* pFuncType);
 
-int32_t fmGetFuncResultType(SFunctionNode* pFunc);
+int32_t fmGetFuncResultType(SFunctionNode* pFunc, char* pErrBuf, int32_t len);
 
 bool fmIsAggFunc(int32_t funcId);
 bool fmIsScalarFunc(int32_t funcId);
@@ -135,8 +135,17 @@ bool fmIsTimeorderFunc(int32_t funcId);
 bool fmIsPseudoColumnFunc(int32_t funcId);
 bool fmIsWindowPseudoColumnFunc(int32_t funcId);
 bool fmIsWindowClauseFunc(int32_t funcId);
+bool fmIsSpecialDataRequiredFunc(int32_t funcId);
+bool fmIsDynamicScanOptimizedFunc(int32_t funcId);
 
-int32_t fmFuncScanType(int32_t funcId);
+typedef enum EFuncDataRequired {
+  FUNC_DATA_REQUIRED_ALL_NEEDED = 1,
+  FUNC_DATA_REQUIRED_STATIS_NEEDED,
+  FUNC_DATA_REQUIRED_NO_NEEDED,
+  FUNC_DATA_REQUIRED_DISCARD
+} EFuncDataRequired;
+
+EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow);
 
 int32_t fmGetFuncExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet);
 int32_t fmGetScalarFuncExecFuncs(int32_t funcId, SScalarFuncExecFuncs* pFpSet);

include/libs/monitor/monitor.h

@@ -78,6 +78,9 @@ typedef struct {
 typedef struct {
   float        uptime;  // day
   int8_t       has_mnode;
+  int8_t       has_qnode;
+  int8_t       has_snode;
+  int8_t       has_bnode;
   SMonDiskDesc logdir;
   SMonDiskDesc tempdir;
 } SMonDnodeInfo;
@@ -134,8 +137,8 @@ typedef struct {
 
 typedef struct {
   int32_t expire_time;
-  int32_t timeseries_used;
+  int64_t timeseries_used;
-  int32_t timeseries_total;
+  int64_t timeseries_total;
 } SMonGrantInfo;
 
 typedef struct {

include/libs/nodes/cmdnodes.h

@@ -267,6 +267,11 @@ typedef struct SDescribeStmt {
   STableMeta* pMeta;
 } SDescribeStmt;
 
+typedef struct SKillStmt {
+  ENodeType type;
+  int32_t targetId;
+} SKillStmt;
+
 #ifdef __cplusplus
 }
 #endif

include/libs/nodes/nodes.h

@@ -52,7 +52,8 @@ extern "C" {
   for (SListCell* cell = (NULL != (list) ? (list)->pHead : NULL); (NULL != cell ? (node = &(cell->pNode), true) : (node = NULL, false)); cell = cell->pNext)
 
 typedef enum ENodeType {
-  // Syntax nodes are used in parser and planner module, and some are also used in executor module, such as COLUMN, VALUE, OPERATOR, FUNCTION and so on.
+  // Syntax nodes are used in parser and planner module, and some are also used in executor module, such as COLUMN,
+  // VALUE, OPERATOR, FUNCTION and so on.
   QUERY_NODE_COLUMN = 1,
   QUERY_NODE_VALUE,
   QUERY_NODE_OPERATOR,
@@ -126,30 +127,30 @@ typedef enum ENodeType {
   QUERY_NODE_REDISTRIBUTE_VGROUP_STMT,
   QUERY_NODE_SPLIT_VGROUP_STMT,
   QUERY_NODE_SYNCDB_STMT,
-  QUERY_NODE_SHOW_DATABASES_STMT,
-  QUERY_NODE_SHOW_TABLES_STMT,
-  QUERY_NODE_SHOW_STABLES_STMT,
-  QUERY_NODE_SHOW_USERS_STMT,
   QUERY_NODE_SHOW_DNODES_STMT,
-  QUERY_NODE_SHOW_VGROUPS_STMT,
   QUERY_NODE_SHOW_MNODES_STMT,
   QUERY_NODE_SHOW_MODULES_STMT,
   QUERY_NODE_SHOW_QNODES_STMT,
+  QUERY_NODE_SHOW_SNODES_STMT,
+  QUERY_NODE_SHOW_BNODES_STMT,
+  QUERY_NODE_SHOW_DATABASES_STMT,
   QUERY_NODE_SHOW_FUNCTIONS_STMT,
   QUERY_NODE_SHOW_INDEXES_STMT,
+  QUERY_NODE_SHOW_STABLES_STMT,
   QUERY_NODE_SHOW_STREAMS_STMT,
-  QUERY_NODE_SHOW_APPS_STMT,
+  QUERY_NODE_SHOW_TABLES_STMT,
-  QUERY_NODE_SHOW_CONNECTIONS_STMT,
+  QUERY_NODE_SHOW_USERS_STMT,
   QUERY_NODE_SHOW_LICENCE_STMT,
-  QUERY_NODE_SHOW_CREATE_DATABASE_STMT,
+  QUERY_NODE_SHOW_VGROUPS_STMT,
-  QUERY_NODE_SHOW_CREATE_TABLE_STMT,
-  QUERY_NODE_SHOW_CREATE_STABLE_STMT, 
-  QUERY_NODE_SHOW_QUERIES_STMT,
-  QUERY_NODE_SHOW_SCORES_STMT,
   QUERY_NODE_SHOW_TOPICS_STMT,
-  QUERY_NODE_SHOW_VARIABLE_STMT,
+  QUERY_NODE_SHOW_CONSUMERS_STMT,
-  QUERY_NODE_SHOW_BNODES_STMT,
+  QUERY_NODE_SHOW_SUBSCRIBES_STMT,
-  QUERY_NODE_SHOW_SNODES_STMT,
+  QUERY_NODE_SHOW_TRANS_STMT,
+  QUERY_NODE_SHOW_SMAS_STMT,
+  QUERY_NODE_SHOW_CONFIGS_STMT,
+  QUERY_NODE_SHOW_CONNECTIONS_STMT,
+  QUERY_NODE_SHOW_QUERIES_STMT,
+  QUERY_NODE_SHOW_VNODES_STMT,
   QUERY_NODE_KILL_CONNECTION_STMT,
   QUERY_NODE_KILL_QUERY_STMT,
 
@@ -216,6 +217,7 @@ SNodeList* nodesMakeList();
 int32_t nodesListAppend(SNodeList* pList, SNodeptr pNode);
 int32_t nodesListStrictAppend(SNodeList* pList, SNodeptr pNode);
 int32_t nodesListMakeAppend(SNodeList** pList, SNodeptr pNode);
+int32_t nodesListMakeStrictAppend(SNodeList** pList, SNodeptr pNode);
 int32_t nodesListAppendList(SNodeList* pTarget, SNodeList* pSrc);
 int32_t nodesListStrictAppendList(SNodeList* pTarget, SNodeList* pSrc);
 int32_t nodesListPushFront(SNodeList* pList, SNodeptr pNode);
@@ -230,6 +232,7 @@ typedef enum EDealRes {
   DEAL_RES_CONTINUE = 1,
   DEAL_RES_IGNORE_CHILD,
   DEAL_RES_ERROR,
+  DEAL_RES_END
 } EDealRes;
 
 typedef EDealRes (*FNodeWalker)(SNode* pNode, void* pContext);

include/libs/nodes/plannodes.h

@@ -30,6 +30,7 @@ typedef struct SLogicNode {
   SNode* pConditions;
   SNodeList* pChildren;
   struct SLogicNode* pParent;
+  int32_t optimizedFlag;
 } SLogicNode;
 
 typedef enum EScanType {
@@ -50,6 +51,8 @@ typedef struct SScanLogicNode {
   SName tableName;
   bool showRewrite;
   double ratio;
+  SNodeList* pDynamicScanFuncs;
+  int32_t dataRequired;
 } SScanLogicNode;
 
 typedef struct SJoinLogicNode {
@@ -84,6 +87,7 @@ typedef struct SVnodeModifLogicNode {
 typedef struct SExchangeLogicNode {
   SLogicNode node;
   int32_t srcGroupId;
+  uint8_t precision;
 } SExchangeLogicNode;
 
 typedef enum EWindowType {
@@ -163,7 +167,7 @@ typedef struct SDataBlockDescNode {
   SNodeList* pSlots;
   int32_t totalRowSize;
   int32_t outputRowSize;
-  int16_t precision;
+  uint8_t precision;
 } SDataBlockDescNode;
 
 typedef struct SPhysiNode {
@@ -195,20 +199,13 @@ typedef struct SSystemTableScanPhysiNode {
   int32_t accountId;
 } SSystemTableScanPhysiNode;
 
-typedef enum EScanRequired {
-  SCAN_REQUIRED_DATA_NO_NEEDED = 1,
-  SCAN_REQUIRED_DATA_STATIS_NEEDED,
-  SCAN_REQUIRED_DATA_ALL_NEEDED,
-  SCAN_REQUIRED_DATA_DISCARD,
-} EScanRequired;
-
 typedef struct STableScanPhysiNode {
   SScanPhysiNode scan;
   uint8_t scanFlag;         // denotes reversed scan of data or not
   STimeWindow scanRange;
   double ratio;
-  EScanRequired scanRequired;
+  int32_t dataRequired;
-  SNodeList* pScanReferFuncs;
+  SNodeList* pDynamicScanFuncs;
 } STableScanPhysiNode;
 
 typedef STableScanPhysiNode STableSeqScanPhysiNode;
@@ -253,11 +250,11 @@ typedef struct SWinodwPhysiNode {
   SPhysiNode node;
   SNodeList* pExprs;   // these are expression list of parameter expression of function
   SNodeList* pFuncs;
+  SNode* pTspk; // timestamp primary key
 } SWinodwPhysiNode;
 
 typedef struct SIntervalPhysiNode {
   SWinodwPhysiNode window;
-  SNode* pTspk; // timestamp primary key
   int64_t    interval;
   int64_t    offset;
   int64_t    sliding;

include/libs/nodes/querynodes.h

@@ -190,6 +190,7 @@ typedef struct SLimitNode {
 
 typedef struct SStateWindowNode {
   ENodeType type; // QUERY_NODE_STATE_WINDOW
+  SNode* pCol; // timestamp primary key
   SNode* pExpr;
 } SStateWindowNode;
 

include/libs/scalar/filter.h

@@ -19,8 +19,8 @@
 extern "C" {
 #endif
 
-#include "tcommon.h"
 #include "nodes.h"
+#include "tcommon.h"
 
 typedef struct SFilterInfo SFilterInfo;
 typedef int32_t (*filer_get_col_from_id)(void *, int32_t, void **);

include/libs/scalar/scalar.h

@@ -70,6 +70,15 @@ int32_t ltrimFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut
 int32_t rtrimFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t substrFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
+/* Conversion functions */
+int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+
+/* Time related functions */
+int32_t toISO8601Function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t toUnixtimestampFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t timeDiffFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+
 bool getTimePseudoFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
 
 int32_t winStartTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);

include/os/osDir.h

@@ -38,6 +38,7 @@ typedef struct TdDirEntry *TdDirEntryPtr;
 void    taosRemoveDir(const char *dirname);
 bool    taosDirExist(char *dirname);
 int32_t taosMkDir(const char *dirname);
+int32_t taosMulMkDir(const char *dirname);
 void    taosRemoveOldFiles(const char *dirname, int32_t keepDays);
 int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen);
 int32_t taosRealPath(char *dirname, int32_t maxlen);

include/os/osFile.h

@@ -44,7 +44,7 @@ extern "C" {
 
 typedef struct TdFile *TdFilePtr;
  
-#define TD_FILE_CTEATE    0x0001
+#define TD_FILE_CREATE    0x0001
 #define TD_FILE_WRITE     0x0002
 #define TD_FILE_READ      0x0004
 #define TD_FILE_TRUNC     0x0008
@@ -79,7 +79,7 @@ int64_t taosPReadFile(TdFilePtr pFile, void *buf, int64_t count, int64_t offset)
 int64_t taosWriteFile(TdFilePtr pFile, const void *buf, int64_t count);
 void    taosFprintfFile(TdFilePtr pFile, const char *format, ...);
 
-int64_t taosGetLineFile(TdFilePtr pFile, char ** __restrict__ ptrBuf);
+int64_t taosGetLineFile(TdFilePtr pFile, char ** __restrict ptrBuf);
 
 int32_t taosEOFFile(TdFilePtr pFile);
  

include/os/osSysinfo.h

@@ -39,7 +39,7 @@ int32_t taosGetEmail(char *email, int32_t maxLen);
 int32_t taosGetOsReleaseName(char *releaseName, int32_t maxLen);
 int32_t taosGetCpuInfo(char *cpuModel, int32_t maxLen, float *numOfCores);
 int32_t taosGetCpuCores(float *numOfCores);
-int32_t taosGetCpuUsage(double *cpu_system, double *cpu_engine);
+void    taosGetCpuUsage(double *cpu_system, double *cpu_engine);
 int32_t taosGetTotalMemory(int64_t *totalKB);
 int32_t taosGetProcMemory(int64_t *usedKB);
 int32_t taosGetSysMemory(int64_t *usedKB);

include/os/osSystem.h

@@ -29,6 +29,13 @@ extern "C" {
     #define tcgetattr TCGETATTR_FUNC_TAOS_FORBID
 #endif
 
+typedef struct TdCmd *TdCmdPtr;
+
+TdCmdPtr taosOpenCmd(const char *cmd);
+int64_t taosGetLineCmd(TdCmdPtr pCmd, char ** __restrict ptrBuf);
+int32_t taosEOFCmd(TdCmdPtr pCmd);
+int64_t taosCloseCmd(TdCmdPtr *ppCmd);
+
 void* taosLoadDll(const char* filename);
 void* taosLoadSym(void* handle, char* name);
 void  taosCloseDll(void* handle);

include/os/osTime.h

@@ -27,9 +27,11 @@ extern "C" {
 #ifndef ALLOW_FORBID_FUNC
     #define strptime STRPTIME_FUNC_TAOS_FORBID
     #define gettimeofday GETTIMEOFDAY_FUNC_TAOS_FORBID
+    #define localtime   LOCALTIME_FUNC_TAOS_FORBID
     #define localtime_s LOCALTIMES_FUNC_TAOS_FORBID
     #define localtime_r LOCALTIMER_FUNC_TAOS_FORBID
     #define time TIME_FUNC_TAOS_FORBID
+    #define mktime MKTIME_FUNC_TAOS_FORBID
 #endif
 
 #if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
@@ -82,6 +84,8 @@ static FORCE_INLINE int64_t taosGetTimestampNs() {
 
 char *taosStrpTime(const char *buf, const char *fmt, struct tm *tm);
 struct tm *taosLocalTime(const time_t *timep, struct tm *result);
+time_t taosTime(time_t *t);
+time_t taosMktime(struct tm *timep);
 
 #ifdef __cplusplus
 }

include/util/taoserror.h

@@ -566,8 +566,6 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_AMBIGUOUS_COLUMN          TAOS_DEF_ERROR_CODE(0, 0x2603)
 #define TSDB_CODE_PAR_WRONG_VALUE_TYPE          TAOS_DEF_ERROR_CODE(0, 0x2604)
 #define TSDB_CODE_PAR_INVALID_FUNTION           TAOS_DEF_ERROR_CODE(0, 0x2605)
-#define TSDB_CODE_PAR_FUNTION_PARA_NUM          TAOS_DEF_ERROR_CODE(0, 0x2606)
-#define TSDB_CODE_PAR_FUNTION_PARA_TYPE         TAOS_DEF_ERROR_CODE(0, 0x2607)
 #define TSDB_CODE_PAR_ILLEGAL_USE_AGG_FUNCTION  TAOS_DEF_ERROR_CODE(0, 0x2608)
 #define TSDB_CODE_PAR_WRONG_NUMBER_OF_SELECT    TAOS_DEF_ERROR_CODE(0, 0x2609)
 #define TSDB_CODE_PAR_GROUPBY_LACK_EXPRESSION   TAOS_DEF_ERROR_CODE(0, 0x260A)
@@ -597,10 +595,17 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_INVALID_ROLLUP_OPTION     TAOS_DEF_ERROR_CODE(0, 0x2622)
 #define TSDB_CODE_PAR_INVALID_RETENTIONS_OPTION TAOS_DEF_ERROR_CODE(0, 0x2623)
 #define TSDB_CODE_PAR_GROUPBY_WINDOW_COEXIST    TAOS_DEF_ERROR_CODE(0, 0x2624)
+#define TSDB_CODE_PAR_INVALID_OPTION_UNIT       TAOS_DEF_ERROR_CODE(0, 0x2625)
+#define TSDB_CODE_PAR_INVALID_KEEP_UNIT         TAOS_DEF_ERROR_CODE(0, 0x2626)
 
 //planner
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)
 
+//function
+#define TSDB_CODE_FUNC_FUNTION_ERROR            TAOS_DEF_ERROR_CODE(0, 0x2800)
+#define TSDB_CODE_FUNC_FUNTION_PARA_NUM         TAOS_DEF_ERROR_CODE(0, 0x2801)
+#define TSDB_CODE_FUNC_FUNTION_PARA_TYPE        TAOS_DEF_ERROR_CODE(0, 0x2802)
+
 #ifdef __cplusplus
 }
 #endif

include/util/tdef.h

@@ -94,12 +94,19 @@ extern const int32_t TYPE_BYTES[15];
 #define TSDB_TIME_PRECISION_MICRO_STR "us"
 #define TSDB_TIME_PRECISION_NANO_STR  "ns"
 
+#define TSDB_TIME_PRECISION_SEC_DIGITS   10
+#define TSDB_TIME_PRECISION_MILLI_DIGITS 13
+#define TSDB_TIME_PRECISION_MICRO_DIGITS 16
+#define TSDB_TIME_PRECISION_NANO_DIGITS  19
+
 #define TSDB_INFORMATION_SCHEMA_DB            "information_schema"
+#define TSDB_PERFORMANCE_SCHEMA_DB            "performance_schema"
 #define TSDB_INS_TABLE_DNODES                 "dnodes"
 #define TSDB_INS_TABLE_MNODES                 "mnodes"
 #define TSDB_INS_TABLE_MODULES                "modules"
 #define TSDB_INS_TABLE_QNODES                 "qnodes"
 #define TSDB_INS_TABLE_BNODES                 "bnodes"
+#define TSDB_INS_TABLE_SNODES                 "snodes"
 #define TSDB_INS_TABLE_CLUSTER                "cluster"
 #define TSDB_INS_TABLE_USER_DATABASES         "user_databases"
 #define TSDB_INS_TABLE_USER_FUNCTIONS         "user_functions"
@@ -109,9 +116,17 @@ extern const int32_t TYPE_BYTES[15];
 #define TSDB_INS_TABLE_USER_TABLES            "user_tables"
 #define TSDB_INS_TABLE_USER_TABLE_DISTRIBUTED "user_table_distributed"
 #define TSDB_INS_TABLE_USER_USERS             "user_users"
+#define TSDB_INS_TABLE_LICENCES               "grants"
 #define TSDB_INS_TABLE_VGROUPS                "vgroups"
-#define TSDB_INS_TABLE_BNODES                 "bnodes"
+#define TSDB_INS_TABLE_TOPICS                 "topics"
-#define TSDB_INS_TABLE_SNODES                 "snodes"
+#define TSDB_INS_TABLE_CONSUMERS              "consumers"
+#define TSDB_INS_TABLE_SUBSCRIBES             "subscribes"
+#define TSDB_INS_TABLE_TRANS                  "trans"
+#define TSDB_INS_TABLE_SMAS                   "smas"
+#define TSDB_INS_TABLE_CONFIGS                "configs"
+#define TSDB_INS_TABLE_CONNS                  "connections"
+#define TSDB_INS_TABLE_QUERIES                "queries"
+#define TSDB_INS_TABLE_VNODES                 "vnodes"
 
 #define TSDB_INDEX_TYPE_SMA      "SMA"
 #define TSDB_INDEX_TYPE_FULLTEXT "FULLTEXT"
@@ -491,6 +506,15 @@ enum {
 #define QNODE_HANDLE 1
 #define DEFAULT_HANDLE 0
 
+#define TSDB_CONFIG_OPTION_LEN  16
+#define TSDB_CONIIG_VALUE_LEN   48
+#define TSDB_CONFIG_NUMBER      8
+
+#define QUERY_ID_SIZE      20
+#define QUERY_OBJ_ID_SIZE  18
+#define SUBQUERY_INFO_SIZE 6
+#define QUERY_SAVE_SIZE    20
+
 #define MAX_NUM_STR_SIZE 40
 
 

include/util/tencode.h

@@ -18,7 +18,6 @@
 
 #include "tcoding.h"
 #include "tfreelist.h"
-#include "tmacro.h"
 
 #ifdef __cplusplus
 extern "C" {

include/util/tmacro.h

@@ -1,40 +0,0 @@
-/*
- * 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_UTIL_MACRO_H_
-#define _TD_UTIL_MACRO_H_
-
-#include "os.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Module init/clear MACRO definitions
-#define TD_MOD_UNINITIALIZED 0
-#define TD_MOD_INITIALIZED   1
-
-typedef int8_t td_mode_flag_t;
-
-#define TD_CHECK_AND_SET_MODE_INIT(FLAG) atomic_val_compare_exchange_8((FLAG), TD_MOD_UNINITIALIZED, TD_MOD_INITIALIZED)
-#define TD_CHECK_AND_SET_MOD_CLEAR(FLAG) atomic_val_compare_exchange_8((FLAG), TD_MOD_INITIALIZED, TD_MOD_UNINITIALIZED)
-
-#define TD_IS_NULL(PTR) ((PTR) == NULL)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_UTIL_MACRO_H_*/

include/util/tprocess.h

@@ -22,13 +22,13 @@
 extern "C" {
 #endif
 
-typedef enum { PROC_REQ = 1, PROC_RSP, PROC_REGIST, PROC_RELEASE } ProcFuncType;
+typedef enum { PROC_FUNC_REQ = 1, PROC_FUNC_RSP, PROC_FUNC_REGIST, PROC_FUNC_RELEASE } EProcFuncType;
 
 typedef struct SProcObj SProcObj;
 typedef void *(*ProcMallocFp)(int32_t contLen);
 typedef void *(*ProcFreeFp)(void *pCont);
 typedef void (*ProcConsumeFp)(void *parent, void *pHead, int16_t headLen, void *pBody, int32_t bodyLen,
-                               ProcFuncType ftype);
+                              EProcFuncType ftype);
 
 typedef struct {
   ProcConsumeFp childConsumeFp;
@@ -53,11 +53,11 @@ int32_t   taosProcRun(SProcObj *pProc);
 void      taosProcStop(SProcObj *pProc);
 
 int32_t taosProcPutToChildQ(SProcObj *pProc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen,
-                            void *handle, ProcFuncType ftype);
+                            void *handle, EProcFuncType ftype);
 void    taosProcRemoveHandle(SProcObj *pProc, void *handle);
 void    taosProcCloseHandles(SProcObj *pProc, void (*HandleFp)(void *handle));
 void    taosProcPutToParentQ(SProcObj *pProc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen,
-                             ProcFuncType ftype);
+                             EProcFuncType ftype);
 
 #ifdef __cplusplus
 }

packaging/install.sh

@@ -157,7 +157,7 @@ function install_main_path() {
     ${csudo} mkdir -p ${install_main_dir}/cfg
     ${csudo} mkdir -p ${install_main_dir}/bin
     ${csudo} mkdir -p ${install_main_dir}/connector
-    ${csudo} mkdir -p ${install_main_dir}/driver
+    ${csudo} mkdir -p ${install_main_dir}/lib
     ${csudo} mkdir -p ${install_main_dir}/examples
     ${csudo} mkdir -p ${install_main_dir}/include
     ${csudo} mkdir -p ${install_main_dir}/init.d
@@ -198,6 +198,10 @@ function install_lib() {
     # Remove links
     ${csudo} rm -f ${lib_link_dir}/libtaos.*         || :
     ${csudo} rm -f ${lib64_link_dir}/libtaos.*       || :
+    ${csudo} rm -f ${lib_link_dir}/libtdb.*         || :
+    ${csudo} rm -f ${lib64_link_dir}/libtdb.*       || :
+
+    ${csudo} cp -rf ${script_dir}/lib/* ${install_main_dir}/lib && ${csudo} chmod 777 ${install_main_dir}/lib/*
 
     ${csudo} ln -s ${install_main_dir}/lib/libtaos.* ${lib_link_dir}/libtaos.so.1
     ${csudo} ln -s ${lib_link_dir}/libtaos.so.1 ${lib_link_dir}/libtaos.so
@@ -224,6 +228,12 @@ function install_header() {
     ${csudo} ln -s ${install_main_dir}/include/taoserror.h ${inc_link_dir}/taoserror.h
 }
 
+# temp install taosBenchmark
+function install_taosTools() {
+    cd ${script_dir}/taos-tools/
+    tar xvf taosTools-1.4.1-Linux-x64.tar.gz && cd  taosTools-1.4.1/ && ./install-taostools.sh
+}
+
 function add_newHostname_to_hosts() {
   localIp="127.0.0.1"
   OLD_IFS="$IFS"
@@ -450,14 +460,14 @@ function install_service_on_systemd() {
 }
 
 function install_service() {
-    if ((${service_mod}==0)); then
+    # if ((${service_mod}==0)); then
-        install_service_on_systemd
+    #     install_service_on_systemd
-    elif ((${service_mod}==1)); then
+    # elif ((${service_mod}==1)); then
-        install_service_on_sysvinit
+    #     install_service_on_sysvinit
-    else
+    # else
-        # must manual stop taosd
+    #     # must manual stop taosd
         kill_process taosd
-    fi
+    # fi
 }
 
 function install_TDengine() {
@@ -469,6 +479,7 @@ function install_TDengine() {
     install_log
     install_header
     install_lib
+    install_taosTools
 
     if [ -z $1 ]; then # install service and client
         # For installing new

packaging/release.sh

@@ -55,6 +55,7 @@ mkdir -p ${install_dir}
 mkdir -p ${install_dir}/bin
 mkdir -p ${install_dir}/lib
 mkdir -p ${install_dir}/inc
+mkdir -p ${install_dir}/taos-tools
 
 install_files="${script_dir}/install.sh"
 chmod a+x ${script_dir}/install.sh || :
@@ -68,6 +69,8 @@ cp ${bin_files} ${install_dir}/bin && chmod a+x ${install_dir}/bin/* || :
 
 cp ${compile_dir}/source/client/libtaos.so  ${install_dir}/lib/
 cp ${compile_dir}/source/libs/tdb/libtdb.so ${install_dir}/lib/
+taostoolfile="${top_dir}/tools/taosTools-1.4.1-Linux-x64.tar.gz"
+cp ${taostoolfile} ${install_dir}/taos-tools 
 
 #cp ${compile_dir}/source/dnode/mnode/impl/libmnode.so ${install_dir}/lib/
 #cp ${compile_dir}/source/dnode/qnode/libqnode.so ${install_dir}/lib/

source/client/inc/clientInt.h

@@ -45,6 +45,11 @@ extern "C" {
 
 #define HEARTBEAT_INTERVAL 1500  // ms
 
+enum {
+  CONN_TYPE__QUERY = 1,
+  CONN_TYPE__TMQ,
+};
+
 typedef struct SAppInstInfo SAppInstInfo;
 
 typedef struct {
@@ -84,10 +89,10 @@ typedef struct {
 } SClientHbMgr;
 
 typedef struct SQueryExecMetric {
-  int64_t start;   // start timestamp
+  int64_t start;   // start timestamp, us
-  int64_t parsed;  // start to parse
+  int64_t parsed;  // start to parse, us
-  int64_t send;    // start to send to server
+  int64_t send;    // start to send to server, us
-  int64_t rsp;     // receive response from server
+  int64_t rsp;     // receive response from server, us
 } SQueryExecMetric;
 
 typedef struct SInstanceSummary {
@@ -132,9 +137,9 @@ typedef struct STscObj {
   char          pass[TSDB_PASSWORD_LEN];
   char          db[TSDB_DB_FNAME_LEN];
   char          ver[128];
+  int8_t        connType;
   int32_t       acctId;
   uint32_t      connId;
-  int32_t         connType;
   uint64_t      id;         // ref ID returned by taosAddRef
   TdThreadMutex mutex;      // used to protect the operation on db
   int32_t       numOfReqs;  // number of sqlObj bound to this connection
@@ -186,7 +191,24 @@ typedef struct SRequestSendRecvBody {
 
 #define ERROR_MSG_BUF_DEFAULT_SIZE 512
 
+enum {
+  RES_TYPE__QUERY = 1,
+  RES_TYPE__TMQ,
+};
+
+#define TD_RES_QUERY(res) (*(int8_t*)res == RES_TYPE__QUERY)
+#define TD_RES_TMQ(res)   (*(int8_t*)res == RES_TYPE__TMQ)
+
+typedef struct {
+  int8_t  resType;
+  char*   topic;
+  SArray* res;  // SArray<SReqResultInfo>
+  int32_t resIter;
+  int32_t vgId;
+} SMqRspObj;
+
 typedef struct SRequestObj {
+  int8_t               resType;  // query or tmq
   uint64_t             requestId;
   int32_t              type;  // request type
   STscObj*             pTscObj;
@@ -203,6 +225,25 @@ typedef struct SRequestObj {
   SRequestSendRecvBody body;
 } SRequestObj;
 
+static FORCE_INLINE SReqResultInfo* tmqGetCurResInfo(TAOS_RES* res) {
+  SMqRspObj* msg = (SMqRspObj*)res;
+  int32_t    resIter = msg->resIter == -1 ? 0 : msg->resIter;
+  return (SReqResultInfo*)taosArrayGet(msg->res, resIter);
+}
+
+static FORCE_INLINE SReqResultInfo* tmqGetNextResInfo(TAOS_RES* res) {
+  SMqRspObj* msg = (SMqRspObj*)res;
+  if (++msg->resIter < taosArrayGetSize(msg->res)) {
+    return (SReqResultInfo*)taosArrayGet(msg->res, msg->resIter);
+  }
+  return NULL;
+}
+
+static FORCE_INLINE SReqResultInfo* tscGetCurResInfo(TAOS_RES* res) {
+  if (TD_RES_QUERY(res)) return &(((SRequestObj*)res)->body.resInfo);
+  return tmqGetCurResInfo(res);
+}
+
 extern SAppInfo appInfo;
 extern int32_t  clientReqRefPool;
 extern int32_t  clientConnRefPool;
@@ -236,17 +277,20 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet);
 void initMsgHandleFp();
 
 TAOS* taos_connect_internal(const char* ip, const char* user, const char* pass, const char* auth, const char* db,
-                            uint16_t port);
+                            uint16_t port, int connType);
-
-void* doFetchRow(SRequestObj* pRequest, bool setupOneRowPtr);
-
-int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows);
-
-int32_t buildRequest(STscObj* pTscObj, const char* sql, int sqlLen, SRequestObj** pRequest);
 
 int32_t parseSql(SRequestObj* pRequest, bool topicQuery, SQuery** pQuery);
 int32_t getPlan(SRequestObj* pRequest, SQuery* pQuery, SQueryPlan** pPlan, SArray* pNodeList);
 
+int32_t buildRequest(STscObj* pTscObj, const char* sql, int sqlLen, SRequestObj** pRequest);
+
+void*   doFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertUcs4);
+void    doSetOneRowPtr(SReqResultInfo* pResultInfo);
+int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows,
+                         bool convertUcs4);
+void    setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t numOfCols);
+int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp, bool convertUcs4);
+
 // --- heartbeat
 // global, called by mgmt
 int  hbMgrInit();

source/client/src/clientEnv.c

@@ -65,10 +65,10 @@ static void deregisterRequest(SRequestObj *pRequest) {
   int32_t currentInst = atomic_sub_fetch_64(&pActivity->currentRequests, 1);
   int32_t num = atomic_sub_fetch_32(&pTscObj->numOfReqs, 1);
 
-  int64_t duration = taosGetTimestampMs() - pRequest->metric.start;
+  int64_t duration = taosGetTimestampUs() - pRequest->metric.start;
   tscDebug("0x%" PRIx64 " free Request from connObj: 0x%" PRIx64 ", reqId:0x%" PRIx64 " elapsed:%" PRIu64
            " ms, current:%d, app current:%d",
-           pRequest->self, pTscObj->id, pRequest->requestId, duration, num, currentInst);
+           pRequest->self, pTscObj->id, pRequest->requestId, duration/1000, num, currentInst);
   taosReleaseRef(clientConnRefPool, pTscObj->id);
 }
 
@@ -149,9 +149,10 @@ void *createRequest(STscObj *pObj, __taos_async_fn_t fp, void *param, int32_t ty
     return NULL;
   }
 
+  pRequest->resType = RES_TYPE__QUERY;
   pRequest->pDb = getDbOfConnection(pObj);
   pRequest->requestId = generateRequestId();
-  pRequest->metric.start = taosGetTimestampMs();
+  pRequest->metric.start = taosGetTimestampUs();
 
   pRequest->type = type;
   pRequest->pTscObj = pObj;

source/client/src/clientHb.c

@@ -23,6 +23,8 @@ static SClientHbMgr clientHbMgr = {0};
 static int32_t hbCreateThread();
 static void    hbStopThread();
 
+static int32_t hbMqHbReqHandle(SClientHbKey *connKey, void *param, SClientHbReq *req) { return 0; }
+
 static int32_t hbMqHbRspHandle(SAppHbMgr *pAppHbMgr, SClientHbRsp *pRsp) { return 0; }
 
 static int32_t hbProcessDBInfoRsp(void *value, int32_t valueLen, struct SCatalog *pCatalog) {
@@ -297,11 +299,10 @@ int32_t hbQueryHbReqHandle(SClientHbKey *connKey, void *param, SClientHbReq *req
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t hbMqHbReqHandle(SClientHbKey *connKey, void *param, SClientHbReq *req) { return 0; }
-
 void hbMgrInitMqHbHandle() {
   clientHbMgr.reqHandle[HEARTBEAT_TYPE_QUERY] = hbQueryHbReqHandle;
   clientHbMgr.reqHandle[HEARTBEAT_TYPE_MQ] = hbMqHbReqHandle;
+
   clientHbMgr.rspHandle[HEARTBEAT_TYPE_QUERY] = hbQueryHbRspHandle;
   clientHbMgr.rspHandle[HEARTBEAT_TYPE_MQ] = hbMqHbRspHandle;
 }
@@ -435,11 +436,11 @@ static int32_t hbCreateThread() {
   taosThreadAttrInit(&thAttr);
   taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
 
-//  if (taosThreadCreate(&clientHbMgr.thread, &thAttr, hbThreadFunc, NULL) != 0) {
+  if (taosThreadCreate(&clientHbMgr.thread, &thAttr, hbThreadFunc, NULL) != 0) {
-//    terrno = TAOS_SYSTEM_ERROR(errno);
+    terrno = TAOS_SYSTEM_ERROR(errno);
-//    return -1;
+    return -1;
-//  }
+  }
-//  taosThreadAttrDestroy(&thAttr);
+  taosThreadAttrDestroy(&thAttr);
   return 0;
 }
 
@@ -500,8 +501,6 @@ SAppHbMgr *appHbMgrInit(SAppInstInfo *pAppInstInfo, char *key) {
 }
 
 void appHbMgrCleanup(void) {
-  taosThreadMutexLock(&clientHbMgr.lock);
-
   int sz = taosArrayGetSize(clientHbMgr.appHbMgrs);
   for (int i = 0; i < sz; i++) {
     SAppHbMgr *pTarget = taosArrayGetP(clientHbMgr.appHbMgrs, i);
@@ -510,8 +509,6 @@ void appHbMgrCleanup(void) {
     taosHashCleanup(pTarget->connInfo);
     pTarget->connInfo = NULL;
   }
-
-  taosThreadMutexUnlock(&clientHbMgr.lock);
 }
 
 int hbMgrInit() {
@@ -532,7 +529,6 @@ int hbMgrInit() {
 }
 
 void hbMgrCleanUp() {
-#if 0
   hbStopThread();
 
   // destroy all appHbMgr
@@ -545,7 +541,6 @@ void hbMgrCleanUp() {
   taosThreadMutexUnlock(&clientHbMgr.lock);
 
   clientHbMgr.appHbMgrs = NULL;
-#endif
 }
 
 int hbRegisterConnImpl(SAppHbMgr *pAppHbMgr, SClientHbKey connKey, SHbConnInfo *info) {
@@ -574,7 +569,7 @@ int hbRegisterConnImpl(SAppHbMgr *pAppHbMgr, SClientHbKey connKey, SHbConnInfo *
 int hbRegisterConn(SAppHbMgr *pAppHbMgr, int32_t connId, int64_t clusterId, int32_t hbType) {
   SClientHbKey connKey = {
       .connId = connId,
-      .hbType = HEARTBEAT_TYPE_QUERY,
+      .hbType = hbType,
   };
   SHbConnInfo info = {0};
 
@@ -584,16 +579,14 @@ int hbRegisterConn(SAppHbMgr *pAppHbMgr, int32_t connId, int64_t clusterId, int3
       *pClusterId = clusterId;
 
       info.param = pClusterId;
-      break;
+      return hbRegisterConnImpl(pAppHbMgr, connKey, &info);
     }
     case HEARTBEAT_TYPE_MQ: {
-      break;
+      return 0;
     }
     default:
-      break;
+      return 0;
   }
-
-  return hbRegisterConnImpl(pAppHbMgr, connKey, &info);
 }
 
 void hbDeregisterConn(SAppHbMgr *pAppHbMgr, SClientHbKey connKey) {

source/client/src/clientImpl.c

@@ -11,9 +11,8 @@
 #include "tref.h"
 
 static int32_t       initEpSetFromCfg(const char* firstEp, const char* secondEp, SCorEpSet* pEpSet);
-static SMsgSendInfo* buildConnectMsg(SRequestObj* pRequest);
+static SMsgSendInfo* buildConnectMsg(SRequestObj* pRequest, int8_t connType);
 static void          destroySendMsgInfo(SMsgSendInfo* pMsgBody);
-static int32_t       setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp);
 
 static bool stringLengthCheck(const char* str, size_t maxsize) {
   if (str == NULL) {
@@ -41,11 +40,10 @@ static char* getClusterKey(const char* user, const char* auth, const char* ip, i
 }
 
 static STscObj* taosConnectImpl(const char* user, const char* auth, const char* db, __taos_async_fn_t fp, void* param,
-                                SAppInstInfo* pAppInfo);
+                                SAppInstInfo* pAppInfo, int connType);
-static void     setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t numOfCols);
 
 TAOS* taos_connect_internal(const char* ip, const char* user, const char* pass, const char* auth, const char* db,
-                            uint16_t port) {
+                            uint16_t port, int connType) {
   if (taos_init() != TSDB_CODE_SUCCESS) {
     return NULL;
   }
@@ -113,7 +111,7 @@ TAOS* taos_connect_internal(const char* ip, const char* user, const char* pass,
   taosThreadMutexUnlock(&appInfo.mutex);
 
   taosMemoryFreeClear(key);
-  return taosConnectImpl(user, &secretEncrypt[0], localDb, NULL, NULL, *pInst);
+  return taosConnectImpl(user, &secretEncrypt[0], localDb, NULL, NULL, *pInst, connType);
 }
 
 int32_t buildRequest(STscObj* pTscObj, const char* sql, int sqlLen, SRequestObj** pRequest) {
@@ -176,7 +174,7 @@ int32_t execLocalCmd(SRequestObj* pRequest, SQuery* pQuery) {
   SRetrieveTableRsp* pRsp = NULL;
   int32_t            code = qExecCommand(pQuery->pRoot, &pRsp);
   if (TSDB_CODE_SUCCESS == code && NULL != pRsp) {
-    code = setQueryResultFromRsp(&pRequest->body.resInfo, pRsp);
+    code = setQueryResultFromRsp(&pRequest->body.resInfo, pRsp, false);
   }
   return code;
 }
@@ -195,13 +193,6 @@ int32_t execDdlQuery(SRequestObj* pRequest, SQuery* pQuery) {
   STscObj*      pTscObj = pRequest->pTscObj;
   SMsgSendInfo* pSendMsg = buildMsgInfoImpl(pRequest);
 
-  if (pMsgInfo->msgType == TDMT_VND_SHOW_TABLES) {
-    SShowReqInfo* pShowReqInfo = &pRequest->body.showInfo;
-    if (pShowReqInfo->pArray == NULL) {
-      pShowReqInfo->currentIndex = 0;  // set the first vnode/ then iterate the next vnode
-      pShowReqInfo->pArray = pMsgInfo->pExtension;
-    }
-  }
   int64_t transporterId = 0;
   asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &pMsgInfo->epSet, &transporterId, pSendMsg);
 
@@ -211,13 +202,11 @@ int32_t execDdlQuery(SRequestObj* pRequest, SQuery* pQuery) {
 
 int32_t getPlan(SRequestObj* pRequest, SQuery* pQuery, SQueryPlan** pPlan, SArray* pNodeList) {
   pRequest->type = pQuery->msgType;
-  SPlanContext cxt = {
+  SPlanContext cxt = {.queryId = pRequest->requestId,
-    .queryId = pRequest->requestId,
                       .acctId = pRequest->pTscObj->acctId,
                       .mgmtEpSet = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp),
                       .pAstRoot = pQuery->pRoot,
-    .showRewrite = pQuery->showRewrite
+                      .showRewrite = pQuery->showRewrite};
-  };
   int32_t      code = qCreateQueryPlan(&cxt, pPlan, pNodeList);
   if (code != 0) {
     return code;
@@ -254,7 +243,8 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList
   void* pTransporter = pRequest->pTscObj->pAppInfo->pTransporter;
 
   SQueryResult res = {.code = 0, .numOfRows = 0, .msgSize = ERROR_MSG_BUF_DEFAULT_SIZE, .msg = pRequest->msgBuf};
-  int32_t      code = schedulerExecJob(pTransporter, pNodeList, pDag, &pRequest->body.queryJob, pRequest->sqlstr, pRequest->metric.start, &res);
+  int32_t      code = schedulerExecJob(pTransporter, pNodeList, pDag, &pRequest->body.queryJob, pRequest->sqlstr,
+                                       pRequest->metric.start, &res);
   if (code != TSDB_CODE_SUCCESS) {
     if (pRequest->body.queryJob != 0) {
       schedulerFreeJob(pRequest->body.queryJob);
@@ -357,7 +347,6 @@ int32_t refreshMeta(STscObj* pTscObj, SRequestObj* pRequest) {
   return code;
 }
 
-
 SRequestObj* execQuery(STscObj* pTscObj, const char* sql, int sqlLen) {
   SRequestObj* pRequest = NULL;
   int32_t      retryNum = 0;
@@ -429,7 +418,7 @@ int initEpSetFromCfg(const char* firstEp, const char* secondEp, SCorEpSet* pEpSe
 }
 
 STscObj* taosConnectImpl(const char* user, const char* auth, const char* db, __taos_async_fn_t fp, void* param,
-                         SAppInstInfo* pAppInfo) {
+                         SAppInstInfo* pAppInfo, int connType) {
   STscObj* pTscObj = createTscObj(user, auth, db, pAppInfo);
   if (NULL == pTscObj) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -443,7 +432,7 @@ STscObj* taosConnectImpl(const char* user, const char* auth, const char* db, __t
     return NULL;
   }
 
-  SMsgSendInfo* body = buildConnectMsg(pRequest);
+  SMsgSendInfo* body = buildConnectMsg(pRequest, connType);
 
   int64_t transporterId = 0;
   asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &pTscObj->pAppInfo->mgmtEp.epSet, &transporterId, body);
@@ -466,7 +455,7 @@ STscObj* taosConnectImpl(const char* user, const char* auth, const char* db, __t
   return pTscObj;
 }
 
-static SMsgSendInfo* buildConnectMsg(SRequestObj* pRequest) {
+static SMsgSendInfo* buildConnectMsg(SRequestObj* pRequest, int8_t connType) {
   SMsgSendInfo* pMsgSendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
   if (pMsgSendInfo == NULL) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -489,6 +478,7 @@ static SMsgSendInfo* buildConnectMsg(SRequestObj* pRequest) {
   }
   taosMemoryFreeClear(db);
 
+  connectReq.connType = connType;
   connectReq.pid = htonl(appInfo.pid);
   connectReq.startTime = htobe64(appInfo.startTime);
   tstrncpy(connectReq.app, appInfo.appName, sizeof(connectReq.app));
@@ -509,7 +499,8 @@ static void destroySendMsgInfo(SMsgSendInfo* pMsgBody) {
 }
 
 bool persistConnForSpecificMsg(void* parenct, tmsg_t msgType) {
-  return msgType == TDMT_VND_QUERY_RSP || msgType == TDMT_VND_FETCH_RSP || msgType == TDMT_VND_RES_READY_RSP || msgType == TDMT_VND_QUERY_HEARTBEAT_RSP;
+  return msgType == TDMT_VND_QUERY_RSP || msgType == TDMT_VND_FETCH_RSP || msgType == TDMT_VND_RES_READY_RSP ||
+         msgType == TDMT_VND_QUERY_HEARTBEAT_RSP;
 }
 
 void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
@@ -520,7 +511,7 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
     SRequestObj* pRequest = (SRequestObj*)taosAcquireRef(clientReqRefPool, pSendInfo->requestObjRefId);
     assert(pRequest->self == pSendInfo->requestObjRefId);
 
-    pRequest->metric.rsp = taosGetTimestampMs();
+    pRequest->metric.rsp = taosGetTimestampUs();
 
     STscObj* pTscObj = pRequest->pTscObj;
     if (pEpSet) {
@@ -536,10 +527,10 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
     int32_t elapsed = pRequest->metric.rsp - pRequest->metric.start;
     if (pMsg->code == TSDB_CODE_SUCCESS) {
       tscDebug("0x%" PRIx64 " message:%s, code:%s rspLen:%d, elapsed:%d ms, reqId:0x%" PRIx64, pRequest->self,
-               TMSG_INFO(pMsg->msgType), tstrerror(pMsg->code), pMsg->contLen, elapsed, pRequest->requestId);
+               TMSG_INFO(pMsg->msgType), tstrerror(pMsg->code), pMsg->contLen, elapsed / 1000, pRequest->requestId);
     } else {
       tscError("0x%" PRIx64 " SQL cmd:%s, code:%s rspLen:%d, elapsed time:%d ms, reqId:0x%" PRIx64, pRequest->self,
-               TMSG_INFO(pMsg->msgType), tstrerror(pMsg->code), pMsg->contLen, elapsed, pRequest->requestId);
+               TMSG_INFO(pMsg->msgType), tstrerror(pMsg->code), pMsg->contLen, elapsed / 1000, pRequest->requestId);
     }
 
     taosReleaseRef(clientReqRefPool, pSendInfo->requestObjRefId);
@@ -573,7 +564,7 @@ TAOS* taos_connect_auth(const char* ip, const char* user, const char* auth, cons
     return NULL;
   }
 
-  return taos_connect_internal(ip, user, NULL, auth, db, port);
+  return taos_connect_internal(ip, user, NULL, auth, db, port, CONN_TYPE__QUERY);
 }
 
 TAOS* taos_connect_l(const char* ip, int ipLen, const char* user, int userLen, const char* pass, int passLen,
@@ -590,7 +581,7 @@ TAOS* taos_connect_l(const char* ip, int ipLen, const char* user, int userLen, c
   return taos_connect(ipStr, userStr, passStr, dbStr, port);
 }
 
-static void doSetOneRowPtr(SReqResultInfo* pResultInfo) {
+void doSetOneRowPtr(SReqResultInfo* pResultInfo) {
   for (int32_t i = 0; i < pResultInfo->numOfCols; ++i) {
     SResultColumn* pCol = &pResultInfo->pCol[i];
 
@@ -605,25 +596,25 @@ static void doSetOneRowPtr(SReqResultInfo* pResultInfo) {
         pResultInfo->row[i] = varDataVal(pStart);
       } else {
         pResultInfo->row[i] = NULL;
+        pResultInfo->length[i] = 0;
       }
     } else {
       if (!colDataIsNull_f(pCol->nullbitmap, pResultInfo->current)) {
         pResultInfo->row[i] = pResultInfo->pCol[i].pData + bytes * pResultInfo->current;
+        pResultInfo->length[i] = bytes;
       } else {
         pResultInfo->row[i] = NULL;
+        pResultInfo->length[i] = 0;
       }
     }
   }
 }
 
-void* doFetchRow(SRequestObj* pRequest, bool setupOneRowPtr) {
+void* doFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertUcs4) {
   assert(pRequest != NULL);
+
   SReqResultInfo* pResultInfo = &pRequest->body.resInfo;
-
-  SEpSet epSet = {0};
-
   if (pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) {
-    if (pRequest->type == TDMT_VND_QUERY) {
     // All data has returned to App already, no need to try again
     if (pResultInfo->completed) {
       pResultInfo->numOfRows = 0;
@@ -637,7 +628,7 @@ void* doFetchRow(SRequestObj* pRequest, bool setupOneRowPtr) {
       return NULL;
     }
 
-      pRequest->code = setQueryResultFromRsp(&pRequest->body.resInfo, (SRetrieveTableRsp*)pResInfo->pData);
+    pRequest->code = setQueryResultFromRsp(&pRequest->body.resInfo, (SRetrieveTableRsp*)pResInfo->pData, convertUcs4);
     if (pRequest->code != TSDB_CODE_SUCCESS) {
       pResultInfo->numOfRows = 0;
       return NULL;
@@ -649,69 +640,8 @@ void* doFetchRow(SRequestObj* pRequest, bool setupOneRowPtr) {
     if (pResultInfo->numOfRows == 0) {
       return NULL;
     }
-
-      goto _return;
-    } else if (pRequest->type == TDMT_MND_SHOW) {
-      pRequest->type = TDMT_MND_SHOW_RETRIEVE;
-      epSet = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp);
-    } else if (pRequest->type == TDMT_VND_SHOW_TABLES) {
-      pRequest->type = TDMT_VND_SHOW_TABLES_FETCH;
-      SShowReqInfo* pShowReqInfo = &pRequest->body.showInfo;
-      SVgroupInfo*  pVgroupInfo = taosArrayGet(pShowReqInfo->pArray, pShowReqInfo->currentIndex);
-
-      epSet = pVgroupInfo->epSet;
-    } else if (pRequest->type == TDMT_VND_SHOW_TABLES_FETCH) {
-      pRequest->type = TDMT_VND_SHOW_TABLES;
-      SShowReqInfo* pShowReqInfo = &pRequest->body.showInfo;
-      pShowReqInfo->currentIndex += 1;
-      if (pShowReqInfo->currentIndex >= taosArrayGetSize(pShowReqInfo->pArray)) {
-        return NULL;
   }
 
-      SVgroupInfo*     pVgroupInfo = taosArrayGet(pShowReqInfo->pArray, pShowReqInfo->currentIndex);
-      SVShowTablesReq* pShowReq = taosMemoryCalloc(1, sizeof(SVShowTablesReq));
-      pShowReq->head.vgId = htonl(pVgroupInfo->vgId);
-
-      pRequest->body.requestMsg.len = sizeof(SVShowTablesReq);
-      pRequest->body.requestMsg.pData = pShowReq;
-
-      SMsgSendInfo* body = buildMsgInfoImpl(pRequest);
-      epSet = pVgroupInfo->epSet;
-
-      int64_t  transporterId = 0;
-      STscObj* pTscObj = pRequest->pTscObj;
-      asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &epSet, &transporterId, body);
-      tsem_wait(&pRequest->body.rspSem);
-
-      pRequest->type = TDMT_VND_SHOW_TABLES_FETCH;
-    } else if (pRequest->type == TDMT_MND_SHOW_RETRIEVE) {
-      epSet = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp);
-
-      if (pResultInfo->completed) {
-        return NULL;
-      }
-    }
-
-    if (pResultInfo->completed) {
-      pResultInfo->numOfRows = 0;
-      return NULL;
-    }
-
-    SMsgSendInfo* body = buildMsgInfoImpl(pRequest);
-
-    int64_t  transporterId = 0;
-    STscObj* pTscObj = pRequest->pTscObj;
-    asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &epSet, &transporterId, body);
-
-    tsem_wait(&pRequest->body.rspSem);
-
-    pResultInfo->current = 0;
-    if (pResultInfo->numOfRows <= pResultInfo->current) {
-      return NULL;
-    }
-  }
-
-_return:
   if (setupOneRowPtr) {
     doSetOneRowPtr(pResultInfo);
     pResultInfo->current += 1;
@@ -735,7 +665,43 @@ static int32_t doPrepareResPtr(SReqResultInfo* pResInfo) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows) {
+static int32_t doConvertUCS4(SReqResultInfo* pResultInfo, int32_t numOfRows, int32_t numOfCols, int32_t* colLength) {
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    int32_t type = pResultInfo->fields[i].type;
+    int32_t bytes = pResultInfo->fields[i].bytes;
+
+    if (type == TSDB_DATA_TYPE_NCHAR && colLength[i] > 0) {
+      char* p = taosMemoryRealloc(pResultInfo->convertBuf[i], colLength[i]);
+      if (p == NULL) {
+        return TSDB_CODE_OUT_OF_MEMORY;
+      }
+
+      pResultInfo->convertBuf[i] = p;
+
+      SResultColumn* pCol = &pResultInfo->pCol[i];
+      for (int32_t j = 0; j < numOfRows; ++j) {
+        if (pCol->offset[j] != -1) {
+          char* pStart = pCol->offset[j] + pCol->pData;
+
+          int32_t len = taosUcs4ToMbs((TdUcs4*)varDataVal(pStart), varDataLen(pStart), varDataVal(p));
+          ASSERT(len <= bytes);
+
+          varDataSetLen(p, len);
+          pCol->offset[j] = (p - pResultInfo->convertBuf[i]);
+          p += (len + VARSTR_HEADER_SIZE);
+        }
+      }
+
+      pResultInfo->pCol[i].pData = pResultInfo->convertBuf[i];
+      pResultInfo->row[i] = pResultInfo->pCol[i].pData;
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows,
+                         bool convertUcs4) {
   assert(numOfCols > 0 && pFields != NULL && pResultInfo != NULL);
   if (numOfRows == 0) {
     return TSDB_CODE_SUCCESS;
@@ -767,37 +733,11 @@ int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32
   }
 
   // convert UCS4-LE encoded character to native multi-bytes character in current data block.
-  for (int32_t i = 0; i < numOfCols; ++i) {
+  if (convertUcs4) {
-    int32_t type = pResultInfo->fields[i].type;
+    code = doConvertUCS4(pResultInfo, numOfRows, numOfCols, colLength);
-    int32_t bytes = pResultInfo->fields[i].bytes;
-
-    if (type == TSDB_DATA_TYPE_NCHAR) {
-      char* p = taosMemoryRealloc(pResultInfo->convertBuf[i], colLength[i]);
-      if (p == NULL) {
-        return TSDB_CODE_OUT_OF_MEMORY;
-      }
-      pResultInfo->convertBuf[i] = p;
-
-      SResultColumn* pCol = &pResultInfo->pCol[i];
-      for (int32_t j = 0; j < numOfRows; ++j) {
-        if (pCol->offset[j] != -1) {
-          pStart = pCol->offset[j] + pCol->pData;
-
-          int32_t len = taosUcs4ToMbs((TdUcs4*)varDataVal(pStart), varDataLen(pStart), varDataVal(p));
-          ASSERT(len <= bytes);
-
-          varDataSetLen(p, len);
-          pCol->offset[j] = (p - pResultInfo->convertBuf[i]);
-          p += (len + VARSTR_HEADER_SIZE);
-        }
   }
 
-      pResultInfo->pCol[i].pData = pResultInfo->convertBuf[i];
+  return code;
-      pResultInfo->row[i] = pResultInfo->pCol[i].pData;
-    }
-  }
-
-  return TSDB_CODE_SUCCESS;
 }
 
 char* getDbOfConnection(STscObj* pObj) {
@@ -829,7 +769,7 @@ void resetConnectDB(STscObj* pTscObj) {
   taosThreadMutexUnlock(&pTscObj->mutex);
 }
 
-int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp) {
+int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp, bool convertUcs4) {
   assert(pResultInfo != NULL && pRsp != NULL);
 
   pResultInfo->pRspMsg = (const char*)pRsp;
@@ -842,5 +782,6 @@ int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableR
 
   // TODO handle the compressed case
   pResultInfo->totalRows += pResultInfo->numOfRows;
-  return setResultDataPtr(pResultInfo, pResultInfo->fields, pResultInfo->numOfCols, pResultInfo->numOfRows);
+  return setResultDataPtr(pResultInfo, pResultInfo->fields, pResultInfo->numOfCols, pResultInfo->numOfRows,
+                          convertUcs4);
 }

source/client/src/clientMain.c

@@ -87,7 +87,7 @@ TAOS *taos_connect(const char *ip, const char *user, const char *pass, const cha
     pass = TSDB_DEFAULT_PASS;
   }
 
-  return taos_connect_internal(ip, user, pass, NULL, db, port);
+  return taos_connect_internal(ip, user, pass, NULL, db, port, CONN_TYPE__QUERY);
 }
 
 void taos_close(TAOS *taos) {
@@ -124,17 +124,18 @@ const char *taos_errstr(TAOS_RES *res) {
 }
 
 void taos_free_result(TAOS_RES *res) {
+  if (TD_RES_QUERY(res)) {
     SRequestObj *pRequest = (SRequestObj *)res;
     destroyRequest(pRequest);
   }
+}
 
 int taos_field_count(TAOS_RES *res) {
   if (res == NULL) {
     return 0;
   }
 
-  SRequestObj    *pRequest = (SRequestObj *)res;
+  SReqResultInfo *pResInfo = tscGetCurResInfo(res);
-  SReqResultInfo *pResInfo = &pRequest->body.resInfo;
   return pResInfo->numOfCols;
 }
 
@@ -145,7 +146,7 @@ TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
     return NULL;
   }
 
-  SReqResultInfo *pResInfo = &(((SRequestObj *)res)->body.resInfo);
+  SReqResultInfo *pResInfo = tscGetCurResInfo(res);
   return pResInfo->userFields;
 }
 
@@ -162,13 +163,40 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
     return NULL;
   }
 
+  if (TD_RES_QUERY(res)) {
     SRequestObj *pRequest = (SRequestObj *)res;
     if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT || pRequest->type == TSDB_SQL_INSERT ||
         pRequest->code != TSDB_CODE_SUCCESS || taos_num_fields(res) == 0) {
       return NULL;
     }
 
-  return doFetchRow(pRequest, true);
+    return doFetchRows(pRequest, true, true);
+
+  } else if (TD_RES_TMQ(res)) {
+    SMqRspObj *msg = ((SMqRspObj *)res);
+    if (msg->resIter == -1) msg->resIter++;
+    SReqResultInfo *pResultInfo = taosArrayGet(msg->res, msg->resIter);
+    if (pResultInfo->current < pResultInfo->numOfRows) {
+      doSetOneRowPtr(pResultInfo);
+      pResultInfo->current += 1;
+      return pResultInfo->row;
+    } else {
+      msg->resIter++;
+      if (msg->resIter < taosArrayGetSize(msg->res)) {
+        pResultInfo = taosArrayGet(msg->res, msg->resIter);
+        doSetOneRowPtr(pResultInfo);
+        pResultInfo->current += 1;
+        return pResultInfo->row;
+      } else {
+        return NULL;
+      }
+    }
+
+  } else {
+    // assert to avoid uninitialization error
+    ASSERT(0);
+  }
+  return NULL;
 }
 
 int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) {
@@ -260,12 +288,12 @@ int *taos_fetch_lengths(TAOS_RES *res) {
     return NULL;
   }
 
-  return ((SRequestObj *)res)->body.resInfo.length;
+  SReqResultInfo *pResInfo = tscGetCurResInfo(res);
+  return pResInfo->length;
 }
 
 TAOS_ROW *taos_result_block(TAOS_RES *res) {
-  SRequestObj* pRequest = (SRequestObj*) res;
+  if (res == NULL) {
-  if (pRequest == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return NULL;
   }
@@ -274,7 +302,8 @@ TAOS_ROW *taos_result_block(TAOS_RES *res) {
     return NULL;
   }
 
-  return &pRequest->body.resInfo.row;
+  SReqResultInfo *pResInfo = tscGetCurResInfo(res);
+  return &pResInfo->row;
 }
 
 // todo intergrate with tDataTypes
@@ -313,7 +342,7 @@ const char *taos_data_type(int type) {
 const char *taos_get_client_info() { return version; }
 
 int taos_affected_rows(TAOS_RES *res) {
-  if (res == NULL) {
+  if (res == NULL || TD_RES_TMQ(res)) {
     return 0;
   }
 
@@ -323,12 +352,17 @@ int taos_affected_rows(TAOS_RES *res) {
 }
 
 int taos_result_precision(TAOS_RES *res) {
-  SRequestObj* pRequest = (SRequestObj*) res;
+  if (res == NULL) {
-  if (pRequest == NULL) {
     return TSDB_TIME_PRECISION_MILLI;
   }
-
+  if (TD_RES_QUERY(res)) {
+    SRequestObj *pRequest = (SRequestObj *)res;
     return pRequest->body.resInfo.precision;
+  } else if (TD_RES_TMQ(res)) {
+    SReqResultInfo *info = tmqGetCurResInfo(res);
+    return info->precision;
+  }
+  return TSDB_TIME_PRECISION_MILLI;
 }
 
 int taos_select_db(TAOS *taos, const char *db) {
@@ -370,20 +404,21 @@ void taos_stop_query(TAOS_RES *res) {
 }
 
 bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) {
-  SRequestObj    *pRequestObj = res;
+  SReqResultInfo *pResultInfo = tscGetCurResInfo(res);
-  SReqResultInfo *pResultInfo = &pRequestObj->body.resInfo;
   if (col >= pResultInfo->numOfCols || col < 0 || row >= pResultInfo->numOfRows || row < 0) {
     return true;
   }
 
-  SResultColumn *pCol = &pRequestObj->body.resInfo.pCol[col];
+  SResultColumn *pCol = &pResultInfo->pCol[col];
+  if (IS_VAR_DATA_TYPE(pResultInfo->fields[col].type)) {
+    return (pCol->offset[row] == -1);
+  } else {
     return colDataIsNull_f(pCol->nullbitmap, row);
   }
-
-bool taos_is_update_query(TAOS_RES *res) {
-  return taos_num_fields(res) == 0;
 }
 
+bool taos_is_update_query(TAOS_RES *res) { return taos_num_fields(res) == 0; }
+
 int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
   int32_t numOfRows = 0;
   /*int32_t code = */ taos_fetch_block_s(res, &numOfRows, rows);
@@ -391,10 +426,11 @@ int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
 }
 
 int taos_fetch_block_s(TAOS_RES *res, int *numOfRows, TAOS_ROW *rows) {
-  SRequestObj *pRequest = (SRequestObj *)res;
+  if (res == NULL) {
-  if (pRequest == NULL) {
     return 0;
   }
+  if (TD_RES_QUERY(res)) {
+    SRequestObj *pRequest = (SRequestObj *)res;
 
     (*rows) = NULL;
     (*numOfRows) = 0;
@@ -404,7 +440,7 @@ int taos_fetch_block_s(TAOS_RES *res, int* numOfRows, TAOS_ROW *rows) {
       return 0;
     }
 
-  doFetchRow(pRequest, false);
+    doFetchRows(pRequest, false, true);
 
     // TODO refactor
     SReqResultInfo *pResultInfo = &pRequest->body.resInfo;
@@ -413,20 +449,45 @@ int taos_fetch_block_s(TAOS_RES *res, int* numOfRows, TAOS_ROW *rows) {
     (*rows) = pResultInfo->row;
     (*numOfRows) = pResultInfo->numOfRows;
     return pRequest->code;
+  } else if (TD_RES_TMQ(res)) {
+    SReqResultInfo *pResultInfo = tmqGetNextResInfo(res);
+    if (pResultInfo == NULL) return -1;
+
+    pResultInfo->current = pResultInfo->numOfRows;
+    (*rows) = pResultInfo->row;
+    (*numOfRows) = pResultInfo->numOfRows;
+    return 0;
+  } else {
+    ASSERT(0);
+    return -1;
+  }
 }
 
 int taos_fetch_raw_block(TAOS_RES *res, int *numOfRows, void **pData) {
-  SRequestObj *pRequest = (SRequestObj *)res;
+  if (res == NULL) {
-  if (pRequest == NULL) {
     return 0;
   }
+  if (TD_RES_TMQ(res)) {
+    SReqResultInfo *pResultInfo = tmqGetNextResInfo(res);
+    if (pResultInfo == NULL) {
+      (*numOfRows) = 0;
+      return 0;
+    }
+
+    pResultInfo->current = pResultInfo->numOfRows;
+    (*numOfRows) = pResultInfo->numOfRows;
+    (*pData) = (void *)pResultInfo->pData;
+    return 0;
+  }
+
+  SRequestObj *pRequest = (SRequestObj *)res;
 
   if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT || pRequest->type == TSDB_SQL_INSERT ||
       pRequest->code != TSDB_CODE_SUCCESS || taos_num_fields(res) == 0) {
     return 0;
   }
 
-  doFetchRow(pRequest, false);
+  doFetchRows(pRequest, false, false);
 
   SReqResultInfo *pResultInfo = &pRequest->body.resInfo;
 
@@ -438,22 +499,22 @@ int taos_fetch_raw_block(TAOS_RES *res, int* numOfRows, void** pData) {
 }
 
 int *taos_get_column_data_offset(TAOS_RES *res, int columnIndex) {
-  SRequestObj *pRequest = (SRequestObj *)res;
+  if (res == NULL) {
-  if (pRequest == NULL) {
     return 0;
   }
 
-  int32_t numOfFields = taos_num_fields(pRequest);
+  int32_t numOfFields = taos_num_fields(res);
   if (columnIndex < 0 || columnIndex >= numOfFields || numOfFields == 0) {
     return 0;
   }
 
-  TAOS_FIELD* pField = &pRequest->body.resInfo.userFields[columnIndex];
+  SReqResultInfo *pResInfo = tscGetCurResInfo(res);
+  TAOS_FIELD     *pField = &pResInfo->userFields[columnIndex];
   if (!IS_VAR_DATA_TYPE(pField->type)) {
     return 0;
   }
 
-  return pRequest->body.resInfo.pCol[columnIndex].offset;
+  return pResInfo->pCol[columnIndex].offset;
 }
 
 int taos_validate_sql(TAOS *taos, const char *sql) { return true; }
@@ -483,7 +544,8 @@ void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
   // TODO
 }
 
-TAOS_SUB *taos_subscribe(TAOS *taos, int restart, const char* topic, const char *sql, TAOS_SUBSCRIBE_CALLBACK fp, void *param, int interval) {
+TAOS_SUB *taos_subscribe(TAOS *taos, int restart, const char *topic, const char *sql, TAOS_SUBSCRIBE_CALLBACK fp,
+                         void *param, int interval) {
   // TODO
   return NULL;
 }

source/client/src/clientMsgHandler.c

@@ -69,9 +69,9 @@ int32_t processConnectRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   pTscObj->pAppInfo->clusterId = connectRsp.clusterId;
   atomic_add_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
 
-  pTscObj->connType = HEARTBEAT_TYPE_QUERY;
+  pTscObj->connType = connectRsp.connType;
 
-  hbRegisterConn(pTscObj->pAppInfo->pAppHbMgr, connectRsp.connId, connectRsp.clusterId, HEARTBEAT_TYPE_QUERY);
+  hbRegisterConn(pTscObj->pAppInfo->pAppHbMgr, connectRsp.connId, connectRsp.clusterId, connectRsp.connType);
 
   //  pRequest->body.resInfo.pRspMsg = pMsg->pData;
   tscDebug("0x%" PRIx64 " clusterId:%" PRId64 ", totalConn:%" PRId64, pRequest->requestId, connectRsp.clusterId,
@@ -90,150 +90,13 @@ SMsgSendInfo* buildMsgInfoImpl(SRequestObj *pRequest) {
   pMsgSendInfo->param           = pRequest;
   pMsgSendInfo->msgType         = pRequest->type;
 
-  if (pRequest->type == TDMT_MND_SHOW_RETRIEVE || pRequest->type == TDMT_VND_SHOW_TABLES_FETCH) {
-    if (pRequest->type == TDMT_MND_SHOW_RETRIEVE) {
-      SRetrieveTableReq retrieveReq = {0};
-      retrieveReq.showId = pRequest->body.showInfo.execId;
-
-      int32_t contLen = tSerializeSRetrieveTableReq(NULL, 0, &retrieveReq);
-      void*   pReq = taosMemoryMalloc(contLen);
-      tSerializeSRetrieveTableReq(pReq, contLen, &retrieveReq);
-      pMsgSendInfo->msgInfo.pData = pReq;
-      pMsgSendInfo->msgInfo.len = contLen;
-      pMsgSendInfo->msgInfo.handle = NULL;
-    } else {
-      SVShowTablesFetchReq* pFetchMsg = taosMemoryCalloc(1, sizeof(SVShowTablesFetchReq));
-      if (pFetchMsg == NULL) {
-        return NULL;
-      }
-
-      pFetchMsg->id = htobe64(pRequest->body.showInfo.execId);
-      pFetchMsg->head.vgId = htonl(pRequest->body.showInfo.vgId);
-
-      pMsgSendInfo->msgInfo.pData = pFetchMsg;
-      pMsgSendInfo->msgInfo.len = sizeof(SVShowTablesFetchReq);
-      pMsgSendInfo->msgInfo.handle = NULL;
-    }
-  } else {
   assert(pRequest != NULL);
   pMsgSendInfo->msgInfo = pRequest->body.requestMsg;
-  }
 
   pMsgSendInfo->fp = (handleRequestRspFp[TMSG_INDEX(pRequest->type)] == NULL)? genericRspCallback:handleRequestRspFp[TMSG_INDEX(pRequest->type)];
   return pMsgSendInfo;
 }
 
-int32_t processShowRsp(void* param, const SDataBuf* pMsg, int32_t code) {
-  SRequestObj* pRequest = param;
-  if (code != TSDB_CODE_SUCCESS) {
-    setErrno(pRequest, code);
-    tsem_post(&pRequest->body.rspSem);
-    return code;
-  }
-
-  SShowRsp showRsp = {0};
-  tDeserializeSShowRsp(pMsg->pData, pMsg->len, &showRsp);
-  STableMetaRsp *pMetaMsg = &showRsp.tableMeta;
-
-  taosMemoryFreeClear(pRequest->body.resInfo.pRspMsg);
-  pRequest->body.resInfo.pRspMsg = pMsg->pData;
-  SReqResultInfo* pResInfo = &pRequest->body.resInfo;
-
-  if (pResInfo->fields == NULL) {
-    TAOS_FIELD* pFields = taosMemoryCalloc(pMetaMsg->numOfColumns, sizeof(TAOS_FIELD));
-    for (int32_t i = 0; i < pMetaMsg->numOfColumns; ++i) {
-      SSchema* pSchema = &pMetaMsg->pSchemas[i];
-      tstrncpy(pFields[i].name, pSchema->name, tListLen(pFields[i].name));
-      pFields[i].type = pSchema->type;
-      pFields[i].bytes = pSchema->bytes;
-    }
-
-    pResInfo->fields = pFields;
-  }
-
-  pResInfo->numOfCols = pMetaMsg->numOfColumns;
-  pRequest->body.showInfo.execId = showRsp.showId;
-  tFreeSShowRsp(&showRsp);
-
-  // todo
-  if (pRequest->type == TDMT_VND_SHOW_TABLES) {
-    SShowReqInfo* pShowInfo = &pRequest->body.showInfo;
-
-    int32_t index = pShowInfo->currentIndex;
-    SVgroupInfo* pInfo = taosArrayGet(pShowInfo->pArray, index);
-    pShowInfo->vgId = pInfo->vgId;
-  }
-
-  tsem_post(&pRequest->body.rspSem);
-  return 0;
-}
-
-int32_t processRetrieveMnodeRsp(void* param, const SDataBuf* pMsg, int32_t code) {
-  SRequestObj    *pRequest = param;
-  SReqResultInfo *pResInfo = &pRequest->body.resInfo;
-  taosMemoryFreeClear(pResInfo->pRspMsg);
-
-  if (code != TSDB_CODE_SUCCESS) {
-    setErrno(pRequest, code);
-    tsem_post(&pRequest->body.rspSem);
-    return code;
-  }
-
-  assert(pMsg->len >= sizeof(SRetrieveTableRsp));
-
-  SRetrieveTableRsp *pRetrieve = (SRetrieveTableRsp *) pMsg->pData;
-  pRetrieve->numOfRows  = htonl(pRetrieve->numOfRows);
-  pRetrieve->precision  = htons(pRetrieve->precision);
-
-  pResInfo->pRspMsg   = pMsg->pData;
-  pResInfo->numOfRows = pRetrieve->numOfRows;
-  pResInfo->pData     = pRetrieve->data;
-  pResInfo->completed = pRetrieve->completed;
-
-  pResInfo->current = 0;
-  setResultDataPtr(pResInfo, pResInfo->fields, pResInfo->numOfCols, pResInfo->numOfRows);
-
-  tscDebug("0x%"PRIx64" numOfRows:%d, complete:%d, qId:0x%"PRIx64, pRequest->self, pRetrieve->numOfRows,
-           pRetrieve->completed, pRequest->body.showInfo.execId);
-
-  tsem_post(&pRequest->body.rspSem);
-  return 0;
-}
-
-int32_t processRetrieveVndRsp(void* param, const SDataBuf* pMsg, int32_t code) {
-  SRequestObj* pRequest = param;
-
-  SReqResultInfo* pResInfo = &pRequest->body.resInfo;
-  taosMemoryFreeClear(pResInfo->pRspMsg);
-
-  if (code != TSDB_CODE_SUCCESS) {
-    setErrno(pRequest, code);
-    tsem_post(&pRequest->body.rspSem);
-    return code;
-  }
-
-  assert(pMsg->len >= sizeof(SRetrieveTableRsp));
-
-  pResInfo->pRspMsg    = pMsg->pData;
-
-  SVShowTablesFetchRsp *pFetchRsp = (SVShowTablesFetchRsp *) pMsg->pData;
-  pFetchRsp->numOfRows  = htonl(pFetchRsp->numOfRows);
-  pFetchRsp->precision  = htons(pFetchRsp->precision);
-
-  pResInfo->pRspMsg   = pMsg->pData;
-  pResInfo->numOfRows = pFetchRsp->numOfRows;
-  pResInfo->pData     = pFetchRsp->data;
-
-  pResInfo->current = 0;
-  setResultDataPtr(pResInfo, pResInfo->fields, pResInfo->numOfCols, pResInfo->numOfRows);
-
-  tscDebug("0x%"PRIx64" numOfRows:%d, complete:%d, qId:0x%"PRIx64, pRequest->self, pFetchRsp->numOfRows,
-           pFetchRsp->completed, pRequest->body.showInfo.execId);
-
-  tsem_post(&pRequest->body.rspSem);
-  return 0;
-}
-
 int32_t processCreateDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   // todo rsp with the vnode id list
   SRequestObj* pRequest = param;
@@ -256,7 +119,8 @@ int32_t processUseDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
     if (usedbRsp.vgVersion >= 0) {
       int32_t code = catalogGetHandle(pRequest->pTscObj->pAppInfo->clusterId, &pCatalog);
       if (code != TSDB_CODE_SUCCESS) {
-        tscWarn("catalogGetHandle failed, clusterId:%"PRIx64", error:%s", pRequest->pTscObj->pAppInfo->clusterId, tstrerror(code));
+        tscWarn("catalogGetHandle failed, clusterId:%" PRIx64 ", error:%s", pRequest->pTscObj->pAppInfo->clusterId,
+                tstrerror(code));
       } else {
         catalogRemoveDB(pCatalog, usedbRsp.db, usedbRsp.uid);
       }
@@ -292,7 +156,8 @@ int32_t processUseDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
 
     int32_t code = catalogGetHandle(pRequest->pTscObj->pAppInfo->clusterId, &pCatalog);
     if (code != TSDB_CODE_SUCCESS) {
-      tscWarn("catalogGetHandle failed, clusterId:%"PRIx64", error:%s", pRequest->pTscObj->pAppInfo->clusterId, tstrerror(code));
+      tscWarn("catalogGetHandle failed, clusterId:%" PRIx64 ", error:%s", pRequest->pTscObj->pAppInfo->clusterId,
+              tstrerror(code));
     } else {
       catalogUpdateDBVgInfo(pCatalog, output.db, output.dbId, output.dbVgroup);
     }
@@ -420,13 +285,8 @@ void initMsgHandleFp() {
 #endif
 
   handleRequestRspFp[TMSG_INDEX(TDMT_MND_CONNECT)]       = processConnectRsp;
-  handleRequestRspFp[TMSG_INDEX(TDMT_MND_SHOW)]          = processShowRsp;
-  handleRequestRspFp[TMSG_INDEX(TDMT_MND_SHOW_RETRIEVE)] = processRetrieveMnodeRsp;
   handleRequestRspFp[TMSG_INDEX(TDMT_MND_CREATE_DB)]     = processCreateDbRsp;
   handleRequestRspFp[TMSG_INDEX(TDMT_MND_USE_DB)]        = processUseDbRsp;
   handleRequestRspFp[TMSG_INDEX(TDMT_MND_CREATE_STB)]    = processCreateTableRsp;
   handleRequestRspFp[TMSG_INDEX(TDMT_MND_DROP_DB)]       = processDropDbRsp;
-
-  handleRequestRspFp[TMSG_INDEX(TDMT_VND_SHOW_TABLES)]   = processShowRsp;
-  handleRequestRspFp[TMSG_INDEX(TDMT_VND_SHOW_TABLES_FETCH)]   = processRetrieveVndRsp;
 }

source/client/src/tmq.c

@@ -17,27 +17,32 @@
 #include "clientLog.h"
 #include "parser.h"
 #include "planner.h"
-#include "scheduler.h"
 #include "tdatablock.h"
 #include "tdef.h"
 #include "tglobal.h"
 #include "tmsgtype.h"
-#include "tpagedbuf.h"
 #include "tqueue.h"
 #include "tref.h"
 
-typedef struct {
-  int32_t curBlock;
-  int32_t curRow;
-  void**  uData;
-} SMqRowIter;
-
 struct tmq_message_t {
   SMqPollRsp msg;
-  void*      vg;
+  char*      topic;
-  SMqRowIter iter;
+  SArray*    res;  // SArray<SReqResultInfo>
+  int32_t    vgId;
+  int32_t    resIter;
 };
 
+typedef struct {
+  int8_t  tmqRspType;
+  int32_t epoch;
+} SMqRspWrapper;
+
+typedef struct {
+  int8_t           tmqRspType;
+  int32_t          epoch;
+  SMqCMGetSubEpRsp msg;
+} SMqAskEpRspWrapper;
+
 struct tmq_list_t {
   SArray container;
 };
@@ -121,9 +126,17 @@ typedef struct {
   SArray*        vgs;  // SArray<SMqClientVg>
   int8_t         isSchemaAdaptive;
   int32_t        numOfFields;
-  TAOS_FIELD* fields;
+  SSchemaWrapper schema;
 } SMqClientTopic;
 
+typedef struct {
+  int8_t          tmqRspType;
+  int32_t         epoch;
+  SMqClientVg*    vgHandle;
+  SMqClientTopic* topicHandle;
+  SMqPollRspV2    msg;
+} SMqPollRspWrapper;
+
 typedef struct {
   tmq_t*         tmq;
   tsem_t         rspSem;
@@ -139,10 +152,10 @@ typedef struct {
 typedef struct {
   tmq_t*          tmq;
   SMqClientVg*    pVg;
+  SMqClientTopic* pTopic;
   int32_t         epoch;
   int32_t         vgId;
   tsem_t          rspSem;
-  tmq_message_t** msg;
   int32_t         sync;
 } SMqPollCbParam;
 
@@ -250,7 +263,7 @@ static int32_t tmqMakeTopicVgKey(char* dst, const char* topicName, int32_t vg) {
 }
 
 void tmqClearUnhandleMsg(tmq_t* tmq) {
-  tmq_message_t* msg = NULL;
+  SMqRspWrapper* msg = NULL;
   while (1) {
     taosGetQitem(tmq->qall, (void**)&msg);
     if (msg)
@@ -344,7 +357,15 @@ tmq_t* tmq_consumer_new1(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
   if (pTmq == NULL) {
     return NULL;
   }
-  pTmq->pTscObj = taos_connect(conf->ip, conf->user, conf->pass, conf->db, conf->port);
+  const char* user = conf->user == NULL ? TSDB_DEFAULT_USER : conf->user;
+  const char* pass = conf->pass == NULL ? TSDB_DEFAULT_PASS : conf->pass;
+
+  ASSERT(user);
+  ASSERT(pass);
+  ASSERT(conf->db);
+
+  pTmq->pTscObj = taos_connect_internal(conf->ip, user, pass, NULL, conf->db, conf->port, CONN_TYPE__TMQ);
+  if (pTmq->pTscObj == NULL) return NULL;
 
   pTmq->inWaiting = 0;
   pTmq->status = 0;
@@ -770,7 +791,7 @@ static char* formatTimestamp(char* buf, int64_t val, int precision) {
     }
   }
 
-  struct tm* ptm = localtime(&tt);
+  struct tm* ptm = taosLocalTime(&tt, NULL);
   size_t     pos = strftime(buf, 35, "%Y-%m-%d %H:%M:%S", ptm);
 
   if (precision == TSDB_TIME_PRECISION_NANO) {
@@ -783,7 +804,7 @@ static char* formatTimestamp(char* buf, int64_t val, int precision) {
 
   return buf;
 }
-
+#if 0
 int32_t tmqGetSkipLogNum(tmq_message_t* tmq_message) {
   if (tmq_message == NULL) return 0;
   SMqPollRsp* pRsp = &tmq_message->msg;
@@ -833,11 +854,13 @@ void tmqShowMsg(tmq_message_t* tmq_message) {
     }
   }
 }
+#endif
 
 int32_t tmqPollCb(void* param, const SDataBuf* pMsg, int32_t code) {
   /*printf("recv poll\n");*/
   SMqPollCbParam* pParam = (SMqPollCbParam*)param;
   SMqClientVg*    pVg = pParam->pVg;
+  SMqClientTopic* pTopic = pParam->pTopic;
   tmq_t*          tmq = pParam->tmq;
   if (code != 0) {
     tscWarn("msg discard from vg %d, epoch %d, code:%x", pParam->vgId, pParam->epoch, code);
@@ -849,7 +872,8 @@ int32_t tmqPollCb(void* param, const SDataBuf* pMsg, int32_t code) {
   if (msgEpoch < tmqEpoch) {
     /*printf("discard rsp epoch %d, current epoch %d\n", msgEpoch, tmqEpoch);*/
     /*tsem_post(&tmq->rspSem);*/
-    tscWarn("msg discard from vg %d since from earlier epoch, rsp epoch %d, current epoch %d", pParam->vgId, msgEpoch, tmqEpoch);
+    tscWarn("msg discard from vg %d since from earlier epoch, rsp epoch %d, current epoch %d", pParam->vgId, msgEpoch,
+            tmqEpoch);
     return 0;
   }
 
@@ -879,18 +903,22 @@ int32_t tmqPollCb(void* param, const SDataBuf* pMsg, int32_t code) {
 #endif
 
   /*SMqConsumeRsp* pRsp = taosMemoryCalloc(1, sizeof(SMqConsumeRsp));*/
-  tmq_message_t* pRsp = taosAllocateQitem(sizeof(tmq_message_t));
+  /*tmq_message_t* pRsp = taosAllocateQitem(sizeof(tmq_message_t));*/
-  if (pRsp == NULL) {
+  SMqPollRspWrapper* pRspWrapper = taosAllocateQitem(sizeof(SMqPollRspWrapper));
+  if (pRspWrapper == NULL) {
     tscWarn("msg discard from vg %d, epoch %d since out of memory", pParam->vgId, pParam->epoch);
     goto CREATE_MSG_FAIL;
   }
-  memcpy(pRsp, pMsg->pData, sizeof(SMqRspHead));
+  pRspWrapper->tmqRspType = TMQ_MSG_TYPE__POLL_RSP;
-  tDecodeSMqPollRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pRsp->msg);
+  pRspWrapper->vgHandle = pVg;
-  pRsp->iter.curBlock = 0;
+  pRspWrapper->topicHandle = pTopic;
-  pRsp->iter.curRow = 0;
+  /*memcpy(pRsp, pMsg->pData, sizeof(SMqRspHead));*/
+  memcpy(&pRspWrapper->msg, pMsg->pData, sizeof(SMqRspHead));
+  tDecodeSMqPollRspV2(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pRspWrapper->msg);
   // TODO: alloc mem
   /*pRsp->*/
   /*printf("rsp commit off:%ld rsp off:%ld has data:%d\n", pRsp->committedOffset, pRsp->rspOffset, pRsp->numOfTopics);*/
+
 #if 0
   if (pRsp->msg.numOfTopics == 0) {
     /*printf("no data\n");*/
@@ -899,11 +927,10 @@ int32_t tmqPollCb(void* param, const SDataBuf* pMsg, int32_t code) {
   }
 #endif
 
-  tscDebug("consumer %ld recv poll: vg %d, req offset %ld, rsp offset %ld", tmq->consumerId, pParam->pVg->vgId, pRsp->msg.reqOffset,
+  tscDebug("consumer %ld recv poll: vg %d, req offset %ld, rsp offset %ld", tmq->consumerId, pVg->vgId,
-           pRsp->msg.rspOffset);
+           pRspWrapper->msg.reqOffset, pRspWrapper->msg.rspOffset);
 
-  pRsp->vg = pParam->pVg;
+  taosWriteQitem(tmq->mqueue, pRspWrapper);
-  taosWriteQitem(tmq->mqueue, pRsp);
   atomic_add_fetch_32(&tmq->readyRequest, 1);
   /*tsem_post(&tmq->rspSem);*/
   return 0;
@@ -921,7 +948,8 @@ bool tmqUpdateEp(tmq_t* tmq, int32_t epoch, SMqCMGetSubEpRsp* pRsp) {
   bool    set = false;
   int32_t topicNumGet = taosArrayGetSize(pRsp->topics);
   char    vgKey[TSDB_TOPIC_FNAME_LEN + 22];
-  tscDebug("consumer %ld update ep epoch %d to epoch %d, topic num: %d", tmq->consumerId, tmq->epoch, epoch, topicNumGet);
+  tscDebug("consumer %ld update ep epoch %d to epoch %d, topic num: %d", tmq->consumerId, tmq->epoch, epoch,
+           topicNumGet);
   SArray* newTopics = taosArrayInit(topicNumGet, sizeof(SMqClientTopic));
   if (newTopics == NULL) {
     return false;
@@ -936,6 +964,7 @@ bool tmqUpdateEp(tmq_t* tmq, int32_t epoch, SMqCMGetSubEpRsp* pRsp) {
   for (int32_t i = 0; i < topicNumGet; i++) {
     SMqClientTopic topic = {0};
     SMqSubTopicEp* pTopicEp = taosArrayGet(pRsp->topics, i);
+    topic.schema = pTopicEp->schema;
     taosHashClear(pHash);
     topic.topicName = strdup(pTopicEp->topic);
 
@@ -1019,16 +1048,19 @@ int32_t tmqAskEpCb(void* param, const SDataBuf* pMsg, int32_t code) {
     }
     tDeleteSMqCMGetSubEpRsp(&rsp);
   } else {
-    SMqCMGetSubEpRsp* pRsp = taosAllocateQitem(sizeof(SMqCMGetSubEpRsp));
+    /*SMqCMGetSubEpRsp* pRsp = taosAllocateQitem(sizeof(SMqCMGetSubEpRsp));*/
-    if (pRsp == NULL) {
+    SMqAskEpRspWrapper* pWrapper = taosAllocateQitem(sizeof(SMqAskEpRspWrapper));
+    if (pWrapper == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       code = -1;
       goto END;
     }
-    memcpy(pRsp, pMsg->pData, sizeof(SMqRspHead));
+    pWrapper->tmqRspType = TMQ_MSG_TYPE__EP_RSP;
-    tDecodeSMqCMGetSubEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), pRsp);
+    pWrapper->epoch = head->epoch;
+    memcpy(&pWrapper->msg, pMsg->pData, sizeof(SMqRspHead));
+    tDecodeSMqCMGetSubEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pWrapper->msg);
 
-    taosWriteQitem(tmq->mqueue, pRsp);
+    taosWriteQitem(tmq->mqueue, pWrapper);
     /*tsem_post(&tmq->rspSem);*/
   }
 
@@ -1156,6 +1188,28 @@ SMqPollReq* tmqBuildConsumeReqImpl(tmq_t* tmq, int64_t blockingTime, SMqClientTo
   return pReq;
 }
 
+SMqRspObj* tmqBuildRspFromWrapper(SMqPollRspWrapper* pWrapper) {
+  SMqRspObj* pRspObj = taosMemoryCalloc(1, sizeof(SMqRspObj));
+  pRspObj->resType = RES_TYPE__TMQ;
+  pRspObj->topic = strdup(pWrapper->topicHandle->topicName);
+  pRspObj->resIter = -1;
+  pRspObj->vgId = pWrapper->vgHandle->vgId;
+  SMqPollRspV2* pRsp = &pWrapper->msg;
+  int32_t       blockNum = taosArrayGetSize(pRsp->blockPos);
+  pRspObj->res = taosArrayInit(blockNum, sizeof(SReqResultInfo));
+  for (int32_t i = 0; i < blockNum; i++) {
+    int32_t            pos = *(int32_t*)taosArrayGet(pRsp->blockPos, i);
+    SRetrieveTableRsp* pRetrieve = POINTER_SHIFT(pRsp->blockData, pos);
+    SReqResultInfo     resInfo = {0};
+    resInfo.totalRows = 0;
+    resInfo.precision = TSDB_TIME_PRECISION_MILLI;
+    setResSchemaInfo(&resInfo, pWrapper->topicHandle->schema.pSchema, pWrapper->topicHandle->schema.nCols);
+    setQueryResultFromRsp(&resInfo, pRetrieve, true);
+    taosArrayPush(pRspObj->res, &resInfo);
+  }
+  return pRspObj;
+}
+
 #if 0
 tmq_message_t* tmqSyncPollImpl(tmq_t* tmq, int64_t blockingTime) {
   tmq_message_t* msg = NULL;
@@ -1262,6 +1316,7 @@ int32_t tmqPollImpl(tmq_t* tmq, int64_t blockingTime) {
       }
       pParam->tmq = tmq;
       pParam->pVg = pVg;
+      pParam->pTopic = pTopic;
       pParam->vgId = pVg->vgId;
       pParam->epoch = tmq->epoch;
       pParam->sync = 0;
@@ -1289,7 +1344,8 @@ int32_t tmqPollImpl(tmq_t* tmq, int64_t blockingTime) {
       int64_t transporterId = 0;
       /*printf("send poll\n");*/
       atomic_add_fetch_32(&tmq->waitingRequest, 1);
-      tscDebug("consumer %ld send poll to %s : vg %d, epoch %d, req offset %ld, reqId %lu", tmq->consumerId, pTopic->topicName, pVg->vgId, tmq->epoch, pVg->currentOffset, pReq->reqId);
+      tscDebug("consumer %ld send poll to %s : vg %d, epoch %d, req offset %ld, reqId %lu", tmq->consumerId,
+               pTopic->topicName, pVg->vgId, tmq->epoch, pVg->currentOffset, pReq->reqId);
       /*printf("send vg %d %ld\n", pVg->vgId, pVg->currentOffset);*/
       asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, &pVg->epSet, &transporterId, sendInfo);
       pVg->pollCnt++;
@@ -1299,13 +1355,13 @@ int32_t tmqPollImpl(tmq_t* tmq, int64_t blockingTime) {
   return 0;
 }
 
-// return
+int32_t tmqHandleNoPollRsp(tmq_t* tmq, SMqRspWrapper* rspWrapper, bool* pReset) {
-int32_t tmqHandleNoPollRsp(tmq_t* tmq, SMqRspHead* rspHead, bool* pReset) {
+  if (rspWrapper->tmqRspType == TMQ_MSG_TYPE__EP_RSP) {
-  if (rspHead->mqMsgType == TMQ_MSG_TYPE__EP_RSP) {
     /*printf("ep %d %d\n", rspMsg->head.epoch, tmq->epoch);*/
-    if (rspHead->epoch > atomic_load_32(&tmq->epoch)) {
+    if (rspWrapper->epoch > atomic_load_32(&tmq->epoch)) {
-      SMqCMGetSubEpRsp* rspMsg = (SMqCMGetSubEpRsp*)rspHead;
+      SMqAskEpRspWrapper* pEpRspWrapper = (SMqAskEpRspWrapper*)rspWrapper;
-      tmqUpdateEp(tmq, rspHead->epoch, rspMsg);
+      SMqCMGetSubEpRsp*   rspMsg = &pEpRspWrapper->msg;
+      tmqUpdateEp(tmq, rspWrapper->epoch, rspMsg);
       /*tmqClearUnhandleMsg(tmq);*/
       *pReset = true;
     } else {
@@ -1317,41 +1373,43 @@ int32_t tmqHandleNoPollRsp(tmq_t* tmq, SMqRspHead* rspHead, bool* pReset) {
   return 0;
 }
 
-tmq_message_t* tmqHandleAllRsp(tmq_t* tmq, int64_t blockingTime, bool pollIfReset) {
+SMqRspObj* tmqHandleAllRsp(tmq_t* tmq, int64_t blockingTime, bool pollIfReset) {
   while (1) {
-    SMqRspHead* rspHead = NULL;
+    SMqRspWrapper* rspWrapper = NULL;
-    taosGetQitem(tmq->qall, (void**)&rspHead);
+    taosGetQitem(tmq->qall, (void**)&rspWrapper);
-    if (rspHead == NULL) {
+    if (rspWrapper == NULL) {
       taosReadAllQitems(tmq->mqueue, tmq->qall);
-      taosGetQitem(tmq->qall, (void**)&rspHead);
+      taosGetQitem(tmq->qall, (void**)&rspWrapper);
-      if (rspHead == NULL) return NULL;
+      if (rspWrapper == NULL) return NULL;
     }
 
-    if (rspHead->mqMsgType == TMQ_MSG_TYPE__POLL_RSP) {
+    if (rspWrapper->tmqRspType == TMQ_MSG_TYPE__POLL_RSP) {
-      tmq_message_t* rspMsg = (tmq_message_t*)rspHead;
+      SMqPollRspWrapper* pollRspWrapper = (SMqPollRspWrapper*)rspWrapper;
       atomic_sub_fetch_32(&tmq->readyRequest, 1);
       /*printf("handle poll rsp %d\n", rspMsg->head.mqMsgType);*/
-      if (rspMsg->msg.head.epoch == atomic_load_32(&tmq->epoch)) {
+      if (pollRspWrapper->msg.head.epoch == atomic_load_32(&tmq->epoch)) {
         /*printf("epoch match\n");*/
-        SMqClientVg* pVg = rspMsg->vg;
+        SMqClientVg* pVg = pollRspWrapper->vgHandle;
         /*printf("vg %d offset %ld up to %ld\n", pVg->vgId, pVg->currentOffset, rspMsg->msg.rspOffset);*/
-        pVg->currentOffset = rspMsg->msg.rspOffset;
+        pVg->currentOffset = pollRspWrapper->msg.rspOffset;
         atomic_store_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE);
-        if (rspMsg->msg.numOfTopics == 0) {
+        if (pollRspWrapper->msg.dataLen == 0) {
-          taosFreeQitem(rspMsg);
+          taosFreeQitem(pollRspWrapper);
-          rspHead = NULL;
+          rspWrapper = NULL;
           continue;
         }
-        return rspMsg;
+        // build rsp
+        SMqRspObj* pRsp = tmqBuildRspFromWrapper(pollRspWrapper);
+        return pRsp;
       } else {
         /*printf("epoch mismatch\n");*/
-        taosFreeQitem(rspMsg);
+        taosFreeQitem(pollRspWrapper);
       }
     } else {
       /*printf("handle ep rsp %d\n", rspMsg->head.mqMsgType);*/
       bool reset = false;
-      tmqHandleNoPollRsp(tmq, rspHead, &reset);
+      tmqHandleNoPollRsp(tmq, rspWrapper, &reset);
-      taosFreeQitem(rspHead);
+      taosFreeQitem(rspWrapper);
       if (pollIfReset && reset) {
         tscDebug("consumer %ld reset and repoll", tmq->consumerId);
         tmqPollImpl(tmq, blockingTime);
@@ -1385,17 +1443,17 @@ tmq_message_t* tmq_consumer_poll_v1(tmq_t* tmq, int64_t blocking_time) {
 }
 #endif
 
-tmq_message_t* tmq_consumer_poll(tmq_t* tmq, int64_t blocking_time) {
+TAOS_RES* tmq_consumer_poll(tmq_t* tmq, int64_t blocking_time) {
-  tmq_message_t* rspMsg;
+  SMqRspObj* rspObj;
   int64_t    startTime = taosGetTimestampMs();
 
   // TODO: put into another thread or delayed queue
   int64_t status = atomic_load_64(&tmq->status);
   tmqAskEp(tmq, status == TMQ_CONSUMER_STATUS__INIT);
 
-  rspMsg = tmqHandleAllRsp(tmq, blocking_time, false);
+  rspObj = tmqHandleAllRsp(tmq, blocking_time, false);
-  if (rspMsg) {
+  if (rspObj) {
-    return rspMsg;
+    return (TAOS_RES*)rspObj;
   }
 
   while (1) {
@@ -1405,9 +1463,9 @@ tmq_message_t* tmq_consumer_poll(tmq_t* tmq, int64_t blocking_time) {
 
     /*tsem_wait(&tmq->rspSem);*/
 
-    rspMsg = tmqHandleAllRsp(tmq, blocking_time, false);
+    rspObj = tmqHandleAllRsp(tmq, blocking_time, false);
-    if (rspMsg) {
+    if (rspObj) {
-      return rspMsg;
+      return (TAOS_RES*)rspObj;
     }
     if (blocking_time != 0) {
       int64_t endTime = taosGetTimestampMs();
@@ -1549,6 +1607,7 @@ tmq_resp_err_t tmq_commit(tmq_t* tmq, const tmq_topic_vgroup_list_t* tmq_topic_v
 }
 #endif
 
+#if 0
 void tmq_message_destroy(tmq_message_t* tmq_message) {
   if (tmq_message == NULL) return;
   SMqPollRsp* pRsp = &tmq_message->msg;
@@ -1556,6 +1615,7 @@ void tmq_message_destroy(tmq_message_t* tmq_message) {
   /*taosMemoryFree(tmq_message);*/
   taosFreeQitem(tmq_message);
 }
+#endif
 
 tmq_resp_err_t tmq_consumer_close(tmq_t* tmq) { return TMQ_RESP_ERR__SUCCESS; }
 
@@ -1566,30 +1626,27 @@ const char* tmq_err2str(tmq_resp_err_t err) {
   return "fail";
 }
 
-TAOS_ROW tmq_get_row(tmq_message_t* message) {
+char* tmq_get_topic_name(TAOS_RES* res) {
-  SMqPollRsp* rsp = &message->msg;
+  if (TD_RES_TMQ(res)) {
-  while (1) {
+    SMqRspObj* pRspObj = (SMqRspObj*)res;
-    if (message->iter.curBlock < taosArrayGetSize(rsp->pBlockData)) {
+    return pRspObj->topic;
-      SSDataBlock* pBlock = taosArrayGet(rsp->pBlockData, message->iter.curBlock);
-      if (message->iter.curRow < pBlock->info.rows) {
-        for (int i = 0; i < pBlock->info.numOfCols; i++) {
-          SColumnInfoData* pData = taosArrayGet(pBlock->pDataBlock, i);
-          if (colDataIsNull_s(pData, message->iter.curRow))
-            message->iter.uData[i] = NULL;
-          else {
-            message->iter.uData[i] = colDataGetData(pData, message->iter.curRow);
-          }
-        }
-        message->iter.curRow++;
-        return message->iter.uData;
   } else {
-        message->iter.curBlock++;
-        message->iter.curRow = 0;
-        continue;
-      }
-    }
     return NULL;
   }
 }
 
-char* tmq_get_topic_name(tmq_message_t* message) { return "not implemented yet"; }
+int32_t tmq_get_vgroup_id(TAOS_RES* res) {
+  if (TD_RES_TMQ(res)) {
+    SMqRspObj* pRspObj = (SMqRspObj*)res;
+    return pRspObj->vgId;
+  } else {
+    return -1;
+  }
+}
+
+void tmq_message_destroy(TAOS_RES* res) {
+  if (res == NULL) return;
+  if (TD_RES_TMQ(res)) {
+    SMqRspObj* pRspObj = (SMqRspObj*)res;
+  }
+}

source/client/test/clientTests.cpp

@@ -400,7 +400,7 @@ TEST(testCase, show_vgroup_Test) {
   taos_free_result(pRes);
   taos_close(pConn);
 }
-#endif
+
 
 TEST(testCase, create_multiple_tables) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
@@ -459,11 +459,10 @@ TEST(testCase, create_multiple_tables) {
 
   taos_free_result(pRes);
 
-  for (int32_t i = 0; i < 25000; ++i) {
+  for (int32_t i = 0; i < 500; i += 2) {
     char sql[512] = {0};
     snprintf(sql, tListLen(sql),
-             "create table t_x_%d using st1 tags(2) t_x_%d using st1 tags(5) t_x_%d using st1 tags(911)", i,
+             "create table t_x_%d using st1 tags(2) t_x_%d using st1 tags(5)", i, i + 1);
-             (i + 1) * 30, (i + 2) * 40);
     TAOS_RES* pres = taos_query(pConn, sql);
     if (taos_errno(pres) != 0) {
       printf("failed to create table %d\n, reason:%s", i, taos_errstr(pres));
@@ -654,6 +653,8 @@ TEST(testCase, projection_query_stables) {
   taos_close(pConn);
 }
 
+#endif
+
 TEST(testCase, agg_query_tables) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(pConn, nullptr);
@@ -661,7 +662,7 @@ TEST(testCase, agg_query_tables) {
   TAOS_RES* pRes = taos_query(pConn, "use abc1");
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "select count(*) from tu");
+  pRes = taos_query(pConn, "select * from test_block_raw.all_type");
   if (taos_errno(pRes) != 0) {
     printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
     taos_free_result(pRes);
@@ -672,10 +673,21 @@ TEST(testCase, agg_query_tables) {
   TAOS_FIELD* pFields = taos_fetch_fields(pRes);
   int32_t     numOfFields = taos_num_fields(pRes);
 
+  int32_t n = 0;
+  void* data = NULL;
+  int32_t code = taos_fetch_raw_block(pRes, &n, &data);
+
   char str[512] = {0};
   while ((pRow = taos_fetch_row(pRes)) != NULL) {
+    int32_t* length = taos_fetch_lengths(pRes);
+    for(int32_t i = 0; i < numOfFields; ++i) {
+      printf("(%d):%d " , i, length[i]);
+    }
+    printf("\n");
+
     int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
     printf("%s\n", str);
+    memset(str, 0, sizeof(str));
   }
 
   taos_free_result(pRes);

source/common/src/tdatablock.c

@@ -1149,10 +1149,11 @@ void* blockDataDestroy(SSDataBlock* pBlock) {
   return NULL;
 }
 
-SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock) {
+SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock, bool copyData) {
   if(pDataBlock == NULL){
     return NULL;
   }
+
   int32_t numOfCols = pDataBlock->info.numOfCols;
 
   SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock));
@@ -1160,6 +1161,7 @@ SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock) {
 
   pBlock->info.numOfCols = numOfCols;
   pBlock->info.hasVarCol = pDataBlock->info.hasVarCol;
+  pBlock->info.rowSize   = pDataBlock->info.rows;
 
   for (int32_t i = 0; i < numOfCols; ++i) {
     SColumnInfoData  colInfo = {0};
@@ -1168,6 +1170,23 @@ SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock) {
     taosArrayPush(pBlock->pDataBlock, &colInfo);
   }
 
+  if (copyData) {
+    for (int32_t i = 0; i < numOfCols; ++i) {
+      SColumnInfoData* pDst = taosArrayGet(pBlock->pDataBlock, i);
+      SColumnInfoData* pSrc = taosArrayGet(pDataBlock->pDataBlock, i);
+
+      int32_t code = colInfoDataEnsureCapacity(pDst, pDataBlock->info.rows);
+      if (code != TSDB_CODE_SUCCESS) {
+        return NULL;
+      }
+
+      colDataAssign(pDst, pSrc, pDataBlock->info.rows);
+    }
+
+    pBlock->info.rows = pDataBlock->info.rows;
+    pBlock->info.capacity = pDataBlock->info.rows;
+  }
+
   return pBlock;
 }
 
@@ -1368,7 +1387,7 @@ static char* formatTimestamp(char* buf, int64_t val, int precision) {
     }
   }
 
-  struct tm* ptm = localtime(&tt);
+  struct tm* ptm = taosLocalTime(&tt, NULL);
   size_t     pos = strftime(buf, 35, "%Y-%m-%d %H:%M:%S", ptm);
 
   if (precision == TSDB_TIME_PRECISION_NANO) {

source/common/src/tdataformat.c

@@ -411,6 +411,7 @@ int tdInitDataCols(SDataCols *pCols, STSchema *pSchema) {
 #endif
 
   pCols->numOfRows = 0;
+  pCols->bitmapMode = 0;
   pCols->numOfCols = schemaNCols(pSchema);
 
   for (i = 0; i < schemaNCols(pSchema); ++i) {

source/common/src/tglobal.c

@@ -189,7 +189,7 @@ static int32_t taosSetTfsCfg(SConfig *pCfg) {
     tsDiskCfgNum = 1;
     taosAddDataDir(0, pItem->str, 0, 1);
     tstrncpy(tsDataDir, pItem->str, PATH_MAX);
-    if (taosMkDir(tsDataDir) != 0) {
+    if (taosMulMkDir(tsDataDir) != 0) {
       uError("failed to create dataDir:%s since %s", tsDataDir, terrstr());
       return -1;
     }
@@ -200,12 +200,12 @@ static int32_t taosSetTfsCfg(SConfig *pCfg) {
       memcpy(&tsDiskCfg[index], pCfg, sizeof(SDiskCfg));
       if (pCfg->level == 0 && pCfg->primary == 1) {
         tstrncpy(tsDataDir, pCfg->dir, PATH_MAX);
-        if (taosMkDir(tsDataDir) != 0) {
+        if (taosMulMkDir(tsDataDir) != 0) {
           uError("failed to create dataDir:%s since %s", tsDataDir, terrstr());
           return -1;
         }
       }
-      if (taosMkDir(pCfg->dir) != 0) {
+      if (taosMulMkDir(pCfg->dir) != 0) {
         uError("failed to create tfsDir:%s since %s", tsDataDir, terrstr());
         return -1;
       }
@@ -256,7 +256,7 @@ static int32_t taosLoadCfg(SConfig *pCfg, const char *inputCfgDir, const char *e
   return 0;
 }
 
-static int32_t taosAddClientLogCfg(SConfig *pCfg) {
+int32_t taosAddClientLogCfg(SConfig *pCfg) {
   if (cfgAddDir(pCfg, "configDir", configDir, 1) != 0) return -1;
   if (cfgAddDir(pCfg, "scriptDir", configDir, 1) != 0) return -1;
   if (cfgAddDir(pCfg, "logDir", tsLogDir, 1) != 0) return -1;
@@ -486,7 +486,7 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
   tstrncpy(tsTempDir, cfgGetItem(pCfg, "tempDir")->str, PATH_MAX);
   taosExpandDir(tsTempDir, tsTempDir, PATH_MAX);
   tsTempSpace.reserved = cfgGetItem(pCfg, "minimalTempDirGB")->fval;
-  if (taosMkDir(tsTempDir) != 0) {
+  if (taosMulMkDir(tsTempDir) != 0) {
     uError("failed to create tempDir:%s since %s", tsTempDir, terrstr());
     return -1;
   }
@@ -495,7 +495,7 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
   tsRpcTimer = cfgGetItem(pCfg, "rpcTimer")->i32;
   tsRpcMaxTime = cfgGetItem(pCfg, "rpcMaxTime")->i32;
   tsRpcForceTcp = cfgGetItem(pCfg, "rpcForceTcp")->i32;
-  tsShellActivityTimer = cfgGetItem(pCfg, "shellActivityTimer")->bval;
+  tsShellActivityTimer = cfgGetItem(pCfg, "shellActivityTimer")->i32;
   tsCompressMsgSize = cfgGetItem(pCfg, "compressMsgSize")->i32;
   tsCompressColData = cfgGetItem(pCfg, "compressColData")->i32;
   tsMaxWildCardsLen = cfgGetItem(pCfg, "maxWildCardsLength")->i32;
@@ -616,7 +616,7 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi
 
   taosSetAllDebugFlag(cfgGetItem(pCfg, "debugFlag")->i32);
 
-  if (taosMkDir(tsLogDir) != 0) {
+  if (taosMulMkDir(tsLogDir) != 0) {
     uError("failed to create dir:%s since %s", tsLogDir, terrstr());
     cfgCleanup(pCfg);
     return -1;

source/common/src/tmsg.c

@@ -308,6 +308,7 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
       tlen += taosEncodeFixedI16(buf, pReq->stbCfg.nTagCols);
       for (col_id_t i = 0; i < pReq->stbCfg.nTagCols; ++i) {
         tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pTagSchema[i].type);
+        tlen += taosEncodeFixedI8(buf, pReq->stbCfg.pTagSchema[i].index);
         tlen += taosEncodeFixedI16(buf, pReq->stbCfg.pTagSchema[i].colId);
         tlen += taosEncodeFixedI32(buf, pReq->stbCfg.pTagSchema[i].bytes);
         tlen += taosEncodeString(buf, pReq->stbCfg.pTagSchema[i].name);
@@ -378,6 +379,7 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
       pReq->stbCfg.pTagSchema = (SSchema *)taosMemoryMalloc(pReq->stbCfg.nTagCols * sizeof(SSchema));
       for (col_id_t i = 0; i < pReq->stbCfg.nTagCols; ++i) {
         buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pTagSchema[i].type));
+        buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pTagSchema[i].index));
         buf = taosDecodeFixedI16(buf, &pReq->stbCfg.pTagSchema[i].colId);
         buf = taosDecodeFixedI32(buf, &pReq->stbCfg.pTagSchema[i].bytes);
         buf = taosDecodeStringTo(buf, pReq->stbCfg.pTagSchema[i].name);
@@ -868,7 +870,7 @@ int32_t tSerializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
 
   // status
   if (tEncodeI32(&encoder, pReq->sver) < 0) return -1;
-  if (tEncodeI64(&encoder, pReq->dver) < 0) return -1;
+  if (tEncodeI64(&encoder, pReq->dnodeVer) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->clusterId) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->rebootTime) < 0) return -1;
@@ -913,7 +915,7 @@ int32_t tDeserializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
 
   // status
   if (tDecodeI32(&decoder, &pReq->sver) < 0) return -1;
-  if (tDecodeI64(&decoder, &pReq->dver) < 0) return -1;
+  if (tDecodeI64(&decoder, &pReq->dnodeVer) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->clusterId) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->rebootTime) < 0) return -1;
@@ -958,6 +960,8 @@ int32_t tDeserializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
   return 0;
 }
 
+void tFreeSStatusReq(SStatusReq *pReq) { taosArrayDestroy(pReq->pVloads); }
+
 int32_t tSerializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -965,7 +969,7 @@ int32_t tSerializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
   if (tStartEncode(&encoder) < 0) return -1;
 
   // status
-  if (tEncodeI64(&encoder, pRsp->dver) < 0) return -1;
+  if (tEncodeI64(&encoder, pRsp->dnodeVer) < 0) return -1;
 
   // dnode cfg
   if (tEncodeI32(&encoder, pRsp->dnodeCfg.dnodeId) < 0) return -1;
@@ -996,7 +1000,7 @@ int32_t tDeserializeSStatusRsp(void *buf, int32_t bufLen, SStatusRsp *pRsp) {
   if (tStartDecode(&decoder) < 0) return -1;
 
   // status
-  if (tDecodeI64(&decoder, &pRsp->dver) < 0) return -1;
+  if (tDecodeI64(&decoder, &pRsp->dnodeVer) < 0) return -1;
 
   // cluster cfg
   if (tDecodeI32(&decoder, &pRsp->dnodeCfg.dnodeId) < 0) return -1;
@@ -1960,7 +1964,7 @@ int32_t tDeserializeSUseDbBatchRsp(void *buf, int32_t bufLen, SUseDbBatchRsp *pR
   int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
   if (tDecodeI32(&decoder, &numOfBatch) < 0) return -1;
 
-  pRsp->pArray = taosArrayInit(numOfBatch, sizeof(SUseDbBatchRsp));
+  pRsp->pArray = taosArrayInit(numOfBatch, sizeof(SUseDbRsp));
   if (pRsp->pArray == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -2134,7 +2138,6 @@ int32_t tDeserializeSUserIndexRsp(void* buf, int32_t bufLen, SUserIndexRsp* pRsp
   return 0;
 }
 
-
 int32_t tSerializeSShowReq(void *buf, int32_t bufLen, SShowReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -2181,7 +2184,6 @@ int32_t tSerializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableReq
   if (tStartEncode(&encoder) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->showId) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->type) < 0) return -1;
-  if (tEncodeI8(&encoder, pReq->free) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->tb) < 0) return -1;
   tEndEncode(&encoder);
@@ -2198,7 +2200,6 @@ int32_t tDeserializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableR
   if (tStartDecode(&decoder) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->showId) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->type) < 0) return -1;
-  if (tDecodeI8(&decoder, &pReq->free) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->tb) < 0) return -1;
   tEndDecode(&decoder);
@@ -2531,6 +2532,7 @@ int32_t tSerializeSConnectReq(void *buf, int32_t bufLen, SConnectReq *pReq) {
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
 
   if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->connType) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->pid) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->app) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
@@ -2547,6 +2549,7 @@ int32_t tDeserializeSConnectReq(void *buf, int32_t bufLen, SConnectReq *pReq) {
   tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
 
   if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->connType) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->pid) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->app) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
@@ -2566,6 +2569,7 @@ int32_t tSerializeSConnectRsp(void *buf, int32_t bufLen, SConnectRsp *pRsp) {
   if (tEncodeI64(&encoder, pRsp->clusterId) < 0) return -1;
   if (tEncodeI32(&encoder, pRsp->connId) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->superUser) < 0) return -1;
+  if (tEncodeI8(&encoder, pRsp->connType) < 0) return -1;
   if (tEncodeSEpSet(&encoder, &pRsp->epSet) < 0) return -1;
   if (tEncodeCStr(&encoder, pRsp->sVersion) < 0) return -1;
   tEndEncode(&encoder);
@@ -2584,6 +2588,7 @@ int32_t tDeserializeSConnectRsp(void *buf, int32_t bufLen, SConnectRsp *pRsp) {
   if (tDecodeI64(&decoder, &pRsp->clusterId) < 0) return -1;
   if (tDecodeI32(&decoder, &pRsp->connId) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->superUser) < 0) return -1;
+  if (tDecodeI8(&decoder, &pRsp->connType) < 0) return -1;
   if (tDecodeSEpSet(&decoder, &pRsp->epSet) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pRsp->sVersion) < 0) return -1;
   tEndDecode(&decoder);

source/common/src/trow.c

@@ -385,7 +385,6 @@ int tdAppendValToDataCol(SDataCol *pCol, TDRowValT valType, const void *val, int
     pCol->len += pCol->bytes;
   }
 #ifdef TD_SUPPORT_BITMAP
-
     tdSetBitmapValType(pCol->pBitmap, numOfRows, valType, bitmapMode);
 #endif
   return 0;
@@ -486,7 +485,7 @@ static int32_t tdAppendKvRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols
  * @param pCols
  * @param forceSetNull
  */
-int32_t tdAppendSTSRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols *pCols, bool forceSetNull) {
+int32_t tdAppendSTSRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols *pCols) {
   if (TD_IS_TP_ROW(pRow)) {
     return tdAppendTpRowToDataCol(pRow, pSchema, pCols);
   } else if (TD_IS_KV_ROW(pRow)) {
@@ -497,7 +496,7 @@ int32_t tdAppendSTSRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols *pCol
   return TSDB_CODE_SUCCESS;
 }
 
-int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int *pOffset, bool forceSetNull) {
+int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int *pOffset, bool forceSetNull, TDRowVerT maxVer) {
   ASSERT(rowsToMerge > 0 && rowsToMerge <= source->numOfRows);
   ASSERT(target->numOfCols == source->numOfCols);
   int offset = 0;
@@ -510,6 +509,7 @@ int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int *
 
   if ((target->numOfRows == 0) || (dataColsKeyLast(target) < dataColsKeyAtRow(source, *pOffset))) {  // No overlap
     ASSERT(target->numOfRows + rowsToMerge <= target->maxPoints);
+    // TODO: filter the maxVer
     for (int i = 0; i < rowsToMerge; i++) {
       for (int j = 0; j < source->numOfCols; j++) {
         if (source->cols[j].len > 0 || target->cols[j].len > 0) {
@@ -555,9 +555,9 @@ static void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, i
     // TKEY  tkey2 = (*iter2 >= limit2) ? TKEY_NULL : dataColsTKeyAt(src2, *iter2);
 
     ASSERT(tkey1 == TKEY_NULL || (!TKEY_IS_DELETED(tkey1)));
-
+    // TODO: filter the maxVer
     if (key1 < key2) {
-      for (int i = 0; i < src1->numOfCols; i++) {
+      for (int i = 0; i < src1->numOfCols; ++i) {
         ASSERT(target->cols[i].type == src1->cols[i].type);
         if (src1->cols[i].len > 0 || target->cols[i].len > 0) {
           SCellVal sVal = {0};
@@ -568,12 +568,12 @@ static void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, i
         }
       }
 
-      target->numOfRows++;
+      ++target->numOfRows;
-      (*iter1)++;
+      ++(*iter1);
     } else if (key1 >= key2) {
-      // if ((key1 > key2) || (key1 == key2 && !TKEY_IS_DELETED(tkey2))) {
+      // TODO: filter the maxVer
-      if ((key1 > key2) || (key1 == key2)) {
+      if ((key1 > key2) || ((key1 == key2) && !TKEY_IS_DELETED(key2))) {
-        for (int i = 0; i < src2->numOfCols; i++) {
+        for (int i = 0; i < src2->numOfCols; ++i) {
           SCellVal sVal = {0};
           ASSERT(target->cols[i].type == src2->cols[i].type);
           if (tdGetColDataOfRow(&sVal, src2->cols + i, *iter2, src2->bitmapMode) < 0) {
@@ -590,11 +590,11 @@ static void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, i
             dataColSetNullAt(&target->cols[i], target->numOfRows, true, target->bitmapMode);
           }
         }
-        target->numOfRows++;
+        ++target->numOfRows;
       }
 
-      (*iter2)++;
+      ++(*iter2);
-      if (key1 == key2) (*iter1)++;
+      if (key1 == key2) ++(*iter1);
     }
 
     ASSERT(target->numOfRows <= target->maxPoints);

source/common/src/ttime.c

@@ -70,7 +70,7 @@ void           deltaToUtcInitOnce() {
   struct tm tm = {0};
 
   (void)taosStrpTime("1970-01-01 00:00:00", (const char*)("%Y-%m-%d %H:%M:%S"), &tm);
-  m_deltaUtc = (int64_t)mktime(&tm);
+  m_deltaUtc = (int64_t)taosMktime(&tm);
   // printf("====delta:%lld\n\n", seconds);
 }
 
@@ -344,7 +344,7 @@ int32_t parseLocaltimeDst(char* timestr, int64_t* time, int32_t timePrec) {
   }
 
   /* mktime will be affected by TZ, set by using taos_options */
-  int64_t seconds = mktime(&tm);
+  int64_t seconds = taosMktime(&tm);
 
   int64_t fraction = 0;
 
@@ -409,6 +409,30 @@ int64_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char
   }
 }
 
+int32_t convertStringToTimestamp(int16_t type, char *inputData, int64_t timePrec, int64_t *timeVal) {
+  int32_t charLen = varDataLen(inputData);
+  char *newColData;
+  if (type == TSDB_DATA_TYPE_BINARY) {
+    newColData = taosMemoryCalloc(1,  charLen + 1);
+    memcpy(newColData, varDataVal(inputData), charLen);
+    taosParseTime(newColData, timeVal, charLen, (int32_t)timePrec, 0);
+    taosMemoryFree(newColData);
+  } else if (type == TSDB_DATA_TYPE_NCHAR) {
+    newColData = taosMemoryCalloc(1,  charLen / TSDB_NCHAR_SIZE + 1);
+    int len = taosUcs4ToMbs((TdUcs4 *)varDataVal(inputData), charLen, newColData);
+    if (len < 0){
+      taosMemoryFree(newColData);
+      return TSDB_CODE_FAILED;
+    }
+    newColData[len] = 0;
+    taosParseTime(newColData, timeVal, len + 1, (int32_t)timePrec, 0);
+    taosMemoryFree(newColData);
+  } else {
+    return TSDB_CODE_FAILED;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t timePrecision) {
   switch (unit) {
     case 's':
@@ -515,7 +539,7 @@ int64_t taosTimeAdd(int64_t t, int64_t duration, char unit, int32_t precision) {
   tm.tm_year = mon / 12;
   tm.tm_mon = mon % 12;
 
-  return (int64_t)(mktime(&tm) * TSDB_TICK_PER_SECOND(precision));
+  return (int64_t)(taosMktime(&tm) * TSDB_TICK_PER_SECOND(precision));
 }
 
 int32_t taosTimeCountInterval(int64_t skey, int64_t ekey, int64_t interval, char unit, int32_t precision) {
@@ -574,7 +598,7 @@ int64_t taosTimeTruncate(int64_t t, const SInterval* pInterval, int32_t precisio
       tm.tm_mon = mon % 12;
     }
 
-    start = (int64_t)(mktime(&tm) * TSDB_TICK_PER_SECOND(precision));
+    start = (int64_t)(taosMktime(&tm) * TSDB_TICK_PER_SECOND(precision));
   } else {
     int64_t delta = t - pInterval->interval;
     int32_t factor = (delta >= 0) ? 1 : -1;
@@ -721,7 +745,7 @@ void taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precision)
       assert(false);
   }
 
-  ptm = localtime(&quot);
+  ptm = taosLocalTime(&quot, NULL);
   int32_t length = (int32_t)strftime(ts, 40, "%Y-%m-%dT%H:%M:%S", ptm);
   length += snprintf(ts + length, fractionLen, format, mod);
   length += (int32_t)strftime(ts + length, 40 - length, "%z", ptm);

source/common/src/ttszip.c

@@ -39,7 +39,7 @@ STSBuf* tsBufCreate(bool autoDelete, int32_t order) {
 
   taosGetTmpfilePath(tsTempDir, "join", pTSBuf->path);
   // pTSBuf->pFile = fopen(pTSBuf->path, "wb+");
-  pTSBuf->pFile = taosOpenFile(pTSBuf->path, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_READ | TD_FILE_TRUNC);
+  pTSBuf->pFile = taosOpenFile(pTSBuf->path, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_READ | TD_FILE_TRUNC);
   if (pTSBuf->pFile == NULL) {
     taosMemoryFree(pTSBuf);
     return NULL;

source/common/src/tvariant.c

@@ -1031,10 +1031,15 @@ char * taosVariantGet(SVariant *pVar, int32_t type) {
     case TSDB_DATA_TYPE_BOOL:
     case TSDB_DATA_TYPE_TINYINT:
     case TSDB_DATA_TYPE_SMALLINT:
-    case TSDB_DATA_TYPE_BIGINT:
     case TSDB_DATA_TYPE_INT:
+    case TSDB_DATA_TYPE_BIGINT:
     case TSDB_DATA_TYPE_TIMESTAMP:
       return (char *)&pVar->i;
+    case TSDB_DATA_TYPE_UTINYINT:
+    case TSDB_DATA_TYPE_USMALLINT:
+    case TSDB_DATA_TYPE_UINT:
+    case TSDB_DATA_TYPE_UBIGINT:
+      return (char *)&pVar->u;
     case TSDB_DATA_TYPE_DOUBLE:
     case TSDB_DATA_TYPE_FLOAT:
       return (char *)&pVar->d;

source/dnode/mgmt/CMakeLists.txt

@@ -1,28 +1,16 @@
-aux_source_directory(dm DNODE_SRC)
+add_subdirectory(interface)
-aux_source_directory(qm DNODE_SRC)
+add_subdirectory(implement)
-aux_source_directory(bm DNODE_SRC)
+add_subdirectory(mgmt_bnode)
-aux_source_directory(sm DNODE_SRC)
+add_subdirectory(mgmt_mnode)
-aux_source_directory(vm DNODE_SRC)
+add_subdirectory(mgmt_qnode)
-aux_source_directory(mm DNODE_SRC)
+add_subdirectory(mgmt_snode)
-aux_source_directory(main DNODE_SRC)
+add_subdirectory(mgmt_vnode)
-add_library(dnode STATIC ${DNODE_SRC})
+add_subdirectory(test)
-target_link_libraries(
-    dnode cjson mnode vnode qnode snode bnode wal sync taos tfs monitor
-)
-target_include_directories(
-    dnode
-    PUBLIC "${TD_SOURCE_DIR}/include/dnode/mgmt"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-)
 
 aux_source_directory(exe EXEC_SRC)
 add_executable(taosd ${EXEC_SRC})
 target_include_directories(
     taosd
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/implement/inc"
 )
 target_link_libraries(taosd dnode)
-
-if(${BUILD_TEST})
-    add_subdirectory(test)
-endif(${BUILD_TEST})

source/dnode/mgmt/dm/dmHandle.c

@@ -1,216 +0,0 @@
-/*
- * 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"
-
-void dmSendStatusReq(SDnodeMgmt *pMgmt) {
-  SDnode    *pDnode = pMgmt->pDnode;
-  SStatusReq req = {0};
-
-  taosRLockLatch(&pMgmt->latch);
-  req.sver = tsVersion;
-  req.dver = pMgmt->dver;
-  req.dnodeId = pDnode->dnodeId;
-  req.clusterId = pDnode->clusterId;
-  req.rebootTime = pDnode->rebootTime;
-  req.updateTime = pMgmt->updateTime;
-  req.numOfCores = tsNumOfCores;
-  req.numOfSupportVnodes = pDnode->numOfSupportVnodes;
-  tstrncpy(req.dnodeEp, pDnode->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->latch);
-
-  SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, VNODES);
-  if (pWrapper != NULL) {
-    SMonVloadInfo info = {0};
-    dmGetVnodeLoads(pWrapper, &info);
-    req.pVloads = info.pVloads;
-    dndReleaseWrapper(pWrapper);
-  }
-
-  int32_t contLen = tSerializeSStatusReq(NULL, 0, &req);
-  void   *pHead = rpcMallocCont(contLen);
-  tSerializeSStatusReq(pHead, contLen, &req);
-  taosArrayDestroy(req.pVloads);
-
-  SRpcMsg rpcMsg = {.pCont = pHead, .contLen = contLen, .msgType = TDMT_MND_STATUS, .ahandle = (void *)0x9527};
-  pMgmt->statusSent = 1;
-
-  dTrace("send req:%s to mnode, app:%p", TMSG_INFO(rpcMsg.msgType), rpcMsg.ahandle);
-  SEpSet epSet = {0};
-  dmGetMnodeEpSet(pMgmt, &epSet);
-  tmsgSendReq(&pMgmt->msgCb, &epSet, &rpcMsg);
-}
-
-static void dmUpdateDnodeCfg(SDnodeMgmt *pMgmt, SDnodeCfg *pCfg) {
-  SDnode *pDnode = pMgmt->pDnode;
-
-  if (pDnode->dnodeId == 0) {
-    dInfo("set dnodeId:%d clusterId:%" PRId64, pCfg->dnodeId, pCfg->clusterId);
-    taosWLockLatch(&pMgmt->latch);
-    pDnode->dnodeId = pCfg->dnodeId;
-    pDnode->clusterId = pCfg->clusterId;
-    dmWriteFile(pMgmt);
-    taosWUnLockLatch(&pMgmt->latch);
-  }
-}
-
-int32_t dmProcessStatusRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
-  SDnode  *pDnode = pMgmt->pDnode;
-  SRpcMsg *pRsp = &pMsg->rpcMsg;
-
-  if (pRsp->code != TSDB_CODE_SUCCESS) {
-    if (pRsp->code == TSDB_CODE_MND_DNODE_NOT_EXIST && !pDnode->dropped && pDnode->dnodeId > 0) {
-      dInfo("dnode:%d, set to dropped since not exist in mnode", pDnode->dnodeId);
-      pDnode->dropped = 1;
-      dmWriteFile(pMgmt);
-    }
-  } else {
-    SStatusRsp statusRsp = {0};
-    if (pRsp->pCont != NULL && pRsp->contLen != 0 &&
-        tDeserializeSStatusRsp(pRsp->pCont, pRsp->contLen, &statusRsp) == 0) {
-      pMgmt->dver = statusRsp.dver;
-      dmUpdateDnodeCfg(pMgmt, &statusRsp.dnodeCfg);
-      dmUpdateDnodeEps(pMgmt, statusRsp.pDnodeEps);
-    }
-    tFreeSStatusRsp(&statusRsp);
-  }
-
-  pMgmt->statusSent = 0;
-  return TSDB_CODE_SUCCESS;
-}
-
-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 int32_t dmProcessCreateNodeMsg(SDnode *pDnode, EDndType ntype, SNodeMsg *pMsg) {
-  SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, ntype);
-  if (pWrapper != NULL) {
-    dndReleaseWrapper(pWrapper);
-    terrno = TSDB_CODE_NODE_ALREADY_DEPLOYED;
-    dError("failed to create node since %s", terrstr());
-    return -1;
-  }
-
-  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.createMsgFp)(pWrapper, pMsg);
-  if (code != 0) {
-    dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
-  } else {
-    dDebug("node:%s, has been opened", pWrapper->name);
-    pWrapper->deployed = true;
-  }
-
-  return code;
-}
-
-static int32_t dmProcessDropNodeMsg(SDnode *pDnode, EDndType ntype, SNodeMsg *pMsg) {
-  SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, ntype);
-  if (pWrapper == NULL) {
-    terrno = TSDB_CODE_NODE_NOT_DEPLOYED;
-    dError("failed to drop node since %s", terrstr());
-    return -1;
-  }
-
-  taosWLockLatch(&pWrapper->latch);
-  pWrapper->deployed = false;
-
-  int32_t code = (*pWrapper->fp.dropMsgFp)(pWrapper, pMsg);
-  if (code != 0) {
-    pWrapper->deployed = true;
-    dError("node:%s, failed to drop since %s", pWrapper->name, terrstr());
-  } else {
-    pWrapper->deployed = false;
-    dDebug("node:%s, has been dropped", pWrapper->name);
-  }
-
-  taosWUnLockLatch(&pWrapper->latch);
-  dndReleaseWrapper(pWrapper);
-  return code;
-}
-
-int32_t dmProcessCDnodeReq(SDnode *pDnode, SNodeMsg *pMsg) {
-  switch (pMsg->rpcMsg.msgType) {
-    case TDMT_DND_CREATE_MNODE:
-      return dmProcessCreateNodeMsg(pDnode, MNODE, pMsg);
-    case TDMT_DND_DROP_MNODE:
-      return dmProcessDropNodeMsg(pDnode, MNODE, pMsg);
-    case TDMT_DND_CREATE_QNODE:
-      return dmProcessCreateNodeMsg(pDnode, QNODE, pMsg);
-    case TDMT_DND_DROP_QNODE:
-      return dmProcessDropNodeMsg(pDnode, QNODE, pMsg);
-    case TDMT_DND_CREATE_SNODE:
-      return dmProcessCreateNodeMsg(pDnode, SNODE, pMsg);
-    case TDMT_DND_DROP_SNODE:
-      return dmProcessDropNodeMsg(pDnode, SNODE, pMsg);
-    case TDMT_DND_CREATE_BNODE:
-      return dmProcessCreateNodeMsg(pDnode, BNODE, pMsg);
-    case TDMT_DND_DROP_BNODE:
-      return dmProcessDropNodeMsg(pDnode, BNODE, pMsg);
-    default:
-      terrno = TSDB_CODE_MSG_NOT_PROCESSED;
-      return -1;
-  }
-}
-
-void dmInitMsgHandle(SMgmtWrapper *pWrapper) {
-  // Requests handled by DNODE
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_MNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_MNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_QNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_QNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_SNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_SNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_BNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_BNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CONFIG_DNODE, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_DND_NETWORK_TEST, dmProcessMgmtMsg, DEFAULT_HANDLE);
-
-  // Requests handled by MNODE
-  dndSetMsgHandle(pWrapper, TDMT_MND_STATUS_RSP, dmProcessMonitorMsg, DEFAULT_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_MND_GRANT_RSP, dmProcessMgmtMsg, DEFAULT_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_MND_AUTH_RSP, dmProcessMgmtMsg, DEFAULT_HANDLE);
-}

source/dnode/mgmt/dm/dmInt.c

@@ -1,171 +0,0 @@
-/*
- * 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"
-
-void dmGetMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet) {
-  taosRLockLatch(&pMgmt->latch);
-  *pEpSet = pMgmt->mnodeEpSet;
-  taosRUnLockLatch(&pMgmt->latch);
-}
-
-void dmUpdateMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet) {
-  dInfo("mnode is changed, num:%d use:%d", pEpSet->numOfEps, pEpSet->inUse);
-
-  taosWLockLatch(&pMgmt->latch);
-  pMgmt->mnodeEpSet = *pEpSet;
-  for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
-    dInfo("mnode index:%d %s:%u", i, pEpSet->eps[i].fqdn, pEpSet->eps[i].port);
-  }
-
-  taosWUnLockLatch(&pMgmt->latch);
-}
-
-void dmGetDnodeEp(SMgmtWrapper *pWrapper, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t *pPort) {
-  SDnodeMgmt *pMgmt = pWrapper->pMgmt;
-  taosRLockLatch(&pMgmt->latch);
-
-  SDnodeEp *pDnodeEp = taosHashGet(pMgmt->dnodeHash, &dnodeId, sizeof(int32_t));
-  if (pDnodeEp != NULL) {
-    if (pPort != NULL) {
-      *pPort = pDnodeEp->ep.port;
-    }
-    if (pFqdn != NULL) {
-      tstrncpy(pFqdn, pDnodeEp->ep.fqdn, TSDB_FQDN_LEN);
-    }
-    if (pEp != NULL) {
-      snprintf(pEp, TSDB_EP_LEN, "%s:%u", pDnodeEp->ep.fqdn, pDnodeEp->ep.port);
-    }
-  }
-
-  taosRUnLockLatch(&pMgmt->latch);
-}
-
-void dmSendRedirectRsp(SDnodeMgmt *pMgmt, const SRpcMsg *pReq) {
-  SDnode *pDnode = pMgmt->pDnode;
-
-  SEpSet epSet = {0};
-  dmGetMnodeEpSet(pMgmt, &epSet);
-
-  dDebug("RPC %p, req is redirected, num:%d use:%d", pReq->handle, epSet.numOfEps, epSet.inUse);
-  for (int32_t i = 0; i < epSet.numOfEps; ++i) {
-    dDebug("mnode index:%d %s:%u", i, epSet.eps[i].fqdn, epSet.eps[i].port);
-    if (strcmp(epSet.eps[i].fqdn, pDnode->localFqdn) == 0 && epSet.eps[i].port == pDnode->serverPort) {
-      epSet.inUse = (i + 1) % epSet.numOfEps;
-    }
-
-    epSet.eps[i].port = htons(epSet.eps[i].port);
-  }
-
-  rpcSendRedirectRsp(pReq->handle, &epSet);
-}
-
-static int32_t dmStart(SMgmtWrapper *pWrapper) {
-  dDebug("dnode-mgmt start to run");
-  return dmStartThread(pWrapper->pMgmt);
-}
-
-static int32_t dmInit(SMgmtWrapper *pWrapper) {
-  SDnode     *pDnode = pWrapper->pDnode;
-  SDnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SDnodeMgmt));
-  dInfo("dnode-mgmt start to init");
-
-  pDnode->dnodeId = 0;
-  pDnode->dropped = 0;
-  pDnode->clusterId = 0;
-  pMgmt->path = pWrapper->path;
-  pMgmt->pDnode = pDnode;
-  pMgmt->pWrapper = pWrapper;
-  taosInitRWLatch(&pMgmt->latch);
-
-  pMgmt->dnodeHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
-  if (pMgmt->dnodeHash == NULL) {
-    dError("failed to init dnode hash");
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  if (dmReadFile(pMgmt) != 0) {
-    dError("failed to read file since %s", terrstr());
-    return -1;
-  }
-
-  if (pDnode->dropped) {
-    dError("dnode will not start since its already dropped");
-    return -1;
-  }
-
-  if (dmStartWorker(pMgmt) != 0) {
-    return -1;
-  }
-
-  if (dndInitTrans(pDnode) != 0) {
-    dError("failed to init transport since %s", terrstr());
-    return -1;
-  }
-
-  pWrapper->pMgmt = pMgmt;
-  pMgmt->msgCb = dndCreateMsgcb(pWrapper);
-
-  dInfo("dnode-mgmt is initialized");
-  return 0;
-}
-
-static void dmCleanup(SMgmtWrapper *pWrapper) {
-  SDnodeMgmt *pMgmt = pWrapper->pMgmt;
-  if (pMgmt == NULL) return;
-
-  dInfo("dnode-mgmt start to clean up");
-  SDnode *pDnode = pMgmt->pDnode;
-  dmStopWorker(pMgmt);
-
-  taosWLockLatch(&pMgmt->latch);
-
-  if (pMgmt->dnodeEps != NULL) {
-    taosArrayDestroy(pMgmt->dnodeEps);
-    pMgmt->dnodeEps = NULL;
-  }
-
-  if (pMgmt->dnodeHash != NULL) {
-    taosHashCleanup(pMgmt->dnodeHash);
-    pMgmt->dnodeHash = NULL;
-  }
-
-  taosWUnLockLatch(&pMgmt->latch);
-
-  taosMemoryFree(pMgmt);
-  pWrapper->pMgmt = NULL;
-  dndCleanupTrans(pDnode);
-
-  dInfo("dnode-mgmt is cleaned up");
-}
-
-static int32_t dmRequire(SMgmtWrapper *pWrapper, bool *required) {
-  *required = true;
-  return 0;
-}
-
-void dmSetMgmtFp(SMgmtWrapper *pWrapper) {
-  SMgmtFp mgmtFp = {0};
-  mgmtFp.openFp = dmInit;
-  mgmtFp.closeFp = dmCleanup;
-  mgmtFp.startFp = dmStart;
-  mgmtFp.requiredFp = dmRequire;
-
-  dmInitMsgHandle(pWrapper);
-  pWrapper->name = "dnode";
-  pWrapper->fp = mgmtFp;
-}

source/dnode/mgmt/dm/dmWorker.c

@@ -1,142 +0,0 @@
-/*
- * 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 *dmThreadRoutine(void *param) {
-  SDnodeMgmt *pMgmt = param;
-  SDnode     *pDnode = pMgmt->pDnode;
-  int64_t     lastStatusTime = taosGetTimestampMs();
-  int64_t     lastMonitorTime = lastStatusTime;
-
-  setThreadName("dnode-hb");
-
-  while (true) {
-    taosThreadTestCancel();
-    taosMsleep(200);
-    if (dndGetStatus(pDnode) != DND_STAT_RUNNING || pDnode->dropped) {
-      continue;
-    }
-
-    int64_t curTime = taosGetTimestampMs();
-    float   statusInterval = (curTime - lastStatusTime) / 1000.0f;
-    if (statusInterval >= tsStatusInterval && !pMgmt->statusSent) {
-      dmSendStatusReq(pMgmt);
-      lastStatusTime = curTime;
-    }
-
-    float monitorInterval = (curTime - lastMonitorTime) / 1000.0f;
-    if (monitorInterval >= tsMonitorInterval) {
-      dmSendMonitorReport(pDnode);
-      lastMonitorTime = curTime;
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t dmStartThread(SDnodeMgmt *pMgmt) {
-  pMgmt->threadId = taosCreateThread(dmThreadRoutine, pMgmt);
-  if (pMgmt->threadId == NULL) {
-    dError("failed to init dnode thread");
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  return 0;
-}
-
-static void dmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
-  SDnodeMgmt *pMgmt = pInfo->ahandle;
-
-  SDnode  *pDnode = pMgmt->pDnode;
-  SRpcMsg *pRpc = &pMsg->rpcMsg;
-  int32_t  code = -1;
-  dTrace("msg:%p, will be processed in dnode queue", pMsg);
-
-  switch (pRpc->msgType) {
-    case TDMT_DND_CONFIG_DNODE:
-      code = dmProcessConfigReq(pMgmt, pMsg);
-      break;
-    case TDMT_MND_STATUS_RSP:
-      code = dmProcessStatusRsp(pMgmt, pMsg);
-      break;
-    case TDMT_MND_AUTH_RSP:
-      code = dmProcessAuthRsp(pMgmt, pMsg);
-      break;
-    case TDMT_MND_GRANT_RSP:
-      code = dmProcessGrantRsp(pMgmt, pMsg);
-      break;
-    default:
-      code = dmProcessCDnodeReq(pMgmt->pDnode, pMsg);
-      break;
-  }
-
-  if (pRpc->msgType & 1u) {
-    if (code != 0) code = terrno;
-    SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = code};
-    rpcSendResponse(&rsp);
-  }
-
-  dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-  rpcFreeCont(pMsg->rpcMsg.pCont);
-  taosFreeQitem(pMsg);
-}
-
-int32_t dmStartWorker(SDnodeMgmt *pMgmt) {
-  SSingleWorkerCfg mcfg = {.min = 1, .max = 1, .name = "dnode-mgmt", .fp = (FItem)dmProcessQueue, .param = pMgmt};
-  if (tSingleWorkerInit(&pMgmt->mgmtWorker, &mcfg) != 0) {
-    dError("failed to start dnode mgmt worker since %s", terrstr());
-    return -1;
-  }
-
-  SSingleWorkerCfg scfg = {.min = 1, .max = 1, .name = "dnode-monitor", .fp = (FItem)dmProcessQueue, .param = pMgmt};
-  if (tSingleWorkerInit(&pMgmt->monitorWorker, &scfg) != 0) {
-    dError("failed to start dnode monitor worker since %s", terrstr());
-    return -1;
-  }
-
-  dDebug("dnode workers are initialized");
-  return 0;
-}
-
-void dmStopWorker(SDnodeMgmt *pMgmt) {
-  tSingleWorkerCleanup(&pMgmt->mgmtWorker);
-  tSingleWorkerCleanup(&pMgmt->monitorWorker);
-
-  if (pMgmt->threadId != NULL) {
-    taosDestoryThread(pMgmt->threadId);
-    pMgmt->threadId = NULL;
-  }
-  dDebug("dnode workers are closed");
-}
-
-int32_t dmProcessMgmtMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SDnodeMgmt    *pMgmt = pWrapper->pMgmt;
-  SSingleWorker *pWorker = &pMgmt->mgmtWorker;
-
-  dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
-  taosWriteQitem(pWorker->queue, pMsg);
-  return 0;
-}
-
-int32_t dmProcessMonitorMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
-  SDnodeMgmt    *pMgmt = pWrapper->pMgmt;
-  SSingleWorker *pWorker = &pMgmt->monitorWorker;
-
-  dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
-  taosWriteQitem(pWorker->queue, pMsg);
-  return 0;
-}

source/dnode/mgmt/exe/dmMain.c

@@ -14,7 +14,7 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dndInt.h"
+#include "dmImp.h"
 #include "tconfig.h"
 
 static struct {
@@ -26,34 +26,34 @@ static struct {
   char         apolloUrl[PATH_MAX];
   SArray      *pArgs;  // SConfigPair
   SDnode      *pDnode;
-  EDndType ntype;
+  EDndNodeType ntype;
 } global = {0};
 
-static void dndStopDnode(int signum, void *info, void *ctx) {
+static void dmStopDnode(int signum, void *info, void *ctx) {
   SDnode *pDnode = atomic_val_compare_exchange_ptr(&global.pDnode, 0, global.pDnode);
   if (pDnode != NULL) {
-    dndHandleEvent(pDnode, DND_EVENT_STOP);
+    dmSetEvent(pDnode, DND_EVENT_STOP);
   }
 }
 
-static void dndSetSignalHandle() {
+static void dmSetSignalHandle() {
-  taosSetSignal(SIGTERM, dndStopDnode);
+  taosSetSignal(SIGTERM, dmStopDnode);
-  taosSetSignal(SIGHUP, dndStopDnode);
+  taosSetSignal(SIGHUP, dmStopDnode);
-  taosSetSignal(SIGINT, dndStopDnode);
+  taosSetSignal(SIGINT, dmStopDnode);
-  taosSetSignal(SIGTSTP, dndStopDnode);
+  taosSetSignal(SIGTSTP, dmStopDnode);
-  taosSetSignal(SIGABRT, dndStopDnode);
+  taosSetSignal(SIGABRT, dmStopDnode);
-  taosSetSignal(SIGBREAK, dndStopDnode);
+  taosSetSignal(SIGBREAK, dmStopDnode);
-  taosSetSignal(SIGQUIT, dndStopDnode);
+  taosSetSignal(SIGQUIT, dmStopDnode);
 
   if (!tsMultiProcess) {
-  } else if (global.ntype == DNODE || global.ntype == NODE_MAX) {
+  } else if (global.ntype == DNODE || global.ntype == NODE_END) {
     taosIgnSignal(SIGCHLD);
   } else {
     taosKillChildOnParentStopped();
   }
 }
 
-static int32_t dndParseArgs(int32_t argc, char const *argv[]) {
+static int32_t dmParseArgs(int32_t argc, char const *argv[]) {
   for (int32_t i = 1; i < argc; ++i) {
     if (strcmp(argv[i], "-c") == 0) {
       if (i < argc - 1) {
@@ -72,8 +72,8 @@ static int32_t dndParseArgs(int32_t argc, char const *argv[]) {
       tstrncpy(global.envFile, argv[++i], PATH_MAX);
     } else if (strcmp(argv[i], "-n") == 0) {
       global.ntype = atoi(argv[++i]);
-      if (global.ntype <= DNODE || global.ntype > NODE_MAX) {
+      if (global.ntype <= DNODE || global.ntype > NODE_END) {
-        printf("'-n' range is [1 - %d], default is 0\n", NODE_MAX - 1);
+        printf("'-n' range is [1 - %d], default is 0\n", NODE_END - 1);
         return -1;
       }
     } else if (strcmp(argv[i], "-k") == 0) {
@@ -89,12 +89,9 @@ static int32_t dndParseArgs(int32_t argc, char const *argv[]) {
   return 0;
 }
 
-static void dndGenerateGrant() {
+static void dmGenerateGrant() { mndGenerateMachineCode(); }
-  // grantParseParameter();
-  printf("this feature is not implemented yet\n");
-}
 
-static void dndPrintVersion() {
+static void dmPrintVersion() {
 #ifdef TD_ENTERPRISE
   char *releaseName = "enterprise";
 #else
@@ -105,12 +102,12 @@ static void dndPrintVersion() {
   printf("buildInfo: %s\n", buildinfo);
 }
 
-static void dndDumpCfg() {
+static void dmDumpCfg() {
   SConfig *pCfg = taosGetCfg();
   cfgDumpCfg(pCfg, 0, 1);
 }
 
-static SDnodeOpt dndGetOpt() {
+static SDnodeOpt dmGetOpt() {
   SConfig  *pCfg = taosGetCfg();
   SDnodeOpt option = {0};
 
@@ -127,43 +124,43 @@ static SDnodeOpt dndGetOpt() {
   return option;
 }
 
-static int32_t dndInitLog() {
+static int32_t dmInitLog() {
   char logName[12] = {0};
-  snprintf(logName, sizeof(logName), "%slog", dndNodeLogStr(global.ntype));
+  snprintf(logName, sizeof(logName), "%slog", dmLogName(global.ntype));
   return taosCreateLog(logName, 1, configDir, global.envFile, global.apolloUrl, global.pArgs, 0);
 }
 
-static void dndSetProcInfo(int32_t argc, char **argv) {
+static void dmSetProcInfo(int32_t argc, char **argv) {
   taosSetProcPath(argc, argv);
-  if (global.ntype != DNODE && global.ntype != NODE_MAX) {
+  if (global.ntype != DNODE && global.ntype != NODE_END) {
-    const char *name = dndNodeProcStr(global.ntype);
+    const char *name = dmProcName(global.ntype);
     taosSetProcName(argc, argv, name);
   }
 }
 
-static int32_t dndRunDnode() {
+static int32_t dmRunDnode() {
-  if (dndInit() != 0) {
+  if (dmInit() != 0) {
     dError("failed to init environment since %s", terrstr());
     return -1;
   }
 
-  SDnodeOpt option = dndGetOpt();
+  SDnodeOpt option = dmGetOpt();
-  SDnode   *pDnode = dndCreate(&option);
+  SDnode   *pDnode = dmCreate(&option);
   if (pDnode == NULL) {
     dError("failed to to create dnode since %s", terrstr());
     return -1;
   } else {
     global.pDnode = pDnode;
-    dndSetSignalHandle();
+    dmSetSignalHandle();
   }
 
   dInfo("start the service");
-  int32_t code = dndRun(pDnode);
+  int32_t code = dmRun(pDnode);
   dInfo("start shutting down the service");
 
   global.pDnode = NULL;
-  dndClose(pDnode);
+  dmClose(pDnode);
-  dndCleanup();
+  dmCleanup();
   taosCloseLog();
   taosCleanupCfg();
   return code;
@@ -175,22 +172,22 @@ int main(int argc, char const *argv[]) {
     return -1;
   }
 
-  if (dndParseArgs(argc, argv) != 0) {
+  if (dmParseArgs(argc, argv) != 0) {
     printf("failed to start since parse args error\n");
     return -1;
   }
 
   if (global.generateGrant) {
-    dndGenerateGrant();
+    dmGenerateGrant();
     return 0;
   }
 
   if (global.printVersion) {
-    dndPrintVersion();
+    dmPrintVersion();
     return 0;
   }
 
-  if (dndInitLog() != 0) {
+  if (dmInitLog() != 0) {
     printf("failed to start since init log error\n");
     return -1;
   }
@@ -201,12 +198,12 @@ int main(int argc, char const *argv[]) {
   }
 
   if (global.dumpConfig) {
-    dndDumpCfg();
+    dmDumpCfg();
     taosCleanupCfg();
     taosCloseLog();
     return 0;
   }
 
-  dndSetProcInfo(argc, (char **)argv);
+  dmSetProcInfo(argc, (char **)argv);
-  return dndRunDnode();
+  return dmRunDnode();
 }

source/dnode/mgmt/implement/CMakeLists.txt

@@ -0,0 +1,17 @@
+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
+)
+target_include_directories(
+    dnode
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+
+IF (TD_GRANT)
+  TARGET_LINK_LIBRARIES(dnode grant)
+ENDIF ()
+IF (TD_USB_DONGLE)
+  TARGET_LINK_LIBRARIES(dnode usb_dongle)
+else()
+ENDIF ()

source/dnode/mgmt/implement/inc/dmImp.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_DND_IMP_H_
+#define _TD_DND_IMP_H_
+
+#include "dmInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t dmOpenNode(SMgmtWrapper *pWrapper);
+void    dmCloseNode(SMgmtWrapper *pWrapper);
+
+// dmTransport.c
+int32_t  dmInitTrans(SDnode *pDnode);
+void     dmCleanupTrans(SDnode *pDnode);
+SProcCfg dmGenProcCfg(SMgmtWrapper *pWrapper);
+SMsgCb   dmGetMsgcb(SMgmtWrapper *pWrapper);
+int32_t  dmInitMsgHandle(SDnode *pDnode);
+void     dmSendRecv(SDnode *pDnode, SEpSet *pEpSet, SRpcMsg *pReq, SRpcMsg *pRsp);
+void     dmSendToMnodeRecv(SDnode *pDnode, SRpcMsg *pReq, SRpcMsg *pRsp);
+
+// dmEps.c
+int32_t dmReadEps(SDnode *pDnode);
+int32_t dmWriteEps(SDnode *pDnode);
+void    dmUpdateEps(SDnode *pDnode, SArray *pDnodeEps);
+
+// dmHandle.c
+void    dmSendStatusReq(SDnode *pDnode);
+int32_t dmProcessConfigReq(SDnode *pDnode, SNodeMsg *pMsg);
+int32_t dmProcessAuthRsp(SDnode *pDnode, SNodeMsg *pMsg);
+int32_t dmProcessGrantRsp(SDnode *pDnode, SNodeMsg *pMsg);
+int32_t dmProcessCreateNodeReq(SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg);
+int32_t dmProcessDropNodeReq(SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg);
+
+// dmMonitor.c
+void dmGetVnodeLoads(SDnode *pDnode, SMonVloadInfo *pInfo);
+void dmSendMonitorReport(SDnode *pDnode);
+
+// dmWorker.c
+int32_t dmStartStatusThread(SDnode *pDnode);
+void    dmStopStatusThread(SDnode *pDnode);
+int32_t dmStartMonitorThread(SDnode *pDnode);
+void    dmStopMonitorThread(SDnode *pDnode);
+int32_t dmStartWorker(SDnode *pDnode);
+void    dmStopWorker(SDnode *pDnode);
+int32_t dmProcessMgmtMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
+int32_t dmProcessStatusMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
+
+// mgmt nodes
+void dmSetMgmtFp(SMgmtWrapper *pWrapper);
+void bmSetMgmtFp(SMgmtWrapper *pWrapper);
+void qmSetMgmtFp(SMgmtWrapper *pWrapper);
+void smSetMgmtFp(SMgmtWrapper *pWrapper);
+void vmSetMgmtFp(SMgmtWrapper *pWrapper);
+void mmSetMgmtFp(SMgmtWrapper *pWrapper);
+
+void vmGetVnodeLoads(SMgmtWrapper *pWrapper, SMonVloadInfo *pInfo);
+void mmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonMmInfo *mmInfo);
+void vmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonVmInfo *vmInfo);
+void qmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonQmInfo *qmInfo);
+void smGetMonitorInfo(SMgmtWrapper *pWrapper, SMonSmInfo *smInfo);
+void bmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonBmInfo *bmInfo);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_DND_IMP_H_*/

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

@@ -14,32 +14,50 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dmInt.h"
+#include "dmImp.h"
 
-static void dmPrintDnodes(SDnodeMgmt *pMgmt);
+static void dmPrintEps(SDnode *pDnode);
-static bool dmIsEpChanged(SDnodeMgmt *pMgmt, int32_t dnodeId, const char *ep);
+static bool dmIsEpChanged(SDnode *pDnode, int32_t dnodeId, const char *ep);
-static void dmResetDnodes(SDnodeMgmt *pMgmt, SArray *dnodeEps);
+static void dmResetEps(SDnode *pDnode, SArray *dnodeEps);
 
-int32_t dmReadFile(SDnodeMgmt *pMgmt) {
+static void dmGetDnodeEp(SDnode *pDnode, int32_t dnodeId, char *pEp, char *pFqdn, uint16_t *pPort) {
+  taosRLockLatch(&pDnode->data.latch);
+
+  SDnodeEp *pDnodeEp = taosHashGet(pDnode->data.dnodeHash, &dnodeId, sizeof(int32_t));
+  if (pDnodeEp != NULL) {
+    if (pPort != NULL) {
+      *pPort = pDnodeEp->ep.port;
+    }
+    if (pFqdn != NULL) {
+      tstrncpy(pFqdn, pDnodeEp->ep.fqdn, TSDB_FQDN_LEN);
+    }
+    if (pEp != NULL) {
+      snprintf(pEp, TSDB_EP_LEN, "%s:%u", pDnodeEp->ep.fqdn, pDnodeEp->ep.port);
+    }
+  }
+
+  taosRUnLockLatch(&pDnode->data.latch);
+}
+
+int32_t dmReadEps(SDnode *pDnode) {
   int32_t   code = TSDB_CODE_INVALID_JSON_FORMAT;
   int32_t   len = 0;
   int32_t   maxLen = 256 * 1024;
   char     *content = taosMemoryCalloc(1, maxLen + 1);
   cJSON    *root = NULL;
-  char      file[PATH_MAX];
+  char      file[PATH_MAX] = {0};
   TdFilePtr pFile = NULL;
-  SDnode   *pDnode = pMgmt->pDnode;
 
-  pMgmt->dnodeEps = taosArrayInit(1, sizeof(SDnodeEp));
+  pDnode->data.dnodeEps = taosArrayInit(1, sizeof(SDnodeEp));
-  if (pMgmt->dnodeEps == NULL) {
+  if (pDnode->data.dnodeEps == NULL) {
     dError("failed to calloc dnodeEp array since %s", strerror(errno));
     goto PRASE_DNODE_OVER;
   }
 
-  snprintf(file, sizeof(file), "%s%sdnode.json", pMgmt->path, TD_DIRSEP);
+  snprintf(file, sizeof(file), "%s%sdnode.json", pDnode->wrappers[DNODE].path, TD_DIRSEP);
   pFile = taosOpenFile(file, TD_FILE_READ);
   if (pFile == NULL) {
-    dDebug("file %s not exist", file);
+    // dDebug("file %s not exist", file);
     code = 0;
     goto PRASE_DNODE_OVER;
   }
@@ -62,21 +80,21 @@ int32_t dmReadFile(SDnodeMgmt *pMgmt) {
     dError("failed to read %s since dnodeId not found", file);
     goto PRASE_DNODE_OVER;
   }
-  pDnode->dnodeId = dnodeId->valueint;
+  pDnode->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 PRASE_DNODE_OVER;
   }
-  pDnode->clusterId = atoll(clusterId->valuestring);
+  pDnode->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 PRASE_DNODE_OVER;
   }
-  pDnode->dropped = dropped->valueint;
+  pDnode->data.dropped = dropped->valueint;
 
   cJSON *dnodes = cJSON_GetObjectItem(root, "dnodes");
   if (!dnodes || dnodes->type != cJSON_Array) {
@@ -126,43 +144,43 @@ int32_t dmReadFile(SDnodeMgmt *pMgmt) {
     }
     dnodeEp.isMnode = isMnode->valueint;
 
-    taosArrayPush(pMgmt->dnodeEps, &dnodeEp);
+    taosArrayPush(pDnode->data.dnodeEps, &dnodeEp);
   }
 
   code = 0;
   dDebug("succcessed to read file %s", file);
-  dmPrintDnodes(pMgmt);
+  dmPrintEps(pDnode);
 
 PRASE_DNODE_OVER:
   if (content != NULL) taosMemoryFree(content);
   if (root != NULL) cJSON_Delete(root);
   if (pFile != NULL) taosCloseFile(&pFile);
 
-  if (dmIsEpChanged(pMgmt, pDnode->dnodeId, pDnode->localEp)) {
+  if (dmIsEpChanged(pDnode, pDnode->data.dnodeId, pDnode->data.localEp)) {
-    dError("localEp %s different with %s and need reconfigured", pDnode->localEp, file);
+    dError("localEp %s different with %s and need reconfigured", pDnode->data.localEp, file);
     return -1;
   }
 
-  if (taosArrayGetSize(pMgmt->dnodeEps) == 0) {
+  if (taosArrayGetSize(pDnode->data.dnodeEps) == 0) {
     SDnodeEp dnodeEp = {0};
     dnodeEp.isMnode = 1;
-    taosGetFqdnPortFromEp(pDnode->firstEp, &dnodeEp.ep);
+    taosGetFqdnPortFromEp(pDnode->data.firstEp, &dnodeEp.ep);
-    taosArrayPush(pMgmt->dnodeEps, &dnodeEp);
+    taosArrayPush(pDnode->data.dnodeEps, &dnodeEp);
   }
 
-  dmResetDnodes(pMgmt, pMgmt->dnodeEps);
+  dmResetEps(pDnode, pDnode->data.dnodeEps);
 
   terrno = code;
   return code;
 }
 
-int32_t dmWriteFile(SDnodeMgmt *pMgmt) {
+int32_t dmWriteEps(SDnode *pDnode) {
-  SDnode *pDnode = pMgmt->pDnode;
+  char file[PATH_MAX] = {0};
+  char realfile[PATH_MAX];
+  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);
 
-  char file[PATH_MAX];
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC);
-  snprintf(file, sizeof(file), "%s%sdnode.json.bak", pMgmt->path, TD_DIRSEP);
-
-  TdFilePtr pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
   if (pFile == NULL) {
     dError("failed to write %s since %s", file, strerror(errno));
     terrno = TAOS_SYSTEM_ERROR(errno);
@@ -174,14 +192,14 @@ int32_t dmWriteFile(SDnodeMgmt *pMgmt) {
   char   *content = taosMemoryCalloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
-  len += snprintf(content + len, maxLen - len, "  \"dnodeId\": %d,\n", pDnode->dnodeId);
+  len += snprintf(content + len, maxLen - len, "  \"dnodeId\": %d,\n", pDnode->data.dnodeId);
-  len += snprintf(content + len, maxLen - len, "  \"clusterId\": \"%" PRId64 "\",\n", pDnode->clusterId);
+  len += snprintf(content + len, maxLen - len, "  \"clusterId\": \"%" PRId64 "\",\n", pDnode->data.clusterId);
-  len += snprintf(content + len, maxLen - len, "  \"dropped\": %d,\n", pDnode->dropped);
+  len += snprintf(content + len, maxLen - len, "  \"dropped\": %d,\n", pDnode->data.dropped);
   len += snprintf(content + len, maxLen - len, "  \"dnodes\": [{\n");
 
-  int32_t numOfEps = (int32_t)taosArrayGetSize(pMgmt->dnodeEps);
+  int32_t numOfEps = (int32_t)taosArrayGetSize(pDnode->data.dnodeEps);
   for (int32_t i = 0; i < numOfEps; ++i) {
-    SDnodeEp *pDnodeEp = taosArrayGet(pMgmt->dnodeEps, i);
+    SDnodeEp *pDnodeEp = taosArrayGet(pDnode->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);
@@ -199,50 +217,47 @@ int32_t dmWriteFile(SDnodeMgmt *pMgmt) {
   taosCloseFile(&pFile);
   taosMemoryFree(content);
 
-  char realfile[PATH_MAX];
-  snprintf(realfile, sizeof(realfile), "%s%sdnode.json", pMgmt->path, TD_DIRSEP);
-
   if (taosRenameFile(file, realfile) != 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     dError("failed to rename %s since %s", file, terrstr());
     return -1;
   }
 
-  pMgmt->updateTime = taosGetTimestampMs();
+  pDnode->data.updateTime = taosGetTimestampMs();
   dDebug("successed to write %s", realfile);
   return 0;
 }
 
-void dmUpdateDnodeEps(SDnodeMgmt *pMgmt, SArray *dnodeEps) {
+void dmUpdateEps(SDnode *pDnode, SArray *eps) {
-  int32_t numOfEps = taosArrayGetSize(dnodeEps);
+  int32_t numOfEps = taosArrayGetSize(eps);
   if (numOfEps <= 0) return;
 
-  taosWLockLatch(&pMgmt->latch);
+  taosWLockLatch(&pDnode->data.latch);
 
-  int32_t numOfEpsOld = (int32_t)taosArrayGetSize(pMgmt->dnodeEps);
+  int32_t numOfEpsOld = (int32_t)taosArrayGetSize(pDnode->data.dnodeEps);
   if (numOfEps != numOfEpsOld) {
-    dmResetDnodes(pMgmt, dnodeEps);
+    dmResetEps(pDnode, eps);
-    dmWriteFile(pMgmt);
+    dmWriteEps(pDnode);
   } else {
     int32_t size = numOfEps * sizeof(SDnodeEp);
-    if (memcmp(pMgmt->dnodeEps->pData, dnodeEps->pData, size) != 0) {
+    if (memcmp(pDnode->data.dnodeEps->pData, eps->pData, size) != 0) {
-      dmResetDnodes(pMgmt, dnodeEps);
+      dmResetEps(pDnode, eps);
-      dmWriteFile(pMgmt);
+      dmWriteEps(pDnode);
     }
   }
 
-  taosWUnLockLatch(&pMgmt->latch);
+  taosWUnLockLatch(&pDnode->data.latch);
 }
 
-static void dmResetDnodes(SDnodeMgmt *pMgmt, SArray *dnodeEps) {
+static void dmResetEps(SDnode *pDnode, SArray *dnodeEps) {
-  if (pMgmt->dnodeEps != dnodeEps) {
+  if (pDnode->data.dnodeEps != dnodeEps) {
-    SArray *tmp = pMgmt->dnodeEps;
+    SArray *tmp = pDnode->data.dnodeEps;
-    pMgmt->dnodeEps = taosArrayDup(dnodeEps);
+    pDnode->data.dnodeEps = taosArrayDup(dnodeEps);
     taosArrayDestroy(tmp);
   }
 
-  pMgmt->mnodeEpSet.inUse = 0;
+  pDnode->data.mnodeEps.inUse = 0;
-  pMgmt->mnodeEpSet.numOfEps = 0;
+  pDnode->data.mnodeEps.numOfEps = 0;
 
   int32_t mIndex = 0;
   int32_t numOfEps = (int32_t)taosArrayGetSize(dnodeEps);
@@ -251,40 +266,40 @@ static void dmResetDnodes(SDnodeMgmt *pMgmt, SArray *dnodeEps) {
     SDnodeEp *pDnodeEp = taosArrayGet(dnodeEps, i);
     if (!pDnodeEp->isMnode) continue;
     if (mIndex >= TSDB_MAX_REPLICA) continue;
-    pMgmt->mnodeEpSet.numOfEps++;
+    pDnode->data.mnodeEps.numOfEps++;
 
-    pMgmt->mnodeEpSet.eps[mIndex] = pDnodeEp->ep;
+    pDnode->data.mnodeEps.eps[mIndex] = pDnodeEp->ep;
     mIndex++;
   }
 
   for (int32_t i = 0; i < numOfEps; i++) {
     SDnodeEp *pDnodeEp = taosArrayGet(dnodeEps, i);
-    taosHashPut(pMgmt->dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp));
+    taosHashPut(pDnode->data.dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp));
   }
 
-  dmPrintDnodes(pMgmt);
+  dmPrintEps(pDnode);
 }
 
-static void dmPrintDnodes(SDnodeMgmt *pMgmt) {
+static void dmPrintEps(SDnode *pDnode) {
-  int32_t numOfEps = (int32_t)taosArrayGetSize(pMgmt->dnodeEps);
+  int32_t numOfEps = (int32_t)taosArrayGetSize(pDnode->data.dnodeEps);
   dDebug("print dnode ep list, num:%d", numOfEps);
   for (int32_t i = 0; i < numOfEps; i++) {
-    SDnodeEp *pEp = taosArrayGet(pMgmt->dnodeEps, i);
+    SDnodeEp *pEp = taosArrayGet(pDnode->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(SDnodeMgmt *pMgmt, int32_t dnodeId, const char *ep) {
+static bool dmIsEpChanged(SDnode *pDnode, int32_t dnodeId, const char *ep) {
   bool changed = false;
-  taosRLockLatch(&pMgmt->latch);
+  taosRLockLatch(&pDnode->data.latch);
 
-  SDnodeEp *pDnodeEp = taosHashGet(pMgmt->dnodeHash, &dnodeId, sizeof(int32_t));
+  SDnodeEp *pDnodeEp = taosHashGet(pDnode->data.dnodeHash, &dnodeId, sizeof(int32_t));
   if (pDnodeEp != NULL) {
     char epstr[TSDB_EP_LEN + 1];
     snprintf(epstr, TSDB_EP_LEN, "%s:%u", pDnodeEp->ep.fqdn, pDnodeEp->ep.port);
     changed = strcmp(ep, epstr) != 0;
   }
 
-  taosRUnLockLatch(&pMgmt->latch);
+  taosRUnLockLatch(&pDnode->data.latch);
   return changed;
 }

source/dnode/mgmt/implement/src/dmExec.c

@@ -0,0 +1,339 @@
+/*
+ * 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 bool dmRequireNode(SMgmtWrapper *pWrapper) {
+  bool    required = false;
+  int32_t code = (*pWrapper->fp.requiredFp)(pWrapper, &required);
+  if (!required) {
+    dDebug("node:%s, does not require startup", pWrapper->name);
+  }
+  return required;
+}
+
+static int32_t dmInitParentProc(SMgmtWrapper *pWrapper) {
+  int32_t shmsize = tsMnodeShmSize;
+  if (pWrapper->ntype == VNODE) {
+    shmsize = tsVnodeShmSize;
+  } else if (pWrapper->ntype == QNODE) {
+    shmsize = tsQnodeShmSize;
+  } else if (pWrapper->ntype == SNODE) {
+    shmsize = tsSnodeShmSize;
+  } else if (pWrapper->ntype == MNODE) {
+    shmsize = tsMnodeShmSize;
+  } else if (pWrapper->ntype == BNODE) {
+    shmsize = tsBnodeShmSize;
+  } else {
+    return -1;
+  }
+
+  if (taosCreateShm(&pWrapper->procShm, pWrapper->ntype, shmsize) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(terrno);
+    dError("node:%s, failed to create shm size:%d since %s", pWrapper->name, shmsize, terrstr());
+    return -1;
+  }
+  dInfo("node:%s, shm:%d is created, size:%d", pWrapper->name, pWrapper->procShm.id, shmsize);
+
+  SProcCfg cfg = dmGenProcCfg(pWrapper);
+  cfg.isChild = false;
+  pWrapper->procType = DND_PROC_PARENT;
+  pWrapper->procObj = taosProcInit(&cfg);
+  if (pWrapper->procObj == NULL) {
+    dError("node:%s, failed to create proc since %s", pWrapper->name, terrstr());
+    return -1;
+  }
+
+  return 0;
+}
+
+static int32_t dmNewNodeProc(SMgmtWrapper *pWrapper, EDndNodeType n) {
+  char  tstr[8] = {0};
+  char *args[6] = {0};
+  snprintf(tstr, sizeof(tstr), "%d", n);
+  args[1] = "-c";
+  args[2] = configDir;
+  args[3] = "-n";
+  args[4] = tstr;
+  args[5] = NULL;
+
+  int32_t pid = taosNewProc(args);
+  if (pid <= 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("node:%s, failed to exec in new process since %s", pWrapper->name, terrstr());
+    return -1;
+  }
+
+  pWrapper->procId = pid;
+  dInfo("node:%s, continue running in new process:%d", pWrapper->name, pid);
+  return 0;
+}
+
+static int32_t dmRunParentProc(SMgmtWrapper *pWrapper) {
+  if (pWrapper->pDnode->ntype == NODE_END) {
+    dInfo("node:%s, should be started manually in child process", pWrapper->name);
+  } else {
+    if (dmNewNodeProc(pWrapper, pWrapper->ntype) != 0) {
+      return -1;
+    }
+  }
+  if (taosProcRun(pWrapper->procObj) != 0) {
+    dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr());
+    return -1;
+  }
+  return 0;
+}
+
+static int32_t dmInitChildProc(SMgmtWrapper *pWrapper) {
+  SProcCfg cfg = dmGenProcCfg(pWrapper);
+  cfg.isChild = true;
+  pWrapper->procObj = taosProcInit(&cfg);
+  if (pWrapper->procObj == NULL) {
+    dError("node:%s, failed to create proc since %s", pWrapper->name, terrstr());
+    return -1;
+  }
+  return 0;
+}
+
+static int32_t dmRunChildProc(SMgmtWrapper *pWrapper) {
+  if (taosProcRun(pWrapper->procObj) != 0) {
+    dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr());
+    return -1;
+  }
+  return 0;
+}
+
+int32_t dmOpenNode(SMgmtWrapper *pWrapper) {
+  if (taosMkDir(pWrapper->path) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("node:%s, failed to create dir:%s since %s", pWrapper->name, pWrapper->path, terrstr());
+    return -1;
+  }
+
+  if (pWrapper->procType == DND_PROC_SINGLE || pWrapper->procType == DND_PROC_CHILD) {
+    if ((*pWrapper->fp.openFp)(pWrapper) != 0) {
+      dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
+      return -1;
+    }
+    if (pWrapper->procType == DND_PROC_CHILD) {
+      if (dmInitChildProc(pWrapper) != 0) return -1;
+      if (dmRunChildProc(pWrapper) != 0) return -1;
+    }
+    dDebug("node:%s, has been opened", pWrapper->name);
+    pWrapper->deployed = true;
+  } else {
+    if (dmInitParentProc(pWrapper) != 0) return -1;
+    if (dmWriteShmFile(pWrapper) != 0) return -1;
+    if (dmRunParentProc(pWrapper) != 0) return -1;
+  }
+
+  return 0;
+}
+
+int32_t dmStartNode(SMgmtWrapper *pWrapper) {
+  if (pWrapper->procType == DND_PROC_PARENT) {
+    dInfo("node:%s, not start in parent process", pWrapper->name);
+  } else if (pWrapper->procType == DND_PROC_CHILD) {
+    dInfo("node:%s, start in child process", pWrapper->name);
+    if (pWrapper->ntype != DNODE) {
+      if (pWrapper->fp.startFp != NULL && (*pWrapper->fp.startFp)(pWrapper) != 0) {
+        dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
+        return -1;
+      }
+    }
+  } else {
+    if (pWrapper->fp.startFp != NULL && (*pWrapper->fp.startFp)(pWrapper) != 0) {
+      dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+void dmStopNode(SMgmtWrapper *pWrapper) {
+  if (pWrapper->fp.stopFp != NULL) {
+    (*pWrapper->fp.stopFp)(pWrapper);
+  }
+}
+
+void dmCloseNode(SMgmtWrapper *pWrapper) {
+  dInfo("node:%s, start to close", pWrapper->name);
+  if (pWrapper->procType == DND_PROC_PARENT) {
+    if (pWrapper->procId > 0 && taosProcExist(pWrapper->procId)) {
+      dInfo("node:%s, send kill signal to the child process:%d", pWrapper->name, pWrapper->procId);
+      taosKillProc(pWrapper->procId);
+      dInfo("node:%s, wait for child process:%d to stop", pWrapper->name, pWrapper->procId);
+      taosWaitProc(pWrapper->procId);
+      dInfo("node:%s, child process:%d is stopped", pWrapper->name, pWrapper->procId);
+    }
+  }
+
+  dmStopNode(pWrapper);
+
+  pWrapper->required = false;
+  taosWLockLatch(&pWrapper->latch);
+  if (pWrapper->deployed) {
+    (*pWrapper->fp.closeFp)(pWrapper);
+    pWrapper->deployed = false;
+  }
+  taosWUnLockLatch(&pWrapper->latch);
+
+  while (pWrapper->refCount > 0) {
+    taosMsleep(10);
+  }
+
+  if (pWrapper->procObj) {
+    taosProcCleanup(pWrapper->procObj);
+    pWrapper->procObj = NULL;
+  }
+
+  dInfo("node:%s, has been closed", pWrapper->name);
+}
+
+static int32_t dmOpenNodes(SDnode *pDnode) {
+  if (pDnode->ptype == DND_PROC_CHILD) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[pDnode->ntype];
+    pWrapper->required = dmRequireNode(pWrapper);
+    if (!pWrapper->required) {
+      dError("dnode:%s, failed to open since not required", pWrapper->name);
+    }
+
+    pWrapper->procType = DND_PROC_CHILD;
+
+    SMsgCb msgCb = pDnode->data.msgCb;
+    msgCb.pWrapper = pWrapper;
+    tmsgSetDefaultMsgCb(&msgCb);
+
+    if (dmOpenNode(pWrapper) != 0) {
+      dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
+      return -1;
+    }
+  } else {
+    for (EDndNodeType n = DNODE; n < NODE_END; ++n) {
+      SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
+      pWrapper->required = dmRequireNode(pWrapper);
+      if (!pWrapper->required) continue;
+
+      if (pDnode->ptype == DND_PROC_PARENT && n != DNODE) {
+        pWrapper->procType = DND_PROC_PARENT;
+      } else {
+        pWrapper->procType = DND_PROC_SINGLE;
+      }
+
+      if (dmOpenNode(pWrapper) != 0) {
+        dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
+        return -1;
+      }
+    }
+  }
+
+  dmSetStatus(pDnode, DND_STAT_RUNNING);
+  return 0;
+}
+
+static int32_t dmStartNodes(SDnode *pDnode) {
+  for (EDndNodeType n = DNODE; n < NODE_END; ++n) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
+    if (!pWrapper->required) continue;
+    if (dmStartNode(pWrapper) != 0) {
+      dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
+      return -1;
+    }
+  }
+
+  dInfo("TDengine initialized successfully");
+  dmReportStartup(pDnode, "TDengine", "initialized successfully");
+  return 0;
+}
+
+static void dmStopNodes(SDnode *pDnode) {
+  for (EDndNodeType n = DNODE; n < NODE_END; ++n) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
+    dmStopNode(pWrapper);
+  }
+}
+
+static void dmCloseNodes(SDnode *pDnode) {
+  for (EDndNodeType n = DNODE; n < NODE_END; ++n) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
+    dmCloseNode(pWrapper);
+  }
+}
+
+static void dmProcessProcHandle(void *handle) {
+  dWarn("handle:%p, the child process dies and send an offline rsp", handle);
+  SRpcMsg rpcMsg = {.handle = handle, .code = TSDB_CODE_NODE_OFFLINE};
+  rpcSendResponse(&rpcMsg);
+}
+
+static void dmWatchNodes(SDnode *pDnode) {
+  taosThreadMutexLock(&pDnode->mutex);
+  if (pDnode->ptype == DND_PROC_PARENT) {
+    for (EDndNodeType n = DNODE + 1; n < NODE_END; ++n) {
+      SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
+      if (!pWrapper->required) continue;
+      if (pWrapper->procType != DND_PROC_PARENT) continue;
+      if (pDnode->ntype == NODE_END) continue;
+
+      if (pWrapper->procId <= 0 || !taosProcExist(pWrapper->procId)) {
+        dWarn("node:%s, process:%d is killed and needs to be restarted", pWrapper->name, pWrapper->procId);
+        if (pWrapper->procObj) {
+          taosProcCloseHandles(pWrapper->procObj, dmProcessProcHandle);
+        }
+        dmNewNodeProc(pWrapper, n);
+      }
+    }
+  }
+  taosThreadMutexUnlock(&pDnode->mutex);
+}
+
+int32_t dmRun(SDnode *pDnode) {
+  if (!tsMultiProcess) {
+    pDnode->ptype = DND_PROC_SINGLE;
+    dInfo("dnode run in single process");
+  } else if (pDnode->ntype == DNODE || pDnode->ntype == NODE_END) {
+    pDnode->ptype = DND_PROC_PARENT;
+    dInfo("dnode run in parent process");
+  } else {
+    pDnode->ptype = DND_PROC_CHILD;
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[pDnode->ntype];
+    dInfo("%s run in child process", pWrapper->name);
+  }
+
+  if (dmOpenNodes(pDnode) != 0) {
+    dError("failed to open nodes since %s", terrstr());
+    return -1;
+  }
+
+  if (dmStartNodes(pDnode) != 0) {
+    dError("failed to start nodes since %s", terrstr());
+    return -1;
+  }
+
+  while (1) {
+    taosMsleep(100);
+    if (pDnode->event & DND_EVENT_STOP) {
+      dInfo("dnode is about to stop");
+      dmSetStatus(pDnode, DND_STAT_STOPPED);
+      dmStopNodes(pDnode);
+      dmCloseNodes(pDnode);
+      return 0;
+    } else {
+      dmWatchNodes(pDnode);
+    }
+  }
+}

source/dnode/mgmt/implement/src/dmHandle.c

@@ -0,0 +1,274 @@
+/*
+ * 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) {
+    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);
+    }
+    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;
+  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 info = {0};
+  dmGetVnodeLoads(pDnode, &info);
+  req.pVloads = info.pVloads;
+
+  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);
+    pWrapper->required = true;
+    pWrapper->deployed = true;
+    pWrapper->procType = pDnode->ptype;
+    (void)dmOpenNode(pWrapper);
+  }
+
+  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);
+  }
+
+  dmReleaseWrapper(pWrapper);
+
+  if (code == 0) {
+    dmCloseNode(pWrapper);
+    pWrapper->required = false;
+    pWrapper->deployed = false;
+    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 (dmInitTrans(pDnode) != 0) {
+    dError("failed to init transport since %s", terrstr());
+    return -1;
+  }
+
+  dInfo("dnode-mgmt is initialized");
+  return 0;
+}
+
+static void dmCleanupMgmt(SMgmtWrapper *pWrapper) {
+  dInfo("dnode-mgmt start to clean up");
+  SDnode *pDnode = pWrapper->pDnode;
+  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);
+
+  dmCleanupTrans(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

@@ -14,22 +14,21 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dmInt.h"
+#include "dmImp.h"
 
 static void dmGetMonitorBasicInfo(SDnode *pDnode, SMonBasicInfo *pInfo) {
   pInfo->protocol = 1;
-  pInfo->dnode_id = pDnode->dnodeId;
+  pInfo->dnode_id = pDnode->data.dnodeId;
-  pInfo->cluster_id = pDnode->clusterId;
+  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->rebootTime) / (86400000.0f);
+  pInfo->uptime = (taosGetTimestampMs() - pDnode->data.rebootTime) / (86400000.0f);
-  SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, MNODE);
+  pInfo->has_mnode = pDnode->wrappers[MNODE].required;
-  if (pWrapper != NULL) {
+  pInfo->has_qnode = pDnode->wrappers[QNODE].required;
-    pInfo->has_mnode = pWrapper->required;
+  pInfo->has_snode = pDnode->wrappers[SNODE].required;
-    dndReleaseWrapper(pWrapper);
+  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));
@@ -56,7 +55,7 @@ void dmSendMonitorReport(SDnode *pDnode) {
   SRpcMsg req = {0};
   SRpcMsg rsp;
   SEpSet  epset = {.inUse = 0, .numOfEps = 1};
-  tstrncpy(epset.eps[0].fqdn, tsLocalFqdn, TSDB_FQDN_LEN);
+  tstrncpy(epset.eps[0].fqdn, pDnode->data.localFqdn, TSDB_FQDN_LEN);
   epset.eps[0].port = tsServerPort;
 
   SMgmtWrapper *pWrapper = NULL;
@@ -65,14 +64,14 @@ void dmSendMonitorReport(SDnode *pDnode) {
   bool getFromAPI = !tsMultiProcess;
   pWrapper = &pDnode->wrappers[MNODE];
   if (getFromAPI) {
-    if (dndMarkWrapper(pWrapper) != 0) {
+    if (dmMarkWrapper(pWrapper) == 0) {
       mmGetMonitorInfo(pWrapper, &mmInfo);
-      dndReleaseWrapper(pWrapper);
+      dmReleaseWrapper(pWrapper);
     }
   } else {
     if (pWrapper->required) {
       req.msgType = TDMT_MON_MM_INFO;
-      dndSendRecv(pDnode, &epset, &req, &rsp);
+      dmSendRecv(pDnode, &epset, &req, &rsp);
       if (rsp.code == 0 && rsp.contLen > 0) {
         tDeserializeSMonMmInfo(rsp.pCont, rsp.contLen, &mmInfo);
       }
@@ -80,16 +79,16 @@ void dmSendMonitorReport(SDnode *pDnode) {
     }
   }
 
-  pWrapper = &pDnode->wrappers[VNODES];
+  pWrapper = &pDnode->wrappers[VNODE];
   if (getFromAPI) {
-    if (dndMarkWrapper(pWrapper) != 0) {
+    if (dmMarkWrapper(pWrapper) == 0) {
       vmGetMonitorInfo(pWrapper, &vmInfo);
-      dndReleaseWrapper(pWrapper);
+      dmReleaseWrapper(pWrapper);
     }
   } else {
     if (pWrapper->required) {
       req.msgType = TDMT_MON_VM_INFO;
-      dndSendRecv(pDnode, &epset, &req, &rsp);
+      dmSendRecv(pDnode, &epset, &req, &rsp);
       if (rsp.code == 0 && rsp.contLen > 0) {
         tDeserializeSMonVmInfo(rsp.pCont, rsp.contLen, &vmInfo);
       }
@@ -99,14 +98,14 @@ void dmSendMonitorReport(SDnode *pDnode) {
 
   pWrapper = &pDnode->wrappers[QNODE];
   if (getFromAPI) {
-    if (dndMarkWrapper(pWrapper) != 0) {
+    if (dmMarkWrapper(pWrapper) == 0) {
       qmGetMonitorInfo(pWrapper, &qmInfo);
-      dndReleaseWrapper(pWrapper);
+      dmReleaseWrapper(pWrapper);
     }
   } else {
     if (pWrapper->required) {
       req.msgType = TDMT_MON_QM_INFO;
-      dndSendRecv(pDnode, &epset, &req, &rsp);
+      dmSendRecv(pDnode, &epset, &req, &rsp);
       if (rsp.code == 0 && rsp.contLen > 0) {
         tDeserializeSMonQmInfo(rsp.pCont, rsp.contLen, &qmInfo);
       }
@@ -116,14 +115,14 @@ void dmSendMonitorReport(SDnode *pDnode) {
 
   pWrapper = &pDnode->wrappers[SNODE];
   if (getFromAPI) {
-    if (dndMarkWrapper(pWrapper) != 0) {
+    if (dmMarkWrapper(pWrapper) == 0) {
       smGetMonitorInfo(pWrapper, &smInfo);
-      dndReleaseWrapper(pWrapper);
+      dmReleaseWrapper(pWrapper);
     }
   } else {
     if (pWrapper->required) {
       req.msgType = TDMT_MON_SM_INFO;
-      dndSendRecv(pDnode, &epset, &req, &rsp);
+      dmSendRecv(pDnode, &epset, &req, &rsp);
       if (rsp.code == 0 && rsp.contLen > 0) {
         tDeserializeSMonSmInfo(rsp.pCont, rsp.contLen, &smInfo);
       }
@@ -133,14 +132,14 @@ void dmSendMonitorReport(SDnode *pDnode) {
 
   pWrapper = &pDnode->wrappers[BNODE];
   if (getFromAPI) {
-    if (dndMarkWrapper(pWrapper) != 0) {
+    if (dmMarkWrapper(pWrapper) == 0) {
       bmGetMonitorInfo(pWrapper, &bmInfo);
-      dndReleaseWrapper(pWrapper);
+      dmReleaseWrapper(pWrapper);
     }
   } else {
     if (pWrapper->required) {
       req.msgType = TDMT_MON_BM_INFO;
-      dndSendRecv(pDnode, &epset, &req, &rsp);
+      dmSendRecv(pDnode, &epset, &req, &rsp);
       if (rsp.code == 0 && rsp.contLen > 0) {
         tDeserializeSMonBmInfo(rsp.pCont, rsp.contLen, &bmInfo);
       }
@@ -162,7 +161,10 @@ void dmSendMonitorReport(SDnode *pDnode) {
   monSendReport();
 }
 
-void dmGetVnodeLoads(SMgmtWrapper *pWrapper, SMonVloadInfo *pInfo) {
+void dmGetVnodeLoads(SDnode *pDnode, SMonVloadInfo *pInfo) {
+  SMgmtWrapper *pWrapper = dmAcquireWrapper(pDnode, VNODE);
+  if (pWrapper == NULL) return;
+
   bool getFromAPI = !tsMultiProcess;
   if (getFromAPI) {
     vmGetVnodeLoads(pWrapper, pInfo);
@@ -170,26 +172,14 @@ void dmGetVnodeLoads(SMgmtWrapper *pWrapper, SMonVloadInfo *pInfo) {
     SRpcMsg req = {.msgType = TDMT_MON_VM_LOAD};
     SRpcMsg rsp = {0};
     SEpSet  epset = {.inUse = 0, .numOfEps = 1};
-    tstrncpy(epset.eps[0].fqdn, tsLocalFqdn, TSDB_FQDN_LEN);
+    tstrncpy(epset.eps[0].fqdn, pDnode->data.localFqdn, TSDB_FQDN_LEN);
     epset.eps[0].port = tsServerPort;
 
-    dndSendRecv(pWrapper->pDnode, &epset, &req, &rsp);
+    dmSendRecv(pDnode, &epset, &req, &rsp);
     if (rsp.code == 0 && rsp.contLen > 0) {
       tDeserializeSMonVloadInfo(rsp.pCont, rsp.contLen, pInfo);
     }
     rpcFreeCont(rsp.pCont);
   }
-}
+  dmReleaseWrapper(pWrapper);
-
-void dmGetMonitorSysInfo(SMonSysInfo *pInfo) {
-  taosGetCpuUsage(&pInfo->cpu_engine, &pInfo->cpu_system);
-  taosGetCpuCores(&pInfo->cpu_cores);
-  taosGetProcMemory(&pInfo->mem_engine);
-  taosGetSysMemory(&pInfo->mem_system);
-  pInfo->mem_total = tsTotalMemoryKB;
-  pInfo->disk_engine = 0;
-  pInfo->disk_used = tsDataSpace.size.used;
-  pInfo->disk_total = tsDataSpace.size.total;
-  taosGetCardInfoDelta(&pInfo->net_in, &pInfo->net_out);
-  taosGetProcIODelta(&pInfo->io_read, &pInfo->io_write, &pInfo->io_read_disk, &pInfo->io_write_disk);
 }

source/dnode/mgmt/implement/src/dmObj.c

@@ -0,0 +1,147 @@
+/*
+ * 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;
+  }
+
+  pDnode->data.msgCb = dmGetMsgcb(&pDnode->wrappers[DNODE]);
+  tmsgSetDefaultMsgCb(&pDnode->data.msgCb);
+
+  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/implement/src/dmTransport.c

@@ -14,18 +14,31 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dndInt.h"
+#include "dmImp.h"
 
 #define INTERNAL_USER   "_dnd"
 #define INTERNAL_CKEY   "_key"
 #define INTERNAL_SECRET "_pwd"
 
-static void dndUpdateMnodeEpSet(SDnode *pDnode, SEpSet *pEpSet) {
+static void dmGetMnodeEpSet(SDnode *pDnode, SEpSet *pEpSet) {
-  SMgmtWrapper *pWrapper = &pDnode->wrappers[DNODE];
+  taosRLockLatch(&pDnode->data.latch);
-  dmUpdateMnodeEpSet(pWrapper->pMgmt, pEpSet);
+  *pEpSet = pDnode->data.mnodeEps;
+  taosRUnLockLatch(&pDnode->data.latch);
 }
 
-static inline NodeMsgFp dndGetMsgFp(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
+static void dmSetMnodeEpSet(SDnode *pDnode, SEpSet *pEpSet) {
+  dInfo("mnode is changed, num:%d use:%d", pEpSet->numOfEps, pEpSet->inUse);
+
+  taosWLockLatch(&pDnode->data.latch);
+  pDnode->data.mnodeEps = *pEpSet;
+  for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
+    dInfo("mnode index:%d %s:%u", i, pEpSet->eps[i].fqdn, pEpSet->eps[i].port);
+  }
+
+  taosWUnLockLatch(&pDnode->data.latch);
+}
+
+static inline NodeMsgFp dmGetMsgFp(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
   NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pRpc->msgType)];
   if (msgFp == NULL) {
     terrno = TSDB_CODE_MSG_NOT_PROCESSED;
@@ -34,7 +47,7 @@ static inline NodeMsgFp dndGetMsgFp(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
   return msgFp;
 }
 
-static inline int32_t dndBuildMsg(SNodeMsg *pMsg, SRpcMsg *pRpc) {
+static inline int32_t dmBuildMsg(SNodeMsg *pMsg, SRpcMsg *pRpc) {
   SRpcConnInfo connInfo = {0};
   if ((pRpc->msgType & 1U) && rpcGetConnInfo(pRpc->handle, &connInfo) != 0) {
     terrno = TSDB_CODE_MND_NO_USER_FROM_CONN;
@@ -49,27 +62,29 @@ static inline int32_t dndBuildMsg(SNodeMsg *pMsg, SRpcMsg *pRpc) {
   return 0;
 }
 
-static void dndProcessRpcMsg(SMgmtWrapper *pWrapper, SRpcMsg *pRpc, SEpSet *pEpSet) {
+static void dmProcessRpcMsg(SMgmtWrapper *pWrapper, SRpcMsg *pRpc, SEpSet *pEpSet) {
   int32_t   code = -1;
   SNodeMsg *pMsg = NULL;
   NodeMsgFp msgFp = NULL;
+  uint16_t  msgType = pRpc->msgType;
 
-  if (pEpSet && pEpSet->numOfEps > 0 && pRpc->msgType == TDMT_MND_STATUS_RSP) {
+  if (pEpSet && pEpSet->numOfEps > 0 && msgType == TDMT_MND_STATUS_RSP) {
-    dndUpdateMnodeEpSet(pWrapper->pDnode, pEpSet);
+    dmSetMnodeEpSet(pWrapper->pDnode, pEpSet);
   }
 
-  if (dndMarkWrapper(pWrapper) != 0) goto _OVER;
+  if (dmMarkWrapper(pWrapper) != 0) goto _OVER;
-  if ((msgFp = dndGetMsgFp(pWrapper, pRpc)) == NULL) goto _OVER;
+  if ((msgFp = dmGetMsgFp(pWrapper, pRpc)) == NULL) goto _OVER;
   if ((pMsg = taosAllocateQitem(sizeof(SNodeMsg))) == NULL) goto _OVER;
-  if (dndBuildMsg(pMsg, pRpc) != 0) goto _OVER;
+  if (dmBuildMsg(pMsg, pRpc) != 0) goto _OVER;
 
-  if (pWrapper->procType == PROC_SINGLE) {
+  if (pWrapper->procType == DND_PROC_SINGLE) {
-    dTrace("msg:%p, is created, handle:%p user:%s", pMsg, pRpc->handle, pMsg->user);
+    dTrace("msg:%p, is created, type:%s handle:%p user:%s", pMsg, TMSG_INFO(msgType), pRpc->handle, pMsg->user);
     code = (*msgFp)(pWrapper, pMsg);
-  } else if (pWrapper->procType == PROC_PARENT) {
+  } else if (pWrapper->procType == DND_PROC_PARENT) {
-    dTrace("msg:%p, is created and put into child queue, handle:%p user:%s", pMsg, pRpc->handle, pMsg->user);
+    dTrace("msg:%p, is created and put into child queue, type:%s handle:%p user:%s", pMsg, TMSG_INFO(msgType),
-    code = taosProcPutToChildQ(pWrapper->pProc, pMsg, sizeof(SNodeMsg), pRpc->pCont, pRpc->contLen, pRpc->handle,
+           pRpc->handle, pMsg->user);
-                               PROC_REQ);
+    code = taosProcPutToChildQ(pWrapper->procObj, pMsg, sizeof(SNodeMsg), pRpc->pCont, pRpc->contLen, pRpc->handle,
+                               PROC_FUNC_REQ);
   } else {
     dTrace("msg:%p, should not processed in child process, handle:%p user:%s", pMsg, pRpc->handle, pMsg->user);
     ASSERT(1);
@@ -77,16 +92,22 @@ static void dndProcessRpcMsg(SMgmtWrapper *pWrapper, SRpcMsg *pRpc, SEpSet *pEpS
 
 _OVER:
   if (code == 0) {
-    if (pWrapper->procType == PROC_PARENT) {
+    if (pWrapper->procType == DND_PROC_PARENT) {
       dTrace("msg:%p, is freed in parent process", pMsg);
       taosFreeQitem(pMsg);
       rpcFreeCont(pRpc->pCont);
     }
   } else {
-    dError("msg:%p, failed to process since 0x%04x:%s", pMsg, code & 0XFFFF, terrstr());
+    dError("msg:%p, type:%s failed to process since 0x%04x:%s", pMsg, TMSG_INFO(msgType), code & 0XFFFF, terrstr());
-    if (pRpc->msgType & 1U) {
+    if (msgType & 1U) {
       if (terrno != 0) code = terrno;
-      SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = terrno};
+      if (code == TSDB_CODE_NODE_NOT_DEPLOYED || code == TSDB_CODE_NODE_OFFLINE) {
+        if (msgType > TDMT_MND_MSG && msgType < TDMT_VND_MSG) {
+          code = TSDB_CODE_NODE_REDIRECT;
+        }
+      }
+
+      SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = code};
       tmsgSendRsp(&rsp);
     }
     dTrace("msg:%p, is freed", pMsg);
@@ -94,23 +115,23 @@ _OVER:
     rpcFreeCont(pRpc->pCont);
   }
 
-  dndReleaseWrapper(pWrapper);
+  dmReleaseWrapper(pWrapper);
 }
 
-static void dndProcessMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
+static void dmProcessMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
-  STransMgmt   *pMgmt = &pDnode->trans;
+  SDnodeTrans  *pTrans = &pDnode->trans;
   tmsg_t        msgType = pMsg->msgType;
   bool          isReq = msgType & 1u;
-  SMsgHandle   *pHandle = &pMgmt->msgHandles[TMSG_INDEX(msgType)];
+  SMsgHandle   *pHandle = &pTrans->msgHandles[TMSG_INDEX(msgType)];
-  SMgmtWrapper *pWrapper = pHandle->pWrapper;
+  SMgmtWrapper *pWrapper = pHandle->pNdWrapper;
 
   if (msgType == TDMT_DND_NETWORK_TEST) {
     dTrace("network test req will be processed, handle:%p, app:%p", pMsg->handle, pMsg->ahandle);
-    dndProcessStartupReq(pDnode, pMsg);
+    dmProcessStartupReq(pDnode, pMsg);
     return;
   }
 
-  if (dndGetStatus(pDnode) != DND_STAT_RUNNING) {
+  if (pDnode->status != DND_STAT_RUNNING) {
     dError("msg:%s ignored since dnode not running, handle:%p app:%p", TMSG_INFO(msgType), pMsg->handle, pMsg->ahandle);
     if (isReq) {
       SRpcMsg rspMsg = {.handle = pMsg->handle, .code = TSDB_CODE_APP_NOT_READY, .ahandle = pMsg->ahandle};
@@ -134,6 +155,7 @@ static void dndProcessMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
       rpcSendResponse(&rspMsg);
     }
     rpcFreeCont(pMsg->pCont);
+    return;
   }
 
   if (pHandle->pMndWrapper != NULL || pHandle->pQndWrapper != NULL) {
@@ -148,17 +170,215 @@ static void dndProcessMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
   }
 
   dTrace("msg:%s will be processed by %s, app:%p", TMSG_INFO(msgType), pWrapper->name, pMsg->ahandle);
-  dndProcessRpcMsg(pWrapper, pMsg, pEpSet);
+  dmProcessRpcMsg(pWrapper, pMsg, pEpSet);
 }
 
-static int32_t dndInitClient(SDnode *pDnode) {
+int32_t dmInitMsgHandle(SDnode *pDnode) {
-  STransMgmt *pMgmt = &pDnode->trans;
+  SDnodeTrans *pTrans = &pDnode->trans;
 
-  SRpcInit rpcInit;
+  for (EDndNodeType n = DNODE; n < NODE_END; ++n) {
-  memset(&rpcInit, 0, sizeof(rpcInit));
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
+
+    for (int32_t msgIndex = 0; msgIndex < TDMT_MAX; ++msgIndex) {
+      NodeMsgFp msgFp = pWrapper->msgFps[msgIndex];
+      int8_t    vgId = pWrapper->msgVgIds[msgIndex];
+      if (msgFp == NULL) continue;
+
+      SMsgHandle *pHandle = &pTrans->msgHandles[msgIndex];
+      if (vgId == QNODE_HANDLE) {
+        if (pHandle->pQndWrapper != NULL) {
+          dError("msg:%s has multiple process nodes", tMsgInfo[msgIndex]);
+          return -1;
+        }
+        pHandle->pQndWrapper = pWrapper;
+      } else if (vgId == MNODE_HANDLE) {
+        if (pHandle->pMndWrapper != NULL) {
+          dError("msg:%s has multiple process nodes", tMsgInfo[msgIndex]);
+          return -1;
+        }
+        pHandle->pMndWrapper = pWrapper;
+      } else {
+        if (pHandle->pNdWrapper != NULL) {
+          dError("msg:%s has multiple process nodes", tMsgInfo[msgIndex]);
+          return -1;
+        }
+        pHandle->pNdWrapper = pWrapper;
+      }
+    }
+  }
+
+  return 0;
+}
+
+static inline int32_t dmSendRpcReq(SDnode *pDnode, const SEpSet *pEpSet, SRpcMsg *pReq) {
+  if (pDnode->trans.clientRpc == NULL) {
+    terrno = TSDB_CODE_NODE_OFFLINE;
+    return -1;
+  }
+
+  rpcSendRequest(pDnode->trans.clientRpc, pEpSet, pReq, NULL);
+  return 0;
+}
+
+static void dmSendRpcRedirectRsp(SDnode *pDnode, const SRpcMsg *pReq) {
+  SEpSet epSet = {0};
+  dmGetMnodeEpSet(pDnode, &epSet);
+
+  dDebug("RPC %p, req is redirected, num:%d use:%d", pReq->handle, epSet.numOfEps, epSet.inUse);
+  for (int32_t i = 0; i < epSet.numOfEps; ++i) {
+    dDebug("mnode index:%d %s:%u", i, epSet.eps[i].fqdn, epSet.eps[i].port);
+    if (strcmp(epSet.eps[i].fqdn, pDnode->data.localFqdn) == 0 && epSet.eps[i].port == pDnode->data.serverPort) {
+      epSet.inUse = (i + 1) % epSet.numOfEps;
+    }
+
+    epSet.eps[i].port = htons(epSet.eps[i].port);
+  }
+
+  rpcSendRedirectRsp(pReq->handle, &epSet);
+}
+
+static inline void dmSendRpcRsp(SDnode *pDnode, const SRpcMsg *pRsp) {
+  if (pRsp->code == TSDB_CODE_NODE_REDIRECT) {
+    dmSendRpcRedirectRsp(pDnode, pRsp);
+  } else {
+    rpcSendResponse(pRsp);
+  }
+}
+
+void dmSendRecv(SDnode *pDnode, SEpSet *pEpSet, SRpcMsg *pReq, SRpcMsg *pRsp) {
+  rpcSendRecv(pDnode->trans.clientRpc, pEpSet, pReq, pRsp);
+}
+
+void dmSendToMnodeRecv(SDnode *pDnode, SRpcMsg *pReq, SRpcMsg *pRsp) {
+  SEpSet epSet = {0};
+  dmGetMnodeEpSet(pDnode, &epSet);
+  rpcSendRecv(pDnode->trans.clientRpc, &epSet, pReq, pRsp);
+}
+
+static inline int32_t dmSendReq(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pReq) {
+  if (pWrapper->pDnode->status != DND_STAT_RUNNING) {
+    terrno = TSDB_CODE_NODE_OFFLINE;
+    dError("failed to send rpc msg since %s, handle:%p", terrstr(), pReq->handle);
+    return -1;
+  }
+
+  if (pWrapper->procType != DND_PROC_CHILD) {
+    return dmSendRpcReq(pWrapper->pDnode, pEpSet, pReq);
+  } else {
+    char *pHead = taosMemoryMalloc(sizeof(SRpcMsg) + sizeof(SEpSet));
+    if (pHead == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+
+    memcpy(pHead, pReq, sizeof(SRpcMsg));
+    memcpy(pHead + sizeof(SRpcMsg), pEpSet, sizeof(SEpSet));
+    taosProcPutToParentQ(pWrapper->procObj, pHead, sizeof(SRpcMsg) + sizeof(SEpSet), pReq->pCont, pReq->contLen,
+                         PROC_FUNC_REQ);
+    taosMemoryFree(pHead);
+    return 0;
+  }
+}
+
+static inline void dmSendRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
+  if (pWrapper->procType != DND_PROC_CHILD) {
+    dmSendRpcRsp(pWrapper->pDnode, pRsp);
+  } else {
+    taosProcPutToParentQ(pWrapper->procObj, pRsp, sizeof(SRpcMsg), pRsp->pCont, pRsp->contLen, PROC_FUNC_RSP);
+  }
+}
+
+static inline void dmRegisterBrokenLinkArg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg) {
+  if (pWrapper->procType != DND_PROC_CHILD) {
+    rpcRegisterBrokenLinkArg(pMsg);
+  } else {
+    taosProcPutToParentQ(pWrapper->procObj, pMsg, sizeof(SRpcMsg), pMsg->pCont, pMsg->contLen, PROC_FUNC_REGIST);
+  }
+}
+
+static inline void dmReleaseHandle(SMgmtWrapper *pWrapper, void *handle, int8_t type) {
+  if (pWrapper->procType != DND_PROC_CHILD) {
+    rpcReleaseHandle(handle, type);
+  } else {
+    SRpcMsg msg = {.handle = handle, .code = type};
+    taosProcPutToParentQ(pWrapper->procObj, &msg, sizeof(SRpcMsg), NULL, 0, PROC_FUNC_RELEASE);
+  }
+}
+
+static void dmConsumeChildQueue(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
+                                EProcFuncType ftype) {
+  SRpcMsg *pRpc = &pMsg->rpcMsg;
+  pRpc->pCont = pCont;
+  dTrace("msg:%p, get from child queue, handle:%p app:%p", pMsg, pRpc->handle, pRpc->ahandle);
+
+  NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pRpc->msgType)];
+  int32_t   code = (*msgFp)(pWrapper, pMsg);
+
+  if (code != 0) {
+    dError("msg:%p, failed to process since code:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
+    if (pRpc->msgType & 1U) {
+      SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = terrno};
+      dmSendRsp(pWrapper, &rsp);
+    }
+
+    dTrace("msg:%p, is freed", pMsg);
+    taosFreeQitem(pMsg);
+    rpcFreeCont(pCont);
+  }
+}
+
+static void dmConsumeParentQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
+                                 EProcFuncType ftype) {
+  pMsg->pCont = pCont;
+  dTrace("msg:%p, get from parent queue, ftype:%d handle:%p code:0x%04x mtype:%d, app:%p", pMsg, ftype, pMsg->handle,
+         pMsg->code & 0xFFFF, pMsg->msgType, pMsg->ahandle);
+
+  switch (ftype) {
+    case PROC_FUNC_REGIST:
+      rpcRegisterBrokenLinkArg(pMsg);
+      break;
+    case PROC_FUNC_RELEASE:
+      taosProcRemoveHandle(pWrapper->procObj, pMsg->handle);
+      rpcReleaseHandle(pMsg->handle, (int8_t)pMsg->code);
+      rpcFreeCont(pCont);
+      break;
+    case PROC_FUNC_REQ:
+      dmSendRpcReq(pWrapper->pDnode, (SEpSet *)((char *)pMsg + sizeof(SRpcMsg)), pMsg);
+      break;
+    case PROC_FUNC_RSP:
+      taosProcRemoveHandle(pWrapper->procObj, pMsg->handle);
+      dmSendRpcRsp(pWrapper->pDnode, pMsg);
+      break;
+    default:
+      break;
+  }
+  taosMemoryFree(pMsg);
+}
+
+SProcCfg dmGenProcCfg(SMgmtWrapper *pWrapper) {
+  SProcCfg cfg = {.childConsumeFp = (ProcConsumeFp)dmConsumeChildQueue,
+                  .childMallocHeadFp = (ProcMallocFp)taosAllocateQitem,
+                  .childFreeHeadFp = (ProcFreeFp)taosFreeQitem,
+                  .childMallocBodyFp = (ProcMallocFp)rpcMallocCont,
+                  .childFreeBodyFp = (ProcFreeFp)rpcFreeCont,
+                  .parentConsumeFp = (ProcConsumeFp)dmConsumeParentQueue,
+                  .parentMallocHeadFp = (ProcMallocFp)taosMemoryMalloc,
+                  .parentFreeHeadFp = (ProcFreeFp)taosMemoryFree,
+                  .parentMallocBodyFp = (ProcMallocFp)rpcMallocCont,
+                  .parentFreeBodyFp = (ProcFreeFp)rpcFreeCont,
+                  .shm = pWrapper->procShm,
+                  .parent = pWrapper,
+                  .name = pWrapper->name};
+  return cfg;
+}
+
+static int32_t dmInitClient(SDnode *pDnode) {
+  SDnodeTrans *pTrans = &pDnode->trans;
+
+  SRpcInit rpcInit = {0};
   rpcInit.label = "DND";
   rpcInit.numOfThreads = 1;
-  rpcInit.cfp = (RpcCfp)dndProcessMsg;
+  rpcInit.cfp = (RpcCfp)dmProcessMsg;
   rpcInit.sessions = 1024;
   rpcInit.connType = TAOS_CONN_CLIENT;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
@@ -171,8 +391,8 @@ static int32_t dndInitClient(SDnode *pDnode) {
   taosEncryptPass_c((uint8_t *)(INTERNAL_SECRET), strlen(INTERNAL_SECRET), pass);
   rpcInit.secret = pass;
 
-  pMgmt->clientRpc = rpcOpen(&rpcInit);
+  pTrans->clientRpc = rpcOpen(&rpcInit);
-  if (pMgmt->clientRpc == NULL) {
+  if (pTrans->clientRpc == NULL) {
     dError("failed to init dnode rpc client");
     return -1;
   }
@@ -181,23 +401,16 @@ static int32_t dndInitClient(SDnode *pDnode) {
   return 0;
 }
 
-static void dndCleanupClient(SDnode *pDnode) {
+static void dmCleanupClient(SDnode *pDnode) {
-  STransMgmt *pMgmt = &pDnode->trans;
+  SDnodeTrans *pTrans = &pDnode->trans;
-  if (pMgmt->clientRpc) {
+  if (pTrans->clientRpc) {
-    rpcClose(pMgmt->clientRpc);
+    rpcClose(pTrans->clientRpc);
-    pMgmt->clientRpc = NULL;
+    pTrans->clientRpc = NULL;
     dDebug("dnode rpc client is closed");
   }
 }
 
-static inline void dndSendMsgToMnodeRecv(SDnode *pDnode, SRpcMsg *pReq, SRpcMsg *pRsp) {
+static inline int32_t dmGetHideUserAuth(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret,
-  SEpSet        epSet = {0};
-  SMgmtWrapper *pWrapper = &pDnode->wrappers[DNODE];
-  dmGetMnodeEpSet(pWrapper->pMgmt, &epSet);
-  rpcSendRecv(pDnode->trans.clientRpc, &epSet, pReq, pRsp);
-}
-
-static inline int32_t dndGetHideUserAuth(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret,
                                         char *ckey) {
   int32_t code = 0;
   char    pass[TSDB_PASSWORD_LEN + 1] = {0};
@@ -220,8 +433,9 @@ static inline int32_t dndGetHideUserAuth(SDnode *pDnode, char *user, char *spi,
   return code;
 }
 
-static int32_t dndRetrieveUserAuthInfo(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret, char *ckey) {
+static inline int32_t dmRetrieveUserAuthInfo(SDnode *pDnode, char *user, char *spi, char *encrypt, char *secret,
-  if (dndGetHideUserAuth(pDnode, user, spi, encrypt, secret, ckey) == 0) {
+                                             char *ckey) {
+  if (dmGetHideUserAuth(pDnode, user, spi, encrypt, secret, ckey) == 0) {
     dTrace("user:%s, get auth from mnode, spi:%d encrypt:%d", user, *spi, *encrypt);
     return 0;
   }
@@ -235,7 +449,7 @@ static int32_t dndRetrieveUserAuthInfo(SDnode *pDnode, char *user, char *spi, ch
   SRpcMsg rpcMsg = {.pCont = pReq, .contLen = contLen, .msgType = TDMT_MND_AUTH, .ahandle = (void *)9528};
   SRpcMsg rpcRsp = {0};
   dTrace("user:%s, send user auth req to other mnodes, spi:%d encrypt:%d", user, authReq.spi, authReq.encrypt);
-  dndSendMsgToMnodeRecv(pDnode, &rpcMsg, &rpcRsp);
+  dmSendToMnodeRecv(pDnode, &rpcMsg, &rpcRsp);
 
   if (rpcRsp.code != 0) {
     terrno = rpcRsp.code;
@@ -255,23 +469,22 @@ static int32_t dndRetrieveUserAuthInfo(SDnode *pDnode, char *user, char *spi, ch
   return rpcRsp.code;
 }
 
-static int32_t dndInitServer(SDnode *pDnode) {
+static int32_t dmInitServer(SDnode *pDnode) {
-  STransMgmt *pMgmt = &pDnode->trans;
+  SDnodeTrans *pTrans = &pDnode->trans;
 
-  SRpcInit rpcInit;
+  SRpcInit rpcInit = {0};
-  memset(&rpcInit, 0, sizeof(rpcInit));
+  rpcInit.localPort = pDnode->data.serverPort;
-  rpcInit.localPort = pDnode->serverPort;
   rpcInit.label = "DND";
   rpcInit.numOfThreads = tsNumOfRpcThreads;
-  rpcInit.cfp = (RpcCfp)dndProcessMsg;
+  rpcInit.cfp = (RpcCfp)dmProcessMsg;
   rpcInit.sessions = tsMaxShellConns;
   rpcInit.connType = TAOS_CONN_SERVER;
   rpcInit.idleTime = tsShellActivityTimer * 1000;
-  rpcInit.afp = (RpcAfp)dndRetrieveUserAuthInfo;
+  rpcInit.afp = (RpcAfp)dmRetrieveUserAuthInfo;
   rpcInit.parent = pDnode;
 
-  pMgmt->serverRpc = rpcOpen(&rpcInit);
+  pTrans->serverRpc = rpcOpen(&rpcInit);
-  if (pMgmt->serverRpc == NULL) {
+  if (pTrans->serverRpc == NULL) {
     dError("failed to init dnode rpc server");
     return -1;
   }
@@ -280,209 +493,33 @@ static int32_t dndInitServer(SDnode *pDnode) {
   return 0;
 }
 
-static void dndCleanupServer(SDnode *pDnode) {
+static void dmCleanupServer(SDnode *pDnode) {
-  STransMgmt *pMgmt = &pDnode->trans;
+  SDnodeTrans *pTrans = &pDnode->trans;
-  if (pMgmt->serverRpc) {
+  if (pTrans->serverRpc) {
-    rpcClose(pMgmt->serverRpc);
+    rpcClose(pTrans->serverRpc);
-    pMgmt->serverRpc = NULL;
+    pTrans->serverRpc = NULL;
     dDebug("dnode rpc server is closed");
   }
 }
 
-int32_t dndInitTrans(SDnode *pDnode) {
+int32_t dmInitTrans(SDnode *pDnode) {
-  if (dndInitServer(pDnode) != 0) return -1;
+  if (dmInitServer(pDnode) != 0) return -1;
-  if (dndInitClient(pDnode) != 0) return -1;
+  if (dmInitClient(pDnode) != 0) return -1;
   return 0;
 }
 
-void dndCleanupTrans(SDnode *pDnode) {
+void dmCleanupTrans(SDnode *pDnode) {
-  dndCleanupServer(pDnode);
+  dmCleanupServer(pDnode);
-  dndCleanupClient(pDnode);
+  dmCleanupClient(pDnode);
 }
 
-int32_t dndInitMsgHandle(SDnode *pDnode) {
+SMsgCb dmGetMsgcb(SMgmtWrapper *pWrapper) {
-  STransMgmt *pMgmt = &pDnode->trans;
-
-  for (EDndType n = 0; n < NODE_MAX; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-
-    for (int32_t msgIndex = 0; msgIndex < TDMT_MAX; ++msgIndex) {
-      NodeMsgFp msgFp = pWrapper->msgFps[msgIndex];
-      int8_t    vgId = pWrapper->msgVgIds[msgIndex];
-      if (msgFp == NULL) continue;
-
-      SMsgHandle *pHandle = &pMgmt->msgHandles[msgIndex];
-      if (vgId == QNODE_HANDLE) {
-        if (pHandle->pQndWrapper != NULL) {
-          dError("msg:%s has multiple process nodes", tMsgInfo[msgIndex]);
-          return -1;
-        }
-        pHandle->pQndWrapper = pWrapper;
-      } else if (vgId == MNODE_HANDLE) {
-        if (pHandle->pMndWrapper != NULL) {
-          dError("msg:%s has multiple process nodes", tMsgInfo[msgIndex]);
-          return -1;
-        }
-        pHandle->pMndWrapper = pWrapper;
-      } else {
-        if (pHandle->pWrapper != NULL) {
-          dError("msg:%s has multiple process nodes", tMsgInfo[msgIndex]);
-          return -1;
-        }
-        pHandle->pWrapper = pWrapper;
-      }
-    }
-  }
-
-  return 0;
-}
-
-static int32_t dndSendRpcReq(STransMgmt *pMgmt, const SEpSet *pEpSet, SRpcMsg *pReq) {
-  if (pMgmt->clientRpc == NULL) {
-    terrno = TSDB_CODE_NODE_OFFLINE;
-    return -1;
-  }
-
-  rpcSendRequest(pMgmt->clientRpc, pEpSet, pReq, NULL);
-  return 0;
-}
-
-static void dndSendRpcRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
-  if (pRsp->code == TSDB_CODE_APP_NOT_READY || pRsp->code == TSDB_CODE_NODE_REDIRECT ||
-      pRsp->code == TSDB_CODE_NODE_OFFLINE) {
-    dmSendRedirectRsp(pWrapper->pMgmt, pRsp);
-  } else {
-    rpcSendResponse(pRsp);
-  }
-}
-
-static int32_t dndSendReq(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pReq) {
-  if (dndGetStatus(pWrapper->pDnode) != DND_STAT_RUNNING) {
-    terrno = TSDB_CODE_NODE_OFFLINE;
-    dError("failed to send rpc msg since %s, handle:%p", terrstr(), pReq->handle);
-    return -1;
-  }
-
-  if (pWrapper->procType != PROC_CHILD) {
-    return dndSendRpcReq(&pWrapper->pDnode->trans, pEpSet, pReq);
-  } else {
-    char *pHead = taosMemoryMalloc(sizeof(SRpcMsg) + sizeof(SEpSet));
-    if (pHead == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
-    }
-
-    memcpy(pHead, pReq, sizeof(SRpcMsg));
-    memcpy(pHead + sizeof(SRpcMsg), pEpSet, sizeof(SEpSet));
-    taosProcPutToParentQ(pWrapper->pProc, pHead, sizeof(SRpcMsg) + sizeof(SEpSet), pReq->pCont, pReq->contLen,
-                         PROC_REQ);
-    taosMemoryFree(pHead);
-    return 0;
-  }
-}
-
-static void dndSendRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
-  if (pWrapper->procType != PROC_CHILD) {
-    dndSendRpcRsp(pWrapper, pRsp);
-  } else {
-    taosProcPutToParentQ(pWrapper->pProc, pRsp, sizeof(SRpcMsg), pRsp->pCont, pRsp->contLen, PROC_RSP);
-  }
-}
-
-static void dndRegisterBrokenLinkArg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg) {
-  if (pWrapper->procType != PROC_CHILD) {
-    rpcRegisterBrokenLinkArg(pMsg);
-  } else {
-    taosProcPutToParentQ(pWrapper->pProc, pMsg, sizeof(SRpcMsg), pMsg->pCont, pMsg->contLen, PROC_REGIST);
-  }
-}
-
-static void dndReleaseHandle(SMgmtWrapper *pWrapper, void *handle, int8_t type) {
-  if (pWrapper->procType != PROC_CHILD) {
-    rpcReleaseHandle(handle, type);
-  } else {
-    SRpcMsg msg = {.handle = handle, .code = type};
-    taosProcPutToParentQ(pWrapper->pProc, &msg, sizeof(SRpcMsg), NULL, 0, PROC_RELEASE);
-  }
-}
-
-SMsgCb dndCreateMsgcb(SMgmtWrapper *pWrapper) {
   SMsgCb msgCb = {
+      .sendReqFp = dmSendReq,
+      .sendRspFp = dmSendRsp,
+      .registerBrokenLinkArgFp = dmRegisterBrokenLinkArg,
+      .releaseHandleFp = dmReleaseHandle,
       .pWrapper = pWrapper,
-      .sendReqFp = dndSendReq,
-      .sendRspFp = dndSendRsp,
-      .registerBrokenLinkArgFp = dndRegisterBrokenLinkArg,
-      .releaseHandleFp = dndReleaseHandle,
   };
   return msgCb;
 }
-
-static void dndConsumeChildQueue(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
-                                 ProcFuncType ftype) {
-  SRpcMsg *pRpc = &pMsg->rpcMsg;
-  pRpc->pCont = pCont;
-  dTrace("msg:%p, get from child queue, handle:%p app:%p", pMsg, pRpc->handle, pRpc->ahandle);
-
-  NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pRpc->msgType)];
-  int32_t   code = (*msgFp)(pWrapper, pMsg);
-
-  if (code != 0) {
-    dError("msg:%p, failed to process since code:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
-    if (pRpc->msgType & 1U) {
-      SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = terrno};
-      dndSendRsp(pWrapper, &rsp);
-    }
-
-    dTrace("msg:%p, is freed", pMsg);
-    taosFreeQitem(pMsg);
-    rpcFreeCont(pCont);
-  }
-}
-
-static void dndConsumeParentQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
-                                  ProcFuncType ftype) {
-  pMsg->pCont = pCont;
-  dTrace("msg:%p, get from parent queue, ftype:%d handle:%p, app:%p", pMsg, ftype, pMsg->handle, pMsg->ahandle);
-
-  switch (ftype) {
-    case PROC_REGIST:
-      rpcRegisterBrokenLinkArg(pMsg);
-      break;
-    case PROC_RELEASE:
-      taosProcRemoveHandle(pWrapper->pProc, pMsg->handle);
-      rpcReleaseHandle(pMsg->handle, (int8_t)pMsg->code);
-      rpcFreeCont(pCont);
-      break;
-    case PROC_REQ:
-      dndSendRpcReq(&pWrapper->pDnode->trans, (SEpSet *)((char *)pMsg + sizeof(SRpcMsg)), pMsg);
-      break;
-    case PROC_RSP:
-      taosProcRemoveHandle(pWrapper->pProc, pMsg->handle);
-      dndSendRpcRsp(pWrapper, pMsg);
-      break;
-    default:
-      break;
-  }
-  taosMemoryFree(pMsg);
-}
-
-SProcCfg dndGenProcCfg(SMgmtWrapper *pWrapper) {
-  SProcCfg cfg = {.childConsumeFp = (ProcConsumeFp)dndConsumeChildQueue,
-                  .childMallocHeadFp = (ProcMallocFp)taosAllocateQitem,
-                  .childFreeHeadFp = (ProcFreeFp)taosFreeQitem,
-                  .childMallocBodyFp = (ProcMallocFp)rpcMallocCont,
-                  .childFreeBodyFp = (ProcFreeFp)rpcFreeCont,
-                  .parentConsumeFp = (ProcConsumeFp)dndConsumeParentQueue,
-                  .parentMallocHeadFp = (ProcMallocFp)taosMemoryMalloc,
-                  .parentFreeHeadFp = (ProcFreeFp)taosMemoryFree,
-                  .parentMallocBodyFp = (ProcMallocFp)rpcMallocCont,
-                  .parentFreeBodyFp = (ProcFreeFp)rpcFreeCont,
-                  .shm = pWrapper->shm,
-                  .parent = pWrapper,
-                  .name = pWrapper->name};
-  return cfg;
-}
-
-void dndSendRecv(SDnode *pDnode, SEpSet *pEpSet, SRpcMsg *pReq, SRpcMsg *pRsp) {
-  rpcSendRecv(pDnode->trans.clientRpc, pEpSet, pReq, pRsp);
-}

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

@@ -0,0 +1,181 @@
+/*
+ * 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 *dmStatusThreadFp(void *param) {
+  SDnode *pDnode = param;
+  int64_t lastTime = taosGetTimestampMs();
+
+  setThreadName("dnode-status");
+
+  while (1) {
+    taosThreadTestCancel();
+    taosMsleep(200);
+
+    if (pDnode->status != DND_STAT_RUNNING || pDnode->data.dropped) {
+      continue;
+    }
+
+    int64_t curTime = taosGetTimestampMs();
+    float   interval = (curTime - lastTime) / 1000.0f;
+    if (interval >= tsStatusInterval) {
+      dmSendStatusReq(pDnode);
+      lastTime = curTime;
+    }
+  }
+
+  return NULL;
+}
+
+static void *dmMonitorThreadFp(void *param) {
+  SDnode *pDnode = param;
+  int64_t lastTime = taosGetTimestampMs();
+
+  setThreadName("dnode-monitor");
+
+  while (1) {
+    taosThreadTestCancel();
+    taosMsleep(200);
+
+    if (pDnode->status != DND_STAT_RUNNING || pDnode->data.dropped) {
+      continue;
+    }
+
+    int64_t curTime = taosGetTimestampMs();
+    float   interval = (curTime - lastTime) / 1000.0f;
+    if (interval >= tsMonitorInterval) {
+      dmSendMonitorReport(pDnode);
+      lastTime = curTime;
+    }
+  }
+
+  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;
+    return -1;
+  }
+
+  return 0;
+}
+
+void dmStopStatusThread(SDnode *pDnode) {
+  if (pDnode->data.statusThreadId != NULL) {
+    taosDestoryThread(pDnode->data.statusThreadId);
+    pDnode->data.statusThreadId = 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;
+    return -1;
+  }
+
+  return 0;
+}
+
+void dmStopMonitorThread(SDnode *pDnode) {
+  if (pDnode->data.monitorThreadId != NULL) {
+    taosDestoryThread(pDnode->data.monitorThreadId);
+    pDnode->data.monitorThreadId = NULL;
+  }
+}
+
+static void dmProcessMgmtQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+  SDnode  *pDnode = pInfo->ahandle;
+  SRpcMsg *pRpc = &pMsg->rpcMsg;
+  int32_t  code = -1;
+  dTrace("msg:%p, will be processed in dnode-mgmt queue", pMsg);
+
+  switch (pRpc->msgType) {
+    case TDMT_DND_CONFIG_DNODE:
+      code = dmProcessConfigReq(pDnode, pMsg);
+      break;
+    case TDMT_MND_AUTH_RSP:
+      code = dmProcessAuthRsp(pDnode, pMsg);
+      break;
+    case TDMT_MND_GRANT_RSP:
+      code = dmProcessGrantRsp(pDnode, pMsg);
+      break;
+    case TDMT_DND_CREATE_MNODE:
+      code = dmProcessCreateNodeReq(pDnode, MNODE, pMsg);
+      break;
+    case TDMT_DND_DROP_MNODE:
+      code = dmProcessDropNodeReq(pDnode, MNODE, pMsg);
+      break;
+    case TDMT_DND_CREATE_QNODE:
+      code = dmProcessCreateNodeReq(pDnode, QNODE, pMsg);
+      break;
+    case TDMT_DND_DROP_QNODE:
+      code = dmProcessDropNodeReq(pDnode, QNODE, pMsg);
+      break;
+    case TDMT_DND_CREATE_SNODE:
+      code = dmProcessCreateNodeReq(pDnode, SNODE, pMsg);
+      break;
+    case TDMT_DND_DROP_SNODE:
+      code = dmProcessDropNodeReq(pDnode, SNODE, pMsg);
+      break;
+    case TDMT_DND_CREATE_BNODE:
+      code = dmProcessCreateNodeReq(pDnode, BNODE, pMsg);
+      break;
+    case TDMT_DND_DROP_BNODE:
+      code = dmProcessDropNodeReq(pDnode, BNODE, pMsg);
+      break;
+    default:
+      break;
+  }
+
+  if (pRpc->msgType & 1u) {
+    if (code != 0) code = terrno;
+    SRpcMsg rsp = {.handle = pRpc->handle, .ahandle = pRpc->ahandle, .code = code};
+    rpcSendResponse(&rsp);
+  }
+
+  dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
+  rpcFreeCont(pMsg->rpcMsg.pCont);
+  taosFreeQitem(pMsg);
+}
+
+int32_t dmStartWorker(SDnode *pDnode) {
+  SSingleWorkerCfg cfg = {.min = 1, .max = 1, .name = "dnode-mgmt", .fp = (FItem)dmProcessMgmtQueue, .param = pDnode};
+  if (tSingleWorkerInit(&pDnode->data.mgmtWorker, &cfg) != 0) {
+    dError("failed to start dnode-mgmt worker since %s", terrstr());
+    return -1;
+  }
+
+  dDebug("dnode workers are initialized");
+  return 0;
+}
+
+void dmStopWorker(SDnode *pDnode) {
+  tSingleWorkerCleanup(&pDnode->data.mgmtWorker);
+  dDebug("dnode workers are closed");
+}
+
+int32_t dmProcessMgmtMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
+  SSingleWorker *pWorker = &pWrapper->pDnode->data.mgmtWorker;
+  dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
+  taosWriteQitem(pWorker->queue, pMsg);
+  return 0;
+}

source/dnode/mgmt/inc/dmInt.h

@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_DND_DNODE_INT_H_
-#define _TD_DND_DNODE_INT_H_
-
-#include "dndInt.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct SDnodeMgmt {
-  int64_t       dver;
-  int64_t       updateTime;
-  int8_t        statusSent;
-  SEpSet        mnodeEpSet;
-  SHashObj     *dnodeHash;
-  SArray       *dnodeEps;
-  TdThread     *threadId;
-  SRWLatch      latch;
-  SSingleWorker mgmtWorker;
-  SSingleWorker monitorWorker;
-  SMsgCb        msgCb;
-  const char   *path;
-  SDnode       *pDnode;
-  SMgmtWrapper *pWrapper;
-} SDnodeMgmt;
-
-// dmFile.c
-int32_t dmReadFile(SDnodeMgmt *pMgmt);
-int32_t dmWriteFile(SDnodeMgmt *pMgmt);
-void    dmUpdateDnodeEps(SDnodeMgmt *pMgmt, SArray *pDnodeEps);
-
-// dmHandle.c
-void    dmInitMsgHandle(SMgmtWrapper *pWrapper);
-void    dmSendStatusReq(SDnodeMgmt *pMgmt);
-int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
-int32_t dmProcessStatusRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
-int32_t dmProcessAuthRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
-int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
-int32_t dmProcessCDnodeReq(SDnode *pDnode, SNodeMsg *pMsg);
-
-// dmMonitor.c
-void dmGetVnodeLoads(SMgmtWrapper *pWrapper, SMonVloadInfo *pInfo);
-void dmSendMonitorReport(SDnode *pDnode);
-
-// dmWorker.c
-int32_t dmStartThread(SDnodeMgmt *pMgmt);
-int32_t dmStartWorker(SDnodeMgmt *pMgmt);
-void    dmStopWorker(SDnodeMgmt *pMgmt);
-int32_t dmProcessMgmtMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-int32_t dmProcessMonitorMsg(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DND_DNODE_INT_H_*/

source/dnode/mgmt/inc/dndInt.h

@@ -1,198 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_DND_INT_H_
-#define _TD_DND_INT_H_
-
-#include "os.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 "monitor.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__); }}
-
-typedef enum { DNODE, VNODES, QNODE, SNODE, MNODE, BNODE, NODE_MAX } EDndType;
-typedef enum { DND_STAT_INIT, DND_STAT_RUNNING, DND_STAT_STOPPED } EDndStatus;
-typedef enum { DND_ENV_INIT, DND_ENV_READY, DND_ENV_CLEANUP } EEnvStatus;
-typedef enum { PROC_SINGLE, PROC_CHILD, PROC_PARENT } EProcType;
-
-typedef struct SMgmtFp      SMgmtFp;
-typedef struct SMgmtWrapper SMgmtWrapper;
-typedef struct SMsgHandle   SMsgHandle;
-typedef struct SDnodeMgmt   SDnodeMgmt;
-typedef struct SVnodesMgmt  SVnodesMgmt;
-typedef struct SMnodeMgmt   SMnodeMgmt;
-typedef struct SQnodeMgmt   SQnodeMgmt;
-typedef struct SSnodeMgmt   SSnodeMgmt;
-typedef struct SBnodeMgmt   SBnodeMgmt;
-
-typedef int32_t (*NodeMsgFp)(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-typedef int32_t (*OpenNodeFp)(SMgmtWrapper *pWrapper);
-typedef void (*CloseNodeFp)(SMgmtWrapper *pWrapper);
-typedef int32_t (*StartNodeFp)(SMgmtWrapper *pWrapper);
-typedef int32_t (*CreateNodeFp)(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-typedef int32_t (*DropNodeFp)(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
-typedef int32_t (*RequireNodeFp)(SMgmtWrapper *pWrapper, bool *required);
-
-typedef struct SMsgHandle {
-  SMgmtWrapper *pQndWrapper;
-  SMgmtWrapper *pMndWrapper;
-  SMgmtWrapper *pWrapper;
-} SMsgHandle;
-
-typedef struct SMgmtFp {
-  OpenNodeFp    openFp;
-  CloseNodeFp   closeFp;
-  StartNodeFp   startFp;
-  CreateNodeFp  createMsgFp;
-  DropNodeFp    dropMsgFp;
-  RequireNodeFp requiredFp;
-} SMgmtFp;
-
-typedef struct SMgmtWrapper {
-  const char *name;
-  char       *path;
-  int32_t     refCount;
-  SRWLatch    latch;
-  EDndType    ntype;
-  bool        deployed;
-  bool        required;
-  EProcType   procType;
-  int32_t     procId;
-  SProcObj   *pProc;
-  SShm        shm;
-  void       *pMgmt;
-  SDnode     *pDnode;
-  SMgmtFp     fp;
-  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];
-} STransMgmt;
-
-typedef struct SDnode {
-  int64_t      clusterId;
-  int32_t      dnodeId;
-  int32_t      numOfSupportVnodes;
-  int64_t      rebootTime;
-  char        *localEp;
-  char        *localFqdn;
-  char        *firstEp;
-  char        *secondEp;
-  char        *dataDir;
-  SDiskCfg    *disks;
-  int32_t      numOfDisks;
-  uint16_t     serverPort;
-  bool         dropped;
-  EDndType     ntype;
-  EDndStatus   status;
-  EDndEvent    event;
-  SStartupReq  startup;
-  TdFilePtr    lockfile;
-  STransMgmt   trans;
-  SMgmtWrapper wrappers[NODE_MAX];
-} SDnode;
-
-// dndEnv.c
-const char *dndStatStr(EDndStatus stat);
-const char *dndNodeLogStr(EDndType ntype);
-const char *dndNodeProcStr(EDndType ntype);
-const char *dndEventStr(EDndEvent ev);
-
-// dndExec.c
-int32_t dndOpenNode(SMgmtWrapper *pWrapper);
-void    dndCloseNode(SMgmtWrapper *pWrapper);
-
-// dndFile.c
-int32_t   dndReadFile(SMgmtWrapper *pWrapper, bool *pDeployed);
-int32_t   dndWriteFile(SMgmtWrapper *pWrapper, bool deployed);
-TdFilePtr dndCheckRunning(const char *dataDir);
-int32_t   dndReadShmFile(SDnode *pDnode);
-int32_t   dndWriteShmFile(SDnode *pDnode);
-
-// dndInt.c
-EDndStatus    dndGetStatus(SDnode *pDnode);
-void          dndSetStatus(SDnode *pDnode, EDndStatus stat);
-void          dndSetMsgHandle(SMgmtWrapper *pWrapper, tmsg_t msgType, NodeMsgFp nodeMsgFp, int8_t vgId);
-SMgmtWrapper *dndAcquireWrapper(SDnode *pDnode, EDndType nType);
-int32_t       dndMarkWrapper(SMgmtWrapper *pWrapper);
-void          dndReleaseWrapper(SMgmtWrapper *pWrapper);
-void          dndHandleEvent(SDnode *pDnode, EDndEvent event);
-void          dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc);
-void          dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pMsg);
-
-// dndTransport.c
-int32_t  dndInitTrans(SDnode *pDnode);
-void     dndCleanupTrans(SDnode *pDnode);
-SMsgCb   dndCreateMsgcb(SMgmtWrapper *pWrapper);
-SProcCfg dndGenProcCfg(SMgmtWrapper *pWrapper);
-int32_t  dndInitMsgHandle(SDnode *pDnode);
-void     dndSendRecv(SDnode *pDnode, SEpSet *pEpSet, SRpcMsg *pReq, SRpcMsg *pRsp);
-
-// mgmt
-void dmSetMgmtFp(SMgmtWrapper *pWrapper);
-void bmSetMgmtFp(SMgmtWrapper *pWrapper);
-void qmSetMgmtFp(SMgmtWrapper *pMgmt);
-void smSetMgmtFp(SMgmtWrapper *pWrapper);
-void vmSetMgmtFp(SMgmtWrapper *pWrapper);
-void mmSetMgmtFp(SMgmtWrapper *pMgmt);
-
-void dmGetMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet);
-void dmUpdateMnodeEpSet(SDnodeMgmt *pMgmt, SEpSet *pEpSet);
-void dmSendRedirectRsp(SDnodeMgmt *pMgmt, const SRpcMsg *pMsg);
-
-void dmGetMonitorSysInfo(SMonSysInfo *pInfo);
-void vmGetVnodeLoads(SMgmtWrapper *pWrapper, SMonVloadInfo *pInfo);
-void mmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonMmInfo *mmInfo);
-void vmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonVmInfo *vmInfo);
-void qmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonQmInfo *qmInfo);
-void smGetMonitorInfo(SMgmtWrapper *pWrapper, SMonSmInfo *smInfo);
-void bmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonBmInfo *bmInfo);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DND_INT_H_*/

source/dnode/mgmt/interface/CMakeLists.txt

@@ -0,0 +1,10 @@
+aux_source_directory(src DNODE_INTERFACE)
+add_library(dnode_interface STATIC ${DNODE_INTERFACE})
+target_include_directories(
+    dnode_interface
+    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 tfs monitor
+)

source/dnode/mgmt/interface/inc/dmDef.h

@@ -0,0 +1,151 @@
+/*
+ * 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 "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"
+
+#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;
+  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 SDnode {
+  EDndProcType  ptype;
+  EDndNodeType  ntype;
+  EDndRunStatus status;
+  EDndEvent     event;
+  SStartupReq   startup;
+  SDnodeTrans   trans;
+  SDnodeData    data;
+  TdThreadMutex mutex;
+  SMgmtWrapper  wrappers[NODE_END];
+} SDnode;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_DM_DEF_H_*/

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

@@ -0,0 +1,52 @@
+/*
+ * 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_INT_H_
+#define _TD_DM_INT_H_
+
+#include "dmDef.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   dmProcessStartupReq(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);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_DM_INT_H_*/

source/dnode/mgmt/interface/inc/dmLog.h

@@ -0,0 +1,36 @@
+/*
+ * 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_*/

source/dnode/mgmt/interface/src/dmEnv.c

@@ -14,12 +14,12 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dndInt.h"
+#include "dmInt.h"
 #include "wal.h"
 
 static int8_t once = DND_ENV_INIT;
 
-int32_t dndInit() {
+int32_t dmInit() {
   dDebug("start to init dnode env");
   if (atomic_val_compare_exchange_8(&once, DND_ENV_INIT, DND_ENV_READY) != DND_ENV_INIT) {
     terrno = TSDB_CODE_REPEAT_INIT;
@@ -45,7 +45,7 @@ int32_t dndInit() {
   return 0;
 }
 
-void dndCleanup() {
+void dmCleanup() {
   dDebug("start to cleanup dnode env");
   if (atomic_val_compare_exchange_8(&once, DND_ENV_READY, DND_ENV_CLEANUP) != DND_ENV_READY) {
     dError("dnode env is already cleaned up");
@@ -57,63 +57,3 @@ void dndCleanup() {
   taosStopCacheRefreshWorker();
   dInfo("dnode env is cleaned up");
 }
-
-const char *dndStatStr(EDndStatus status) {
-  switch (status) {
-    case DND_STAT_INIT:
-      return "init";
-    case DND_STAT_RUNNING:
-      return "running";
-    case DND_STAT_STOPPED:
-      return "stopped";
-    default:
-      return "UNKNOWN";
-  }
-}
-
-const char *dndNodeLogStr(EDndType ntype) {
-  switch (ntype) {
-    case VNODES:
-      return "vnode";
-    case QNODE:
-      return "qnode";
-    case SNODE:
-      return "snode";
-    case MNODE:
-      return "mnode";
-    case BNODE:
-      return "bnode";
-    default:
-      return "taosd";
-  }
-}
-
-const char *dndNodeProcStr(EDndType ntype) {
-  switch (ntype) {
-    case VNODES:
-      return "taosv";
-    case QNODE:
-      return "taosq";
-    case SNODE:
-      return "taoss";
-    case MNODE:
-      return "taosm";
-    case BNODE:
-      return "taosb";
-    default:
-      return "taosd";
-  }
-}
-
-const char *dndEventStr(EDndEvent ev) {
-  switch (ev) {
-    case DND_EVENT_START:
-      return "start";
-    case DND_EVENT_STOP:
-      return "stop";
-    case DND_EVENT_CHILD:
-      return "child";
-    default:
-      return "UNKNOWN";
-  }
-}

source/dnode/mgmt/interface/src/dmFile.c

@@ -14,22 +14,22 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dndInt.h"
+#include "dmInt.h"
 
 #define MAXLEN 1024
 
-int32_t dndReadFile(SMgmtWrapper *pWrapper, bool *pDeployed) {
+int32_t dmReadFile(SMgmtWrapper *pWrapper, bool *pDeployed) {
   int32_t   code = TSDB_CODE_INVALID_JSON_FORMAT;
   int64_t   len = 0;
   char      content[MAXLEN + 1] = {0};
   cJSON    *root = NULL;
-  char      file[PATH_MAX];
+  char      file[PATH_MAX] = {0};
   TdFilePtr pFile = NULL;
 
   snprintf(file, sizeof(file), "%s%s%s.json", pWrapper->path, TD_DIRSEP, pWrapper->name);
   pFile = taosOpenFile(file, TD_FILE_READ);
   if (pFile == NULL) {
-    dDebug("file %s not exist", file);
+    // dDebug("file %s not exist", file);
     code = 0;
     goto _OVER;
   }
@@ -64,7 +64,7 @@ _OVER:
   return code;
 }
 
-int32_t dndWriteFile(SMgmtWrapper *pWrapper, bool deployed) {
+int32_t dmWriteFile(SMgmtWrapper *pWrapper, bool deployed) {
   int32_t   code = -1;
   int32_t   len = 0;
   char      content[MAXLEN + 1] = {0};
@@ -75,7 +75,7 @@ int32_t dndWriteFile(SMgmtWrapper *pWrapper, bool deployed) {
   snprintf(file, sizeof(file), "%s%s%s.json", pWrapper->path, TD_DIRSEP, pWrapper->name);
   snprintf(realfile, sizeof(realfile), "%s%s%s.json", pWrapper->path, TD_DIRSEP, pWrapper->name);
 
-  pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC);
   if (pFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     dError("failed to write %s since %s", file, terrstr());
@@ -117,11 +117,11 @@ _OVER:
   return code;
 }
 
-TdFilePtr dndCheckRunning(const char *dataDir) {
+TdFilePtr dmCheckRunning(const char *dataDir) {
   char filepath[PATH_MAX] = {0};
   snprintf(filepath, sizeof(filepath), "%s%s.running", dataDir, TD_DIRSEP);
 
-  TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC);
   if (pFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     dError("failed to lock file:%s since %s", filepath, terrstr());
@@ -140,18 +140,17 @@ TdFilePtr dndCheckRunning(const char *dataDir) {
   return pFile;
 }
 
-int32_t dndReadShmFile(SDnode *pDnode) {
+int32_t dmReadShmFile(SMgmtWrapper *pWrapper) {
   int32_t   code = -1;
-  char      itemName[24] = {0};
   char      content[MAXLEN + 1] = {0};
   char      file[PATH_MAX] = {0};
   cJSON    *root = NULL;
   TdFilePtr pFile = NULL;
 
-  snprintf(file, sizeof(file), "%s%s.shmfile", pDnode->dataDir, TD_DIRSEP);
+  snprintf(file, sizeof(file), "%s%sshmfile", pWrapper->path, TD_DIRSEP);
   pFile = taosOpenFile(file, TD_FILE_READ);
   if (pFile == NULL) {
-    dDebug("file %s not exist", file);
+    // dDebug("node:%s, file %s not exist", pWrapper->name, file);
     code = 0;
     goto _OVER;
   }
@@ -160,44 +159,36 @@ int32_t dndReadShmFile(SDnode *pDnode) {
     root = cJSON_Parse(content);
     if (root == NULL) {
       terrno = TSDB_CODE_INVALID_JSON_FORMAT;
-      dError("failed to read %s since invalid json format", file);
+      dError("node:%s, failed to read %s since invalid json format", pWrapper->name, file);
       goto _OVER;
     }
 
-    for (EDndType ntype = DNODE + 1; ntype < NODE_MAX; ++ntype) {
+    cJSON *shmid = cJSON_GetObjectItem(root, "shmid");
-      snprintf(itemName, sizeof(itemName), "%s_shmid", dndNodeProcStr(ntype));
-      cJSON *shmid = cJSON_GetObjectItem(root, itemName);
     if (shmid && shmid->type == cJSON_Number) {
-        pDnode->wrappers[ntype].shm.id = shmid->valueint;
+      pWrapper->procShm.id = shmid->valueint;
     }
 
-      snprintf(itemName, sizeof(itemName), "%s_shmsize", dndNodeProcStr(ntype));
+    cJSON *shmsize = cJSON_GetObjectItem(root, "shmsize");
-      cJSON *shmsize = cJSON_GetObjectItem(root, itemName);
     if (shmsize && shmsize->type == cJSON_Number) {
-        pDnode->wrappers[ntype].shm.size = shmsize->valueint;
+      pWrapper->procShm.size = shmsize->valueint;
-      }
     }
   }
 
-  if (!tsMultiProcess || pDnode->ntype == DNODE || pDnode->ntype == NODE_MAX) {
+  if (!tsMultiProcess || pWrapper->pDnode->ntype == DNODE || pWrapper->pDnode->ntype == NODE_END) {
-    for (EDndType ntype = DNODE; ntype < NODE_MAX; ++ntype) {
+    if (pWrapper->procShm.id >= 0) {
-      SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
+      dDebug("node:%s, shmid:%d, is closed, size:%d", pWrapper->name, pWrapper->procShm.id, pWrapper->procShm.size);
-      if (pWrapper->shm.id >= 0) {
+      taosDropShm(&pWrapper->procShm);
-        dDebug("shmid:%d, is closed, size:%d", pWrapper->shm.id, pWrapper->shm.size);
-        taosDropShm(&pWrapper->shm);
-      }
     }
   } else {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[pDnode->ntype];
+    if (taosAttachShm(&pWrapper->procShm) != 0) {
-    if (taosAttachShm(&pWrapper->shm) != 0) {
       terrno = TAOS_SYSTEM_ERROR(errno);
-      dError("shmid:%d, failed to attach shm since %s", pWrapper->shm.id, terrstr());
+      dError("shmid:%d, failed to attach shm since %s", pWrapper->procShm.id, terrstr());
       goto _OVER;
     }
-    dInfo("node:%s, shmid:%d is attached, size:%d", pWrapper->name, pWrapper->shm.id, pWrapper->shm.size);
+    dInfo("node:%s, shmid:%d is attached, size:%d", pWrapper->name, pWrapper->procShm.id, pWrapper->procShm.size);
   }
 
-  dDebug("successed to load %s", file);
+  dDebug("node:%s, successed to load %s", pWrapper->name, file);
   code = 0;
 
 _OVER:
@@ -207,7 +198,7 @@ _OVER:
   return code;
 }
 
-int32_t dndWriteShmFile(SDnode *pDnode) {
+int32_t dmWriteShmFile(SMgmtWrapper *pWrapper) {
   int32_t   code = -1;
   int32_t   len = 0;
   char      content[MAXLEN + 1] = {0};
@@ -215,37 +206,30 @@ int32_t dndWriteShmFile(SDnode *pDnode) {
   char      realfile[PATH_MAX] = {0};
   TdFilePtr pFile = NULL;
 
-  snprintf(file, sizeof(file), "%s%s.shmfile.bak", pDnode->dataDir, TD_DIRSEP);
+  snprintf(file, sizeof(file), "%s%sshmfile.bak", pWrapper->path, TD_DIRSEP);
-  snprintf(realfile, sizeof(realfile), "%s%s.shmfile", pDnode->dataDir, TD_DIRSEP);
+  snprintf(realfile, sizeof(realfile), "%s%sshmfile", pWrapper->path, TD_DIRSEP);
 
-  pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC);
   if (pFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to open file:%s since %s", file, terrstr());
+    dError("node:%s, failed to open file:%s since %s", pWrapper->name, file, terrstr());
     goto _OVER;
   }
 
   len += snprintf(content + len, MAXLEN - len, "{\n");
-  for (EDndType ntype = DNODE + 1; ntype < NODE_MAX; ++ntype) {
+  len += snprintf(content + len, MAXLEN - len, "  \"shmid\":%d,\n", pWrapper->procShm.id);
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
+  len += snprintf(content + len, MAXLEN - len, "  \"shmsize\":%d\n", pWrapper->procShm.size);
-    len += snprintf(content + len, MAXLEN - len, "  \"%s_shmid\":%d,\n", dndNodeProcStr(ntype), pWrapper->shm.id);
-    if (ntype == NODE_MAX - 1) {
-      len += snprintf(content + len, MAXLEN - len, "  \"%s_shmsize\":%d\n", dndNodeProcStr(ntype), pWrapper->shm.size);
-    } else {
-      len += snprintf(content + len, MAXLEN - len, "  \"%s_shmsize\":%d,\n", dndNodeProcStr(ntype), pWrapper->shm.size);
-    }
-  }
   len += snprintf(content + len, MAXLEN - len, "}\n");
 
   if (taosWriteFile(pFile, content, len) != len) {
     terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to write file:%s since %s", file, terrstr());
+    dError("node:%s, failed to write file:%s since %s", pWrapper->name, file, terrstr());
     goto _OVER;
   }
 
   if (taosFsyncFile(pFile) != 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to fsync file:%s since %s", file, terrstr());
+    dError("node:%s, failed to fsync file:%s since %s", pWrapper->name, file, terrstr());
     goto _OVER;
   }
 
@@ -253,11 +237,11 @@ int32_t dndWriteShmFile(SDnode *pDnode) {
 
   if (taosRenameFile(file, realfile) != 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to rename %s to %s since %s", file, realfile, terrstr());
+    dError("node:%s, failed to rename %s to %s since %s", pWrapper->name, file, realfile, terrstr());
     return -1;
   }
 
-  dInfo("successed to write %s", realfile);
+  dInfo("node:%s, successed to write %s", pWrapper->name, realfile);
   code = 0;
 
 _OVER:

source/dnode/mgmt/interface/src/dmInt.c

@@ -0,0 +1,173 @@
+/*
+ * 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"
+
+const char *dmStatName(EDndRunStatus status) {
+  switch (status) {
+    case DND_STAT_INIT:
+      return "init";
+    case DND_STAT_RUNNING:
+      return "running";
+    case DND_STAT_STOPPED:
+      return "stopped";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+const char *dmLogName(EDndNodeType ntype) {
+  switch (ntype) {
+    case VNODE:
+      return "vnode";
+    case QNODE:
+      return "qnode";
+    case SNODE:
+      return "snode";
+    case MNODE:
+      return "mnode";
+    case BNODE:
+      return "bnode";
+    default:
+      return "taosd";
+  }
+}
+
+const char *dmProcName(EDndNodeType ntype) {
+  switch (ntype) {
+    case VNODE:
+      return "taosv";
+    case QNODE:
+      return "taosq";
+    case SNODE:
+      return "taoss";
+    case MNODE:
+      return "taosm";
+    case BNODE:
+      return "taosb";
+    default:
+      return "taosd";
+  }
+}
+
+const char *dmEventName(EDndEvent ev) {
+  switch (ev) {
+    case DND_EVENT_START:
+      return "start";
+    case DND_EVENT_STOP:
+      return "stop";
+    case DND_EVENT_CHILD:
+      return "child";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+void dmSetStatus(SDnode *pDnode, EDndRunStatus status) {
+  if (pDnode->status != status) {
+    dDebug("dnode status set from %s to %s", dmStatName(pDnode->status), dmStatName(status));
+    pDnode->status = status;
+  }
+}
+
+void dmSetEvent(SDnode *pDnode, EDndEvent event) {
+  if (event == DND_EVENT_STOP) {
+    pDnode->event = event;
+  }
+}
+
+void dmSetMsgHandle(SMgmtWrapper *pWrapper, tmsg_t msgType, NodeMsgFp nodeMsgFp, int8_t vgId) {
+  pWrapper->msgFps[TMSG_INDEX(msgType)] = nodeMsgFp;
+  pWrapper->msgVgIds[TMSG_INDEX(msgType)] = vgId;
+}
+
+SMgmtWrapper *dmAcquireWrapper(SDnode *pDnode, EDndNodeType ntype) {
+  SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
+  SMgmtWrapper *pRetWrapper = pWrapper;
+
+  taosRLockLatch(&pWrapper->latch);
+  if (pWrapper->deployed) {
+    int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1);
+    dTrace("node:%s, is acquired, refCount:%d", pWrapper->name, refCount);
+  } else {
+    terrno = TSDB_CODE_NODE_NOT_DEPLOYED;
+    pRetWrapper = NULL;
+  }
+  taosRUnLockLatch(&pWrapper->latch);
+
+  return pRetWrapper;
+}
+
+int32_t dmMarkWrapper(SMgmtWrapper *pWrapper) {
+  int32_t code = 0;
+
+  taosRLockLatch(&pWrapper->latch);
+  if (pWrapper->deployed || (pWrapper->procType == DND_PROC_PARENT && pWrapper->required)) {
+    int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1);
+    dTrace("node:%s, is marked, refCount:%d", pWrapper->name, refCount);
+  } else {
+    terrno = TSDB_CODE_NODE_NOT_DEPLOYED;
+    code = -1;
+  }
+  taosRUnLockLatch(&pWrapper->latch);
+
+  return code;
+}
+
+void dmReleaseWrapper(SMgmtWrapper *pWrapper) {
+  if (pWrapper == NULL) return;
+
+  taosRLockLatch(&pWrapper->latch);
+  int32_t refCount = atomic_sub_fetch_32(&pWrapper->refCount, 1);
+  taosRUnLockLatch(&pWrapper->latch);
+  dTrace("node:%s, is released, refCount:%d", pWrapper->name, refCount);
+}
+
+void dmReportStartup(SDnode *pDnode, const char *pName, const char *pDesc) {
+  SStartupReq *pStartup = &pDnode->startup;
+  tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
+  tstrncpy(pStartup->desc, pDesc, TSDB_STEP_DESC_LEN);
+  pStartup->finished = 0;
+}
+
+static void dmGetStartup(SDnode *pDnode, SStartupReq *pStartup) {
+  memcpy(pStartup, &pDnode->startup, sizeof(SStartupReq));
+  pStartup->finished = (pDnode->status == DND_STAT_RUNNING);
+}
+
+void dmProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
+  dDebug("startup req is received");
+  SStartupReq *pStartup = rpcMallocCont(sizeof(SStartupReq));
+  dmGetStartup(pDnode, pStartup);
+
+  dDebug("startup req is sent, step:%s desc:%s finished:%d", pStartup->name, pStartup->desc, pStartup->finished);
+  SRpcMsg rpcRsp = {
+      .handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupReq), .ahandle = pReq->ahandle};
+  rpcSendResponse(&rpcRsp);
+}
+
+void dmGetMonitorSysInfo(SMonSysInfo *pInfo) {
+  taosGetCpuUsage(&pInfo->cpu_engine, &pInfo->cpu_system);
+  taosGetCpuCores(&pInfo->cpu_cores);
+  taosGetProcMemory(&pInfo->mem_engine);
+  taosGetSysMemory(&pInfo->mem_system);
+  pInfo->mem_total = tsTotalMemoryKB;
+  pInfo->disk_engine = 0;
+  pInfo->disk_used = tsDataSpace.size.used;
+  pInfo->disk_total = tsDataSpace.size.total;
+  taosGetCardInfoDelta(&pInfo->net_in, &pInfo->net_out);
+  taosGetProcIODelta(&pInfo->io_read, &pInfo->io_write, &pInfo->io_read_disk, &pInfo->io_write_disk);
+}

source/dnode/mgmt/main/dndExec.c

@@ -1,318 +0,0 @@
-/*
- * 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 "dndInt.h"
-
-static bool dndRequireNode(SMgmtWrapper *pWrapper) {
-  bool    required = false;
-  int32_t code = (*pWrapper->fp.requiredFp)(pWrapper, &required);
-  if (!required) {
-    dDebug("node:%s, does not require startup", pWrapper->name);
-  } else {
-    dDebug("node:%s, needs to be started", pWrapper->name);
-  }
-  return required;
-}
-
-int32_t dndOpenNode(SMgmtWrapper *pWrapper) {
-  if (taosMkDir(pWrapper->path) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("node:%s, failed to create dir:%s since %s", pWrapper->name, pWrapper->path, terrstr());
-    return -1;
-  }
-
-  if ((*pWrapper->fp.openFp)(pWrapper) != 0) {
-    dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
-    return -1;
-  }
-
-  dDebug("node:%s, has been opened", pWrapper->name);
-  pWrapper->deployed = true;
-  return 0;
-}
-
-void dndCloseNode(SMgmtWrapper *pWrapper) {
-  dDebug("node:%s, mgmt start to close", pWrapper->name);
-  pWrapper->required = false;
-  taosWLockLatch(&pWrapper->latch);
-  if (pWrapper->deployed) {
-    (*pWrapper->fp.closeFp)(pWrapper);
-    pWrapper->deployed = false;
-  }
-  taosWUnLockLatch(&pWrapper->latch);
-
-  while (pWrapper->refCount > 0) {
-    taosMsleep(10);
-  }
-
-  if (pWrapper->pProc) {
-    taosProcCleanup(pWrapper->pProc);
-    pWrapper->pProc = NULL;
-  }
-  dDebug("node:%s, mgmt has been closed", pWrapper->name);
-}
-
-
-static int32_t dndNewProc(SMgmtWrapper *pWrapper, EDndType n) {
-  char  tstr[8] = {0};
-  char *args[6] = {0};
-  snprintf(tstr, sizeof(tstr), "%d", n);
-  args[1] = "-c";
-  args[2] = configDir;
-  args[3] = "-n";
-  args[4] = tstr;
-  args[5] = NULL;
-
-  int32_t pid = taosNewProc(args);
-  if (pid <= 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("node:%s, failed to exec in new process since %s", pWrapper->name, terrstr());
-    return -1;
-  }
-
-  pWrapper->procId = pid;
-  dInfo("node:%s, continue running in new process:%d", pWrapper->name, pid);
-  return 0;
-}
-
-static void dndProcessProcHandle(void *handle) {
-  dWarn("handle:%p, the child process dies and send an offline rsp", handle);
-  SRpcMsg rpcMsg = {.handle = handle, .code = TSDB_CODE_NODE_OFFLINE};
-  rpcSendResponse(&rpcMsg);
-}
-
-static int32_t dndRunInSingleProcess(SDnode *pDnode) {
-  dInfo("dnode run in single process");
-
-  for (EDndType n = DNODE; n < NODE_MAX; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    pWrapper->required = dndRequireNode(pWrapper);
-    if (!pWrapper->required) continue;
-
-    if (dndOpenNode(pWrapper) != 0) {
-      dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
-      return -1;
-    }
-  }
-
-  dndSetStatus(pDnode, DND_STAT_RUNNING);
-
-  for (EDndType n = 0; n < NODE_MAX; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    if (!pWrapper->required) continue;
-    if (pWrapper->fp.startFp == NULL) continue;
-    if ((*pWrapper->fp.startFp)(pWrapper) != 0) {
-      dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
-      return -1;
-    }
-  }
-
-  dInfo("TDengine initialized successfully");
-  dndReportStartup(pDnode, "TDengine", "initialized successfully");
-  while (1) {
-    if (pDnode->event == DND_EVENT_STOP) {
-      dInfo("dnode is about to stop");
-      dndSetStatus(pDnode, DND_STAT_STOPPED);
-      break;
-    }
-    taosMsleep(100);
-  }
-
-  return 0;
-}
-
-static int32_t dndRunInParentProcess(SDnode *pDnode) {
-  dInfo("dnode run in parent process");
-  SMgmtWrapper *pDWrapper = &pDnode->wrappers[DNODE];
-  if (dndOpenNode(pDWrapper) != 0) {
-    dError("node:%s, failed to start since %s", pDWrapper->name, terrstr());
-    return -1;
-  }
-
-  for (EDndType n = DNODE + 1; n < NODE_MAX; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    pWrapper->required = dndRequireNode(pWrapper);
-    if (!pWrapper->required) continue;
-
-    int32_t shmsize = tsMnodeShmSize;
-    if (n == VNODES) {
-      shmsize = tsVnodeShmSize;
-    } else if (n == QNODE) {
-      shmsize = tsQnodeShmSize;
-    } else if (n == SNODE) {
-      shmsize = tsSnodeShmSize;
-    } else if (n == MNODE) {
-      shmsize = tsMnodeShmSize;
-    } else if (n == BNODE) {
-      shmsize = tsBnodeShmSize;
-    } else {
-    }
-
-    if (taosCreateShm(&pWrapper->shm, n, shmsize) != 0) {
-      terrno = TAOS_SYSTEM_ERROR(terrno);
-      dError("node:%s, failed to create shm size:%d since %s", pWrapper->name, shmsize, terrstr());
-      return -1;
-    }
-    dInfo("node:%s, shm:%d is created, size:%d", pWrapper->name, pWrapper->shm.id, shmsize);
-
-    SProcCfg cfg = dndGenProcCfg(pWrapper);
-    cfg.isChild = false;
-    pWrapper->procType = PROC_PARENT;
-    pWrapper->pProc = taosProcInit(&cfg);
-    if (pWrapper->pProc == NULL) {
-      dError("node:%s, failed to create proc since %s", pWrapper->name, terrstr());
-      return -1;
-    }
-  }
-
-  if (dndWriteShmFile(pDnode) != 0) {
-    dError("failed to write runtime file since %s", terrstr());
-    return -1;
-  }
-
-  for (EDndType n = DNODE + 1; n < NODE_MAX; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    if (!pWrapper->required) continue;
-
-    if (pDnode->ntype == NODE_MAX) {
-      dInfo("node:%s, should be started manually", pWrapper->name);
-    } else {
-      if (dndNewProc(pWrapper, n) != 0) {
-        return -1;
-      }
-    }
-
-    if (taosProcRun(pWrapper->pProc) != 0) {
-      dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr());
-      return -1;
-    }
-  }
-
-  dndSetStatus(pDnode, DND_STAT_RUNNING);
-
-  if ((*pDWrapper->fp.startFp)(pDWrapper) != 0) {
-    dError("node:%s, failed to start since %s", pDWrapper->name, terrstr());
-    return -1;
-  }
-
-  dInfo("TDengine initialized successfully");
-  dndReportStartup(pDnode, "TDengine", "initialized successfully");
-
-  while (1) {
-    if (pDnode->event == DND_EVENT_STOP) {
-      dInfo("dnode is about to stop");
-      dndSetStatus(pDnode, DND_STAT_STOPPED);
-
-      for (EDndType n = DNODE + 1; n < NODE_MAX; ++n) {
-        SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-        if (!pWrapper->required) continue;
-        if (pDnode->ntype == NODE_MAX) continue;
-
-        if (pWrapper->procId > 0 && taosProcExist(pWrapper->procId)) {
-          dInfo("node:%s, send kill signal to the child process:%d", pWrapper->name, pWrapper->procId);
-          taosKillProc(pWrapper->procId);
-          dInfo("node:%s, wait for child process:%d to stop", pWrapper->name, pWrapper->procId);
-          taosWaitProc(pWrapper->procId);
-          dInfo("node:%s, child process:%d is stopped", pWrapper->name, pWrapper->procId);
-        }
-      }
-      break;
-    } else {
-      for (EDndType n = DNODE + 1; n < NODE_MAX; ++n) {
-        SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-        if (!pWrapper->required) continue;
-        if (pDnode->ntype == NODE_MAX) continue;
-
-        if (pWrapper->procId <= 0 || !taosProcExist(pWrapper->procId)) {
-          dWarn("node:%s, process:%d is killed and needs to be restarted", pWrapper->name, pWrapper->procId);
-          taosProcCloseHandles(pWrapper->pProc, dndProcessProcHandle);
-          dndNewProc(pWrapper, n);
-        }
-      }
-    }
-
-    taosMsleep(100);
-  }
-
-  return 0;
-}
-
-static int32_t dndRunInChildProcess(SDnode *pDnode) {
-  SMgmtWrapper *pWrapper = &pDnode->wrappers[pDnode->ntype];
-  dInfo("%s run in child process", pWrapper->name);
-
-  pWrapper->required = dndRequireNode(pWrapper);
-  if (!pWrapper->required) {
-    dError("%s does not require startup", pWrapper->name);
-    return -1;
-  }
-
-  SMsgCb msgCb = dndCreateMsgcb(pWrapper);
-  tmsgSetDefaultMsgCb(&msgCb);
-  pWrapper->procType = PROC_CHILD;
-
-  if (dndOpenNode(pWrapper) != 0) {
-    dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
-    return -1;
-  }
-
-  SProcCfg cfg = dndGenProcCfg(pWrapper);
-  cfg.isChild = true;
-  pWrapper->pProc = taosProcInit(&cfg);
-  if (pWrapper->pProc == NULL) {
-    dError("node:%s, failed to create proc since %s", pWrapper->name, terrstr());
-    return -1;
-  }
-
-  if (pWrapper->fp.startFp != NULL) {
-    if ((*pWrapper->fp.startFp)(pWrapper) != 0) {
-      dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
-      return -1;
-    }
-  }
-
-  dndSetStatus(pDnode, DND_STAT_RUNNING);
-
-  if (taosProcRun(pWrapper->pProc) != 0) {
-    dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr());
-    return -1;
-  }
-
-  dInfo("TDengine initialized successfully");
-  dndReportStartup(pDnode, "TDengine", "initialized successfully");
-  while (1) {
-    if (pDnode->event == DND_EVENT_STOP) {
-      dInfo("%s is about to stop", pWrapper->name);
-      dndSetStatus(pDnode, DND_STAT_STOPPED);
-      break;
-    }
-    taosMsleep(100);
-  }
-
-  return 0;
-}
-
-int32_t dndRun(SDnode *pDnode) {
-  if (!tsMultiProcess) {
-    return dndRunInSingleProcess(pDnode);
-  } else if (pDnode->ntype == DNODE || pDnode->ntype == NODE_MAX) {
-    return dndRunInParentProcess(pDnode);
-  } else {
-    return dndRunInChildProcess(pDnode);
-  }
-
-  return 0;
-}

source/dnode/mgmt/main/dndInt.c

@@ -1,229 +0,0 @@
-/*
- * 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 "dndInt.h"
-
-static int32_t dndInitVars(SDnode *pDnode, const SDnodeOpt *pOption) {
-  pDnode->numOfSupportVnodes = pOption->numOfSupportVnodes;
-  pDnode->serverPort = pOption->serverPort;
-  pDnode->dataDir = strdup(pOption->dataDir);
-  pDnode->localEp = strdup(pOption->localEp);
-  pDnode->localFqdn = strdup(pOption->localFqdn);
-  pDnode->firstEp = strdup(pOption->firstEp);
-  pDnode->secondEp = strdup(pOption->secondEp);
-  pDnode->disks = pOption->disks;
-  pDnode->numOfDisks = pOption->numOfDisks;
-  pDnode->ntype = pOption->ntype;
-  pDnode->rebootTime = taosGetTimestampMs();
-
-  if (pDnode->dataDir == NULL || pDnode->localEp == NULL || pDnode->localFqdn == NULL || pDnode->firstEp == NULL ||
-      pDnode->secondEp == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  if (!tsMultiProcess || pDnode->ntype == DNODE || pDnode->ntype == NODE_MAX) {
-    pDnode->lockfile = dndCheckRunning(pDnode->dataDir);
-    if (pDnode->lockfile == NULL) {
-      return -1;
-    }
-  }
-
-  return 0;
-}
-
-static void dndClearVars(SDnode *pDnode) {
-  for (EDndType n = 0; n < NODE_MAX; ++n) {
-    SMgmtWrapper *pMgmt = &pDnode->wrappers[n];
-    taosMemoryFreeClear(pMgmt->path);
-  }
-  if (pDnode->lockfile != NULL) {
-    taosUnLockFile(pDnode->lockfile);
-    taosCloseFile(&pDnode->lockfile);
-    pDnode->lockfile = NULL;
-  }
-  taosMemoryFreeClear(pDnode->localEp);
-  taosMemoryFreeClear(pDnode->localFqdn);
-  taosMemoryFreeClear(pDnode->firstEp);
-  taosMemoryFreeClear(pDnode->secondEp);
-  taosMemoryFreeClear(pDnode->dataDir);
-  taosMemoryFree(pDnode);
-  dDebug("dnode memory is cleared, data:%p", pDnode);
-}
-
-SDnode *dndCreate(const SDnodeOpt *pOption) {
-  dDebug("start to create dnode object");
-  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 (dndInitVars(pDnode, pOption) != 0) {
-    dError("failed to init variables since %s", terrstr());
-    goto _OVER;
-  }
-
-  dndSetStatus(pDnode, DND_STAT_INIT);
-  dmSetMgmtFp(&pDnode->wrappers[DNODE]);
-  mmSetMgmtFp(&pDnode->wrappers[MNODE]);
-  vmSetMgmtFp(&pDnode->wrappers[VNODES]);
-  qmSetMgmtFp(&pDnode->wrappers[QNODE]);
-  smSetMgmtFp(&pDnode->wrappers[SNODE]);
-  bmSetMgmtFp(&pDnode->wrappers[BNODE]);
-
-  for (EDndType n = 0; n < NODE_MAX; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    snprintf(path, sizeof(path), "%s%s%s", pDnode->dataDir, TD_DIRSEP, pWrapper->name);
-    pWrapper->path = strdup(path);
-    pWrapper->shm.id = -1;
-    pWrapper->pDnode = pDnode;
-    pWrapper->ntype = n;
-    if (pWrapper->path == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      goto _OVER;
-    }
-
-    pWrapper->procType = PROC_SINGLE;
-    taosInitRWLatch(&pWrapper->latch);
-  }
-
-  if (dndInitMsgHandle(pDnode) != 0) {
-    dError("failed to init msg handles since %s", terrstr());
-    goto _OVER;
-  }
-
-  if (dndReadShmFile(pDnode) != 0) {
-    dError("failed to read shm file since %s", terrstr());
-    goto _OVER;
-  }
-
-  SMsgCb msgCb = dndCreateMsgcb(&pDnode->wrappers[0]);
-  tmsgSetDefaultMsgCb(&msgCb);
-
-  dInfo("dnode is created, data:%p", pDnode);
-  code = 0;
-
-_OVER:
-  if (code != 0 && pDnode) {
-    dndClearVars(pDnode);
-    pDnode = NULL;
-    dError("failed to create dnode since %s", terrstr());
-  }
-
-  return pDnode;
-}
-
-void dndClose(SDnode *pDnode) {
-  if (pDnode == NULL) return;
-
-  for (EDndType n = 0; n < NODE_MAX; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    dndCloseNode(pWrapper);
-  }
-
-  dndClearVars(pDnode);
-  dInfo("dnode is closed, data:%p", pDnode);
-}
-
-void dndHandleEvent(SDnode *pDnode, EDndEvent event) {
-  if (event == DND_EVENT_STOP) {
-    pDnode->event = event;
-  }
-}
-
-SMgmtWrapper *dndAcquireWrapper(SDnode *pDnode, EDndType ntype) {
-  SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
-  SMgmtWrapper *pRetWrapper = pWrapper;
-
-  taosRLockLatch(&pWrapper->latch);
-  if (pWrapper->deployed) {
-    int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1);
-    dTrace("node:%s, is acquired, refCount:%d", pWrapper->name, refCount);
-  } else {
-    terrno = TSDB_CODE_NODE_REDIRECT;
-    pRetWrapper = NULL;
-  }
-  taosRUnLockLatch(&pWrapper->latch);
-
-  return pRetWrapper;
-}
-
-int32_t dndMarkWrapper(SMgmtWrapper *pWrapper) {
-  int32_t code = 0;
-
-  taosRLockLatch(&pWrapper->latch);
-  if (pWrapper->deployed || (pWrapper->procType == PROC_PARENT && pWrapper->required)) {
-    int32_t refCount = atomic_add_fetch_32(&pWrapper->refCount, 1);
-    dTrace("node:%s, is marked, refCount:%d", pWrapper->name, refCount);
-  } else {
-    terrno = TSDB_CODE_NODE_REDIRECT;
-    code = -1;
-  }
-  taosRUnLockLatch(&pWrapper->latch);
-
-  return code;
-}
-
-void dndReleaseWrapper(SMgmtWrapper *pWrapper) {
-  if (pWrapper == NULL) return;
-
-  taosRLockLatch(&pWrapper->latch);
-  int32_t refCount = atomic_sub_fetch_32(&pWrapper->refCount, 1);
-  taosRUnLockLatch(&pWrapper->latch);
-  dTrace("node:%s, is released, refCount:%d", pWrapper->name, refCount);
-}
-
-void dndSetMsgHandle(SMgmtWrapper *pWrapper, tmsg_t msgType, NodeMsgFp nodeMsgFp, int8_t vgId) {
-  pWrapper->msgFps[TMSG_INDEX(msgType)] = nodeMsgFp;
-  pWrapper->msgVgIds[TMSG_INDEX(msgType)] = vgId;
-}
-
-EDndStatus dndGetStatus(SDnode *pDnode) { return pDnode->status; }
-
-void dndSetStatus(SDnode *pDnode, EDndStatus status) {
-  if (pDnode->status != status) {
-    dDebug("dnode status set from %s to %s", dndStatStr(pDnode->status), dndStatStr(status));
-    pDnode->status = status;
-  }
-}
-
-void dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc) {
-  SStartupReq *pStartup = &pDnode->startup;
-  tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
-  tstrncpy(pStartup->desc, pDesc, TSDB_STEP_DESC_LEN);
-  pStartup->finished = 0;
-}
-
-static void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup) {
-  memcpy(pStartup, &pDnode->startup, sizeof(SStartupReq));
-  pStartup->finished = (dndGetStatus(pDnode) == DND_STAT_RUNNING);
-}
-
-void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
-  dDebug("startup req is received");
-  SStartupReq *pStartup = rpcMallocCont(sizeof(SStartupReq));
-  dndGetStartup(pDnode, pStartup);
-
-  dDebug("startup req is sent, step:%s desc:%s finished:%d", pStartup->name, pStartup->desc, pStartup->finished);
-  SRpcMsg rpcRsp = {
-      .handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupReq), .ahandle = pReq->ahandle};
-  rpcSendResponse(&rpcRsp);
-}

source/dnode/mgmt/mgmt_bnode/CMakeLists.txt

@@ -0,0 +1,9 @@
+aux_source_directory(src MGMT_BNODE)
+add_library(mgmt_bnode STATIC ${MGMT_BNODE})
+target_include_directories(
+    mgmt_bnode
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+target_link_libraries(
+    mgmt_bnode dnode_interface
+)

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 "dndInt.h"
+#include "dmInt.h"
 
 #include "bnode.h"
 
@@ -33,10 +33,6 @@ typedef struct SBnodeMgmt {
   SSingleWorker monitorWorker;
 } SBnodeMgmt;
 
-// bmInt.c
-int32_t bmOpen(SMgmtWrapper *pWrapper);
-int32_t bmDrop(SMgmtWrapper *pWrapper);
-
 // bmHandle.c
 void    bmInitMsgHandle(SMgmtWrapper *pWrapper);
 int32_t bmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);

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

@@ -53,13 +53,19 @@ int32_t bmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (createReq.dnodeId != pDnode->dnodeId) {
+  if (createReq.dnodeId != pDnode->data.dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
-    dError("failed to create bnode since %s, input:%d cur:%d", terrstr(), createReq.dnodeId, pDnode->dnodeId);
+    dError("failed to create bnode since %s, input:%d cur:%d", terrstr(), createReq.dnodeId, pDnode->data.dnodeId);
     return -1;
-  } else {
-    return bmOpen(pWrapper);
   }
+
+  bool deployed = true;
+  if (dmWriteFile(pWrapper, deployed) != 0) {
+    dError("failed to write bnode file since %s", terrstr());
+    return -1;
+  }
+
+  return 0;
 }
 
 int32_t bmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
@@ -72,15 +78,21 @@ int32_t bmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (dropReq.dnodeId != pDnode->dnodeId) {
+  if (dropReq.dnodeId != pDnode->data.dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to drop bnode since %s", terrstr());
     return -1;
-  } else {
-    return bmDrop(pWrapper);
   }
+
+  bool deployed = false;
+  if (dmWriteFile(pWrapper, deployed) != 0) {
+    dError("failed to write bnode file since %s", terrstr());
+    return -1;
+  }
+
+  return 0;
 }
 
 void bmInitMsgHandle(SMgmtWrapper *pWrapper) {
-  dndSetMsgHandle(pWrapper, TDMT_MON_BM_INFO, bmProcessMonitorMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_MON_BM_INFO, bmProcessMonitorMsg, DEFAULT_HANDLE);
 }

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

@@ -16,70 +16,25 @@
 #define _DEFAULT_SOURCE
 #include "bmInt.h"
 
-static int32_t bmRequire(SMgmtWrapper *pWrapper, bool *required) { return dndReadFile(pWrapper, required); }
+static int32_t bmRequire(SMgmtWrapper *pWrapper, bool *required) { return dmReadFile(pWrapper, required); }
 
 static void bmInitOption(SBnodeMgmt *pMgmt, SBnodeOpt *pOption) {
-  SMsgCb msgCb = dndCreateMsgcb(pMgmt->pWrapper);
+  SMsgCb msgCb = pMgmt->pDnode->data.msgCb;
+  msgCb.pWrapper = pMgmt->pWrapper;
   pOption->msgCb = msgCb;
 }
 
-static int32_t bmOpenImp(SBnodeMgmt *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());
-    return -1;
-  }
-
-  if (bmStartWorker(pMgmt) != 0) {
-    dError("failed to start bnode worker since %s", terrstr());
-    return -1;
-  }
-
-  bool deployed = true;
-  if (dndWriteFile(pMgmt->pWrapper, deployed) != 0) {
-    dError("failed to write bnode file since %s", terrstr());
-    return -1;
-  }
-
-  return 0;
-}
-
-static void bmCloseImp(SBnodeMgmt *pMgmt) {
-  if (pMgmt->pBnode != NULL) {
-    bmStopWorker(pMgmt);
-    bndClose(pMgmt->pBnode);
-    pMgmt->pBnode = NULL;
-  }
-}
-
-int32_t bmDrop(SMgmtWrapper *pWrapper) {
-  SBnodeMgmt *pMgmt = pWrapper->pMgmt;
-  if (pMgmt == NULL) return 0;
-
-  dInfo("bnode-mgmt start to drop");
-  bool deployed = false;
-  if (dndWriteFile(pWrapper, deployed) != 0) {
-    dError("failed to drop bnode since %s", terrstr());
-    return -1;
-  }
-
-  bmCloseImp(pMgmt);
-  taosRemoveDir(pMgmt->path);
-  pWrapper->pMgmt = NULL;
-  taosMemoryFree(pMgmt);
-  dInfo("bnode-mgmt is dropped");
-  return 0;
-}
-
 static void bmClose(SMgmtWrapper *pWrapper) {
   SBnodeMgmt *pMgmt = pWrapper->pMgmt;
   if (pMgmt == NULL) return;
 
   dInfo("bnode-mgmt start to cleanup");
-  bmCloseImp(pMgmt);
+  if (pMgmt->pBnode != NULL) {
+    bmStopWorker(pMgmt);
+    bndClose(pMgmt->pBnode);
+    pMgmt->pBnode = NULL;
+  }
+
   pWrapper->pMgmt = NULL;
   taosMemoryFree(pMgmt);
   dInfo("bnode-mgmt is cleaned up");
@@ -98,23 +53,30 @@ int32_t bmOpen(SMgmtWrapper *pWrapper) {
   pMgmt->pWrapper = pWrapper;
   pWrapper->pMgmt = pMgmt;
 
-  int32_t code = bmOpenImp(pMgmt);
+  SBnodeOpt option = {0};
-  if (code != 0) {
+  bmInitOption(pMgmt, &option);
-    dError("failed to init bnode-mgmt since %s", terrstr());
+  pMgmt->pBnode = bndOpen(pMgmt->path, &option);
+  if (pMgmt->pBnode == NULL) {
+    dError("failed to open bnode since %s", terrstr());
     bmClose(pWrapper);
-  } else {
+    return -1;
-    dInfo("bnode-mgmt is initialized");
   }
 
-  return code;
+  if (bmStartWorker(pMgmt) != 0) {
+    dError("failed to start bnode worker since %s", terrstr());
+    bmClose(pWrapper);
+    return -1;
+  }
+
+  return 0;
 }
 
 void bmSetMgmtFp(SMgmtWrapper *pWrapper) {
   SMgmtFp mgmtFp = {0};
   mgmtFp.openFp = bmOpen;
   mgmtFp.closeFp = bmClose;
-  mgmtFp.createMsgFp = bmProcessCreateReq;
+  mgmtFp.createFp = bmProcessCreateReq;
-  mgmtFp.dropMsgFp = bmProcessDropReq;
+  mgmtFp.dropFp = bmProcessDropReq;
   mgmtFp.requiredFp = bmRequire;
 
   bmInitMsgHandle(pWrapper);

source/dnode/mgmt/mgmt_mnode/CMakeLists.txt

@@ -0,0 +1,9 @@
+aux_source_directory(src MGMT_MNODE)
+add_library(mgmt_mnode STATIC ${MGMT_MNODE})
+target_include_directories(
+    mgmt_mnode
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+target_link_libraries(
+    mgmt_mnode dnode_interface
+)

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

@@ -16,7 +16,8 @@
 #ifndef _TD_DND_MNODE_INT_H_
 #define _TD_DND_MNODE_INT_H_
 
-#include "dndInt.h"
+#include "dmInt.h"
+
 #include "mnode.h"
 
 #ifdef __cplusplus
@@ -40,11 +41,9 @@ typedef struct SMnodeMgmt {
 
 // mmFile.c
 int32_t mmReadFile(SMnodeMgmt *pMgmt, bool *pDeployed);
-int32_t mmWriteFile(SMnodeMgmt *pMgmt, bool deployed);
+int32_t mmWriteFile(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq, bool deployed);
 
 // mmInt.c
-int32_t mmOpenFromMsg(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq);
-int32_t mmDrop(SMgmtWrapper *pWrapper);
 int32_t mmAlter(SMnodeMgmt *pMgmt, SDAlterMnodeReq *pReq);
 
 // mmHandle.c

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

@@ -28,7 +28,7 @@ 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);
+    // dDebug("file %s not exist", file);
     code = 0;
     goto PRASE_MNODE_OVER;
   }
@@ -105,11 +105,13 @@ PRASE_MNODE_OVER:
   return code;
 }
 
-int32_t mmWriteFile(SMnodeMgmt *pMgmt, bool deployed) {
+int32_t mmWriteFile(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq, bool deployed) {
-  char file[PATH_MAX];
+  char file[PATH_MAX] = {0};
-  snprintf(file, sizeof(file), "%s%smnode.json.bak", pMgmt->path, TD_DIRSEP);
+  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);
 
-  TdFilePtr pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  TdFilePtr pFile = taosOpenFile(file, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC);
   if (pFile == NULL) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     dError("failed to write %s since %s", file, terrstr());
@@ -121,19 +123,28 @@ int32_t mmWriteFile(SMnodeMgmt *pMgmt, bool deployed) {
   char   *content = taosMemoryCalloc(1, maxLen + 1);
   
   len += snprintf(content + len, maxLen - len, "{\n");
-  len += snprintf(content + len, maxLen - len, "  \"deployed\": %d,\n", deployed);
   len += snprintf(content + len, maxLen - len, "  \"mnodes\": [{\n");
-  for (int32_t i = 0; i < pMgmt->replica; ++i) {
+
+  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];
+      if (pReq != NULL) {
+        pReplica = &pReq->replicas[i];
+      }
       len += snprintf(content + len, maxLen - len, "    \"id\": %d,\n", pReplica->id);
       len += snprintf(content + len, maxLen - len, "    \"fqdn\": \"%s\",\n", pReplica->fqdn);
       len += snprintf(content + len, maxLen - len, "    \"port\": %u\n", pReplica->port);
-    if (i < pMgmt->replica - 1) {
+      if (i < replica - 1) {
         len += snprintf(content + len, maxLen - len, "  },{\n");
       } else {
-      len += snprintf(content + len, maxLen - len, "  }]\n");
+        len += snprintf(content + len, maxLen - len, "  }],\n");
       }
     }
+  }
+
+  len += snprintf(content + len, maxLen - len, "  \"deployed\": %d\n", deployed);
   len += snprintf(content + len, maxLen - len, "}\n");
 
   taosWriteFile(pFile, content, len);
@@ -141,9 +152,6 @@ int32_t mmWriteFile(SMnodeMgmt *pMgmt, bool deployed) {
   taosCloseFile(&pFile);
   taosMemoryFree(content);
 
-  char realfile[PATH_MAX];
-  snprintf(realfile, sizeof(realfile), "%s%smnode.json", pMgmt->path, TD_DIRSEP);
-
   if (taosRenameFile(file, realfile) != 0) {
     terrno = TAOS_SYSTEM_ERROR(errno);
     dError("failed to rename %s since %s", file, terrstr());

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

@@ -0,0 +1,209 @@
+/*
+ * 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 "mmInt.h"
+
+void mmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonMmInfo *mmInfo) {
+  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
+  mndGetMonitorInfo(pMgmt->pMnode, &mmInfo->cluster, &mmInfo->vgroup, &mmInfo->grant);
+}
+
+int32_t mmProcessGetMonMmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
+  SMonMmInfo mmInfo = {0};
+  mmGetMonitorInfo(pWrapper, &mmInfo);
+  dmGetMonitorSysInfo(&mmInfo.sys);
+  monGetLogs(&mmInfo.log);
+
+  int32_t rspLen = tSerializeSMonMmInfo(NULL, 0, &mmInfo);
+  if (rspLen < 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    return -1;
+  }
+
+  void *pRsp = rpcMallocCont(rspLen);
+  if (pRsp == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  tSerializeSMonMmInfo(pRsp, rspLen, &mmInfo);
+  pReq->pRsp = pRsp;
+  pReq->rspLen = rspLen;
+  tFreeSMonMmInfo(&mmInfo);
+  return 0;
+}
+
+int32_t mmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
+  SDnode  *pDnode = pWrapper->pDnode;
+  SRpcMsg *pReq = &pMsg->rpcMsg;
+
+  SDCreateMnodeReq createReq = {0};
+  if (tDeserializeSDCreateMnodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    return -1;
+  }
+
+  if (createReq.replica <= 1 || createReq.dnodeId != pDnode->data.dnodeId) {
+    terrno = TSDB_CODE_INVALID_OPTION;
+    dError("failed to create mnode since %s", terrstr());
+    return -1;
+  }
+
+  bool deployed = true;
+  if (mmWriteFile(pWrapper, &createReq, deployed) != 0) {
+    dError("failed to write mnode file since %s", terrstr());
+    return -1;
+  }
+
+  return 0;
+}
+
+int32_t mmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
+  SDnode  *pDnode = pWrapper->pDnode;
+  SRpcMsg *pReq = &pMsg->rpcMsg;
+
+  SDDropMnodeReq dropReq = {0};
+  if (tDeserializeSCreateDropMQSBNodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    return -1;
+  }
+
+  if (dropReq.dnodeId != pDnode->data.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) {
+    dError("failed to write mnode file since %s", terrstr());
+    return -1;
+  }
+
+  return 0;
+}
+
+int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  SDnode  *pDnode = pMgmt->pDnode;
+  SRpcMsg *pReq = &pMsg->rpcMsg;
+
+  SDAlterMnodeReq alterReq = {0};
+  if (tDeserializeSDCreateMnodeReq(pReq->pCont, pReq->contLen, &alterReq) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    return -1;
+  }
+
+  if (alterReq.dnodeId != pDnode->data.dnodeId) {
+    terrno = TSDB_CODE_INVALID_OPTION;
+    dError("failed to alter mnode since %s, dnodeId:%d input:%d", terrstr(), pDnode->data.dnodeId, alterReq.dnodeId);
+    return -1;
+  } else {
+    return mmAlter(pMgmt, &alterReq);
+  }
+}
+
+void mmInitMsgHandle(SMgmtWrapper *pWrapper) {
+  dmSetMsgHandle(pWrapper, TDMT_MON_MM_INFO, mmProcessMonitorMsg, DEFAULT_HANDLE);
+
+  // 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_ALTER_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_DND_DROP_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_DND_SYNC_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_DND_COMPACT_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_DND_CONFIG_DNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+
+  // 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_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_SYNC_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_GET_SUB_EP, mmProcessReadMsg, 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);
+
+  // Requests handled by VNODE
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CONN_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_REB_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CANCEL_CONN_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  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);
+}

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

@@ -18,9 +18,9 @@
 #include "wal.h"
 
 static bool mmDeployRequired(SDnode *pDnode) {
-  if (pDnode->dnodeId > 0) return false;
+  if (pDnode->data.dnodeId > 0) return false;
-  if (pDnode->clusterId > 0) return false;
+  if (pDnode->data.clusterId > 0) return false;
-  if (strcmp(pDnode->localEp, pDnode->firstEp) != 0) return false;
+  if (strcmp(pDnode->data.localEp, pDnode->data.firstEp) != 0) return false;
   return true;
 }
 
@@ -39,7 +39,8 @@ static int32_t mmRequire(SMgmtWrapper *pWrapper, bool *required) {
 }
 
 static void mmInitOption(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {
-  SMsgCb msgCb = dndCreateMsgcb(pMgmt->pWrapper);
+  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;
@@ -53,8 +54,8 @@ static void mmBuildOptionForDeploy(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {
   pOption->selfIndex = 0;
   SReplica *pReplica = &pOption->replicas[0];
   pReplica->id = 1;
-  pReplica->port = pMgmt->pDnode->serverPort;
+  pReplica->port = pMgmt->pDnode->data.serverPort;
-  tstrncpy(pReplica->fqdn, pMgmt->pDnode->localFqdn, TSDB_FQDN_LEN);
+  tstrncpy(pReplica->fqdn, pMgmt->pDnode->data.localFqdn, TSDB_FQDN_LEN);
   pOption->deploy = true;
 
   pMgmt->selfIndex = pOption->selfIndex;
@@ -80,7 +81,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->dnodeId) {
+    if (pReplica->id == pMgmt->pDnode->data.dnodeId) {
       pOption->selfIndex = i;
     }
   }
@@ -97,80 +98,22 @@ static int32_t mmBuildOptionFromReq(SMnodeMgmt *pMgmt, SMnodeOpt *pOption, SDCre
   return 0;
 }
 
-static int32_t mmOpenImp(SMnodeMgmt *pMgmt, SDCreateMnodeReq *pReq) {
-  SMnodeOpt option = {0};
-  if (pReq != NULL) {
-    if (mmBuildOptionFromReq(pMgmt, &option, pReq) != 0) {
-      return -1;
-    }
-  } else {
-    bool deployed = false;
-    if (mmReadFile(pMgmt, &deployed) != 0) {
-      dError("failed to read file since %s", terrstr());
-      return -1;
-    }
-
-    if (!deployed) {
-      dInfo("mnode start to deploy");
-      mmBuildOptionForDeploy(pMgmt, &option);
-    } else {
-      dInfo("mnode start to open");
-      mmBuildOptionForOpen(pMgmt, &option);
-    }
-  }
-
-  pMgmt->pMnode = mndOpen(pMgmt->path, &option);
-  if (pMgmt->pMnode == NULL) {
-    dError("failed to open mnode since %s", terrstr());
-    return -1;
-  }
-
-  if (mmStartWorker(pMgmt) != 0) {
-    dError("failed to start mnode worker since %s", terrstr());
-    return -1;
-  }
-
-  bool deployed = true;
-  if (mmWriteFile(pMgmt, deployed) != 0) {
-    dError("failed to write mnode file since %s", terrstr());
-    return -1;
-  }
-
-  return 0;
-}
-
-static void mmCloseImp(SMnodeMgmt *pMgmt) {
-  if (pMgmt->pMnode != NULL) {
-    mmStopWorker(pMgmt);
-    mndClose(pMgmt->pMnode);
-    pMgmt->pMnode = NULL;
-  }
-}
-
 int32_t mmAlter(SMnodeMgmt *pMgmt, SDAlterMnodeReq *pReq) {
   SMnodeOpt option = {0};
   if (mmBuildOptionFromReq(pMgmt, &option, pReq) != 0) {
     return -1;
   }
-  return mndAlter(pMgmt->pMnode, &option);
-}
 
-int32_t mmDrop(SMgmtWrapper *pWrapper) {
+  if (mndAlter(pMgmt->pMnode, &option) != 0) {
-  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
+    return -1;
-  if (pMgmt == NULL) return 0;
+  }
-
+
-  dInfo("mnode-mgmt start to drop");
+  bool deployed = true;
-  bool deployed = false;
+  if (mmWriteFile(pMgmt->pWrapper, pReq, deployed) != 0) {
-  if (mmWriteFile(pMgmt, deployed) != 0) {
+    dError("failed to write mnode file since %s", terrstr());
-    dError("failed to drop mnode since %s", terrstr());
     return -1;
   }
 
-  mmCloseImp(pMgmt);
-  taosRemoveDir(pMgmt->path);
-  pWrapper->pMgmt = NULL;
-  taosMemoryFree(pMgmt);
-  dInfo("mnode-mgmt is dropped");
   return 0;
 }
 
@@ -179,13 +122,18 @@ static void mmClose(SMgmtWrapper *pWrapper) {
   if (pMgmt == NULL) return;
 
   dInfo("mnode-mgmt start to cleanup");
-  mmCloseImp(pMgmt);
+  if (pMgmt->pMnode != NULL) {
+    mmStopWorker(pMgmt);
+    mndClose(pMgmt->pMnode);
+    pMgmt->pMnode = NULL;
+  }
+
   pWrapper->pMgmt = NULL;
   taosMemoryFree(pMgmt);
   dInfo("mnode-mgmt is cleaned up");
 }
 
-int32_t mmOpenFromMsg(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq) {
+static int32_t mmOpen(SMgmtWrapper *pWrapper) {
   dInfo("mnode-mgmt start to init");
   if (walInit() != 0) {
     dError("failed to init wal since %s", terrstr());
@@ -203,32 +151,72 @@ int32_t mmOpenFromMsg(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq) {
   pMgmt->pWrapper = pWrapper;
   pWrapper->pMgmt = pMgmt;
 
-  int32_t code = mmOpenImp(pMgmt, pReq);
+  bool deployed = false;
-  if (code != 0) {
+  if (mmReadFile(pMgmt, &deployed) != 0) {
-    dError("failed to init mnode-mgmt since %s", terrstr());
+    dError("failed to read file since %s", terrstr());
     mmClose(pWrapper);
+    return -1;
+  }
+
+  SMnodeOpt option = {0};
+  if (!deployed) {
+    dInfo("mnode start to deploy");
+    if (pWrapper->procType == DND_PROC_CHILD) {
+      pWrapper->pDnode->data.dnodeId = 1;
+    }
+    mmBuildOptionForDeploy(pMgmt, &option);
   } else {
+    dInfo("mnode start to open");
+    mmBuildOptionForOpen(pMgmt, &option);
+  }
+
+  pMgmt->pMnode = mndOpen(pMgmt->path, &option);
+  if (pMgmt->pMnode == NULL) {
+    dError("failed to open mnode since %s", terrstr());
+    mmClose(pWrapper);
+    return -1;
+  }
+
+  if (mmStartWorker(pMgmt) != 0) {
+    dError("failed to start mnode worker since %s", terrstr());
+    mmClose(pWrapper);
+    return -1;
+  }
+
+  if (!deployed) {
+    deployed = true;
+    if (mmWriteFile(pWrapper, NULL, deployed) != 0) {
+      dError("failed to write mnode file since %s", terrstr());
+      return -1;
+    }
+  }
+
   dInfo("mnode-mgmt is initialized");
+  return 0;
 }
 
-  return code;
-}
-
-static int32_t mmOpen(SMgmtWrapper *pWrapper) { return mmOpenFromMsg(pWrapper, NULL); }
-
 static int32_t mmStart(SMgmtWrapper *pWrapper) {
   dDebug("mnode-mgmt start to run");
   SMnodeMgmt *pMgmt = pWrapper->pMgmt;
   return mndStart(pMgmt->pMnode);
 }
 
+static void mmStop(SMgmtWrapper *pWrapper) {
+  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.createMsgFp = mmProcessCreateReq;
+  mgmtFp.stopFp = mmStop;
-  mgmtFp.dropMsgFp = mmProcessDropReq;
+  mgmtFp.createFp = mmProcessCreateReq;
+  mgmtFp.dropFp = mmProcessDropReq;
   mgmtFp.requiredFp = mmRequire;
 
   mmInitMsgHandle(pWrapper);

source/dnode/mgmt/mgmt_qnode/CMakeLists.txt

@@ -0,0 +1,9 @@
+aux_source_directory(src MGMT_QNODE)
+add_library(mgmt_qnode STATIC ${MGMT_QNODE})
+target_include_directories(
+    mgmt_qnode
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+target_link_libraries(
+    mgmt_qnode dnode_interface
+)

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

@@ -16,7 +16,8 @@
 #ifndef _TD_DND_QNODE_INT_H_
 #define _TD_DND_QNODE_INT_H_
 
-#include "dndInt.h"
+#include "dmInt.h"
+
 #include "qnode.h"
 
 #ifdef __cplusplus
@@ -33,10 +34,6 @@ typedef struct SQnodeMgmt {
   SSingleWorker monitorWorker;
 } SQnodeMgmt;
 
-// qmInt.c
-int32_t qmOpen(SMgmtWrapper *pWrapper);
-int32_t qmDrop(SMgmtWrapper *pWrapper);
-
 // qmHandle.c
 void    qmInitMsgHandle(SMgmtWrapper *pWrapper);
 int32_t qmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);

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

@@ -53,13 +53,19 @@ int32_t qmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (createReq.dnodeId != pDnode->dnodeId) {
+  if (createReq.dnodeId != pDnode->data.dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to create qnode since %s", terrstr());
     return -1;
-  } else {
-    return qmOpen(pWrapper);
   }
+
+  bool deployed = true;
+  if (dmWriteFile(pWrapper, deployed) != 0) {
+    dError("failed to write qnode file since %s", terrstr());
+    return -1;
+  }
+
+  return 0;
 }
 
 int32_t qmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
@@ -72,27 +78,32 @@ int32_t qmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
     return -1;
   }
 
-  if (dropReq.dnodeId != pDnode->dnodeId) {
+  if (dropReq.dnodeId != pDnode->data.dnodeId) {
     terrno = TSDB_CODE_INVALID_OPTION;
     dError("failed to drop qnode since %s", terrstr());
     return -1;
-  } else {
-    return qmDrop(pWrapper);
   }
+
+  bool deployed = false;
+  if (dmWriteFile(pWrapper, deployed) != 0) {
+    dError("failed to write qnode file since %s", terrstr());
+    return -1;
+  }
+
+  return 0;
 }
 
 void qmInitMsgHandle(SMgmtWrapper *pWrapper) {
-  dndSetMsgHandle(pWrapper, TDMT_MON_QM_INFO, qmProcessMonitorMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_MON_QM_INFO, qmProcessMonitorMsg, DEFAULT_HANDLE);
 
   // Requests handled by VNODE
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY, qmProcessQueryMsg, QNODE_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY, qmProcessQueryMsg, QNODE_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, qmProcessQueryMsg, QNODE_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, qmProcessQueryMsg, QNODE_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH, qmProcessFetchMsg, QNODE_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH, qmProcessFetchMsg, QNODE_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, qmProcessFetchMsg, QNODE_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, qmProcessFetchMsg, QNODE_HANDLE);
 
-  dndSetMsgHandle(pWrapper, TDMT_VND_RES_READY, qmProcessFetchMsg, QNODE_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_RES_READY, qmProcessFetchMsg, QNODE_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_VND_TASKS_STATUS, qmProcessFetchMsg, QNODE_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TASKS_STATUS, qmProcessFetchMsg, QNODE_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_VND_CANCEL_TASK, qmProcessFetchMsg, QNODE_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CANCEL_TASK, qmProcessFetchMsg, QNODE_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, qmProcessFetchMsg, QNODE_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, qmProcessFetchMsg, QNODE_HANDLE);
-  dndSetMsgHandle(pWrapper, TDMT_VND_SHOW_TABLES, qmProcessFetchMsg, QNODE_HANDLE);
 }

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

@@ -16,79 +16,34 @@
 #define _DEFAULT_SOURCE
 #include "qmInt.h"
 
-static int32_t qmRequire(SMgmtWrapper *pWrapper, bool *required) { return dndReadFile(pWrapper, required); }
+static int32_t qmRequire(SMgmtWrapper *pWrapper, bool *required) { return dmReadFile(pWrapper, required); }
 
 static void qmInitOption(SQnodeMgmt *pMgmt, SQnodeOpt *pOption) {
-  SMsgCb msgCb = dndCreateMsgcb(pMgmt->pWrapper);
+  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 qmOpenImp(SQnodeMgmt *pMgmt) {
-  SQnodeOpt option = {0};
-  qmInitOption(pMgmt, &option);
-
-  pMgmt->pQnode = qndOpen(&option);
-  if (pMgmt->pQnode == NULL) {
-    dError("failed to open qnode since %s", terrstr());
-    return -1;
-  }
-
-  if (qmStartWorker(pMgmt) != 0) {
-    dError("failed to start qnode worker since %s", terrstr());
-    return -1;
-  }
-
-  bool deployed = true;
-  if (dndWriteFile(pMgmt->pWrapper, deployed) != 0) {
-    dError("failed to write qnode file since %s", terrstr());
-    return -1;
-  }
-
-  return 0;
-}
-
-static void qmCloseImp(SQnodeMgmt *pMgmt) {
-  if (pMgmt->pQnode != NULL) {
-    qmStopWorker(pMgmt);
-    qndClose(pMgmt->pQnode);
-    pMgmt->pQnode = NULL;
-  }
-}
-
-int32_t qmDrop(SMgmtWrapper *pWrapper) {
-  SQnodeMgmt *pMgmt = pWrapper->pMgmt;
-  if (pMgmt == NULL) return 0;
-
-  dInfo("qnode-mgmt start to drop");
-  bool deployed = false;
-  if (dndWriteFile(pWrapper, deployed) != 0) {
-    dError("failed to drop qnode since %s", terrstr());
-    return -1;
-  }
-
-  qmCloseImp(pMgmt);
-  taosRemoveDir(pMgmt->path);
-  pWrapper->pMgmt = NULL;
-  taosMemoryFree(pMgmt);
-  dInfo("qnode-mgmt is dropped");
-  return 0;
-}
-
 static void qmClose(SMgmtWrapper *pWrapper) {
   SQnodeMgmt *pMgmt = pWrapper->pMgmt;
   if (pMgmt == NULL) return;
 
   dInfo("qnode-mgmt start to cleanup");
-  qmCloseImp(pMgmt);
+  if (pMgmt->pQnode != NULL) {
+    qmStopWorker(pMgmt);
+    qndClose(pMgmt->pQnode);
+    pMgmt->pQnode = NULL;
+  }
+
   pWrapper->pMgmt = NULL;
   taosMemoryFree(pMgmt);
   dInfo("qnode-mgmt is cleaned up");
 }
 
-int32_t qmOpen(SMgmtWrapper *pWrapper) {
+static int32_t qmOpen(SMgmtWrapper *pWrapper) {
   dInfo("qnode-mgmt start to init");
   SQnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SQnodeMgmt));
   if (pMgmt == NULL) {
@@ -101,23 +56,31 @@ int32_t qmOpen(SMgmtWrapper *pWrapper) {
   pMgmt->pWrapper = pWrapper;
   pWrapper->pMgmt = pMgmt;
 
-  int32_t code = qmOpenImp(pMgmt);
+  SQnodeOpt option = {0};
-  if (code != 0) {
+  qmInitOption(pMgmt, &option);
-    dError("failed to init qnode-mgmt since %s", terrstr());
+  pMgmt->pQnode = qndOpen(&option);
+  if (pMgmt->pQnode == NULL) {
+    dError("failed to open qnode since %s", terrstr());
     qmClose(pWrapper);
-  } else {
+    return -1;
-    dInfo("qnode-mgmt is initialized");
   }
 
-  return code;
+  if (qmStartWorker(pMgmt) != 0) {
+    dError("failed to start qnode worker since %s", terrstr());
+    qmClose(pWrapper);
+    return -1;
+  }
+
+  dInfo("qnode-mgmt is initialized");
+  return 0;
 }
 
 void qmSetMgmtFp(SMgmtWrapper *pWrapper) {
   SMgmtFp mgmtFp = {0};
   mgmtFp.openFp = qmOpen;
   mgmtFp.closeFp = qmClose;
-  mgmtFp.createMsgFp = qmProcessCreateReq;
+  mgmtFp.createFp = qmProcessCreateReq;
-  mgmtFp.dropMsgFp = qmProcessDropReq;
+  mgmtFp.dropFp = qmProcessDropReq;
   mgmtFp.requiredFp = qmRequire;
 
   qmInitMsgHandle(pWrapper);

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

@@ -32,7 +32,7 @@ static void qmProcessMonitorQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   SRpcMsg *pRpc = &pMsg->rpcMsg;
   int32_t  code = -1;
 
-  if (pMsg->rpcMsg.msgType == TDMT_MON_SM_INFO) {
+  if (pMsg->rpcMsg.msgType == TDMT_MON_QM_INFO) {
     code = qmProcessGetMonQmInfoReq(pMgmt->pWrapper, pMsg);
   } else {
     terrno = TSDB_CODE_MSG_NOT_PROCESSED;

source/dnode/mgmt/mgmt_snode/CMakeLists.txt

@@ -0,0 +1,9 @@
+aux_source_directory(src MGMT_SNODE)
+add_library(mgmt_snode STATIC ${MGMT_SNODE})
+target_include_directories(
+    mgmt_snode
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+target_link_libraries(
+    mgmt_snode dnode_interface
+)

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

@@ -16,7 +16,8 @@
 #ifndef _TD_DND_SNODE_INT_H_
 #define _TD_DND_SNODE_INT_H_
 
-#include "dndInt.h"
+#include "dmInt.h"
+
 #include "snode.h"
 
 #ifdef __cplusplus
@@ -35,10 +36,6 @@ typedef struct SSnodeMgmt {
   SSingleWorker monitorWorker;
 } SSnodeMgmt;
 
-// smInt.c
-int32_t smOpen(SMgmtWrapper *pWrapper);
-int32_t smDrop(SMgmtWrapper *pWrapper);
-
 // smHandle.c
 void    smInitMsgHandle(SMgmtWrapper *pWrapper);
 int32_t smProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);