[td-225] merge develop branch

documentation/webdocs/markdowndocs/Super Table-ch.md

@@ -53,10 +53,11 @@ STable从属于库，一个STable只属于一个库，但一个库可以有一
 
     说明：
 
-    1. TAGS列总长度不能超过512 bytes；
+    1. TAGS列总长度不能超过64k bytes；
     2. TAGS列的数据类型不能是timestamp；
     3. TAGS列名不能与其他列名相同;
     4. TAGS列名不能为预留关键字. 
+    5. TAGS总数的上限是128.
 
 - 显示已创建的超级表
 
@@ -114,7 +115,7 @@ INSERT INTO <tb1_name> USING <stb1_name> TAGS (<tag1_value1>, ...) VALUES (<fiel
     ALTER TABLE <stable_name> ADD TAG <new_tag_name> <TYPE>
     ```
 
-    为STable增加一个新的标签，并指定新标签的类型。标签总数不能超过6个。
+    为STable增加一个新的标签，并指定新标签的类型。标签总数不能超过128个。
 
 - 删除标签
 
@@ -202,7 +203,7 @@ INSERT INTO therm4 VALUES ('2018-01-01 00:00:00.000', 23);
 
 ###3:按标签聚合查询
 
-查询位于北京(beijing)和天津(tianjing)两个地区的温度传感器采样值的数量count(*)、平均温度avg(degree)、最高温度max(degree)、最低温度min(degree)，并将结果按所处地域(location)和传感器类型(type)进行聚合。
+查询位于北京(beijing)和天津(tianjin)两个地区的温度传感器采样值的数量count(*)、平均温度avg(degree)、最高温度max(degree)、最低温度min(degree)，并将结果按所处地域(location)和传感器类型(type)进行聚合。
 
 ```mysql
 SELECT COUNT(*), AVG(degree), MAX(degree), MIN(degree)

documentation/webdocs/markdowndocs/Super Table.md

@@ -22,11 +22,11 @@ New keyword "tags" is introduced, where tag_name is the tag name, and tag_type i
 
 Note：
 
-1. The bytes of all tags together shall be less than 512 
+1. The bytes of all tags together shall be less than 64k 
 2. Tag's data type can not be time stamp
 3. Tag name shall be different from the field name
 4. Tag name shall not be the same as system keywords
-5. Maximum number of tags is 6 
+5. Maximum number of tags is 128 
 
 For example:
 
@@ -168,7 +168,7 @@ You can add, delete and change the tags for a STable, and you can change the tag
 ALTER TABLE <stable_name> ADD TAG <new_tag_name> <TYPE>
 ```
 
-It adds a new tag to the STable with a data type. The maximum number of tags is 6. 
+It adds a new tag to the STable with a data type. The maximum number of tags is 128. 
 
 ### Drop a Tag
 

documentation/webdocs/markdowndocs/TAOS SQL-ch.md

@@ -63,7 +63,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 | 3    |  BIGINT   | 8      | 长整型，范围 [-2^63+1,   2^63-1], -2^63用于NULL                                 |
 | 4    |   FLOAT   | 4      | 浮点型，有效位数6-7，范围 [-3.4E38, 3.4E38]                  |
 | 5    |  DOUBLE   | 8      | 双精度浮点型，有效位数15-16，范围 [-1.7E308,   1.7E308]      |
-| 6    |  BINARY   | 自定义 | 用于记录字符串，最长不能超过504 bytes。binary仅支持字符串输入，字符串两端使用单引号引用，否则英文全部自动转化为小写。使用时须指定大小，如binary(20)定义了最长为20个字符的字符串，每个字符占1byte的存储空间。如果用户字符串超出20字节，将被自动截断。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示， 即 **\’**。 |
+| 6    |  BINARY   | 自定义 | 用于记录字符串，理论上，最长可以有65526字节，但由于每行数据最多64K字节，实际上限一般小于理论值。 binary仅支持字符串输入，字符串两端使用单引号引用，否则英文全部自动转化为小写。使用时须指定大小，如binary(20)定义了最长为20个字符的字符串，每个字符占1byte的存储空间。如果用户字符串超出20字节，将被自动截断。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示， 即 **\’**。 |
 | 7    | SMALLINT  | 2      | 短整型， 范围 [-32767, 32767], -32768用于NULL                                |
 | 8    |  TINYINT  | 1      | 单字节整型，范围 [-127, 127], -128用于NULL                                |
 | 9    |   BOOL    | 1      | 布尔型，{true,   false}                                      |
@@ -106,7 +106,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     ```mysql
     CREATE TABLE [IF NOT EXISTS] tb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...])
     ```
-    说明：1）表的第一个字段必须是TIMESTAMP，并且系统自动将其设为主键；2）表的每行长度不能超过4096字节；3）使用数据类型binary或nchar，需指定其最长的字节数，如binary(20)，表示20字节。
+    说明：1）表的第一个字段必须是TIMESTAMP，并且系统自动将其设为主键；2）表的每行长度不能超过64K字节；3）使用数据类型binary或nchar，需指定其最长的字节数，如binary(20)，表示20字节。
 
 
 - **删除数据表**
@@ -402,7 +402,7 @@ count(tbname) |
     SELECT * FROM tb1 WHERE ts >= NOW - 1h
     ```
 
-- 查询表tb1从2018-06-01 08:00:00.000 到2018-06-02 08:00:00.000时间范围，并且clo3的字符串是'nny'结尾的记录，结果按照时间戳降序
+- 查询表tb1从2018-06-01 08:00:00.000 到2018-06-02 08:00:00.000时间范围，并且col3的字符串是'nny'结尾的记录，结果按照时间戳降序
 
     ```mysql
     SELECT * FROM tb1 WHERE ts > '2018-06-01 08:00:00.000' AND ts <= '2018-06-02 08:00:00.000' AND col3 LIKE '%nny' ORDER BY ts DESC

documentation/webdocs/markdowndocs/TAOS SQL.md

@@ -39,7 +39,7 @@ The full list of data types is listed below.  For string types of data, we will
 | 6    |   DOUBLE    |    8    | A standard nullable double float type with 15-16 significant digits and a range of [-1.7E308, 1.7E308]​ |
 | 7    |    BOOL     |    1    | A nullable boolean type, [**`true`**, **`false`**]           |
 | 8    |  TIMESTAMP  |    8    | A nullable timestamp type with the same usage as the primary column timestamp |
-| 9    | BINARY(*M*) |   *M*   | A nullable string type whose length is *M*, any exceeded chars will be automatically truncated. This type of string only supports ASCii encoded chars. |
+| 9    | BINARY(*M*) |   *M*   | A nullable string type whose length is *M*, any exceeded chars will be automatically truncated, the maximum length of *M* is 65526, but as maximum row size is 64K bytes, the actual upper limit will generally less than 65526. This type of string only supports ASCii encoded chars. |
 | 10   | NCHAR(*M*)  | 4 * *M* | A nullable string type whose length is *M*, any exceeded chars will be truncated. The **`NCHAR`** type supports Unicode encoded chars. |
 
 All the keywords in a SQL statement are case-insensitive, but strings values are case-sensitive and must be quoted by a pair of `'` or `"`. To quote a `'` or a `"` , you can use the escape character `\`.
@@ -86,7 +86,7 @@ All the keywords in a SQL statement are case-insensitive, but strings values are
     
     1) The first column must be a `timestamp`, and the system will set it as the primary key.
     
-    2) The record size is limited to 4096 bytes
+    2) The record size is limited to 64k bytes
     
     3) For `binary` or `nchar` data types, the length must be specified. For example, binary(20) means a binary data type with 20 bytes.
 

documentation/webdocs/markdowndocs/connector-ch.md

@@ -2,7 +2,7 @@
 
 TDengine提供了丰富的应用程序开发接口，其中包括C/C++、JAVA、Python、RESTful、Go等，便于用户快速开发应用。
 
-注意：所以执行 SQL 语句的 API，例如 C/C++ Connector 中的 `tao_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。
+注意：所有执行 SQL 语句的 API，例如 C/C++ Connector 中的 `tao_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。
 
 ## C/C++ Connector
 

importSampleData/app/main.go

@@ -18,7 +18,7 @@ import (
 	"sync"
 	"time"
 
-	_ "github.com/taosdata/TDengine/src/connector/go/src/taosSql"
+	_ "github.com/taosdata/TDengine/src/connector/go/taosSql"
 )
 
 const (
@@ -634,6 +634,7 @@ func insertData(threadIndex, start, end int, wg  *sync.WaitGroup, successRows []
 					if  appendRows == batch {
 						// executebatch
 						insertSql := buffers.String()
+						connection.Exec("use " + db)
 						affectedRows := executeBatchInsert(insertSql, connection)
 
 						successRows[threadIndex] += affectedRows
@@ -658,6 +659,7 @@ func insertData(threadIndex, start, end int, wg  *sync.WaitGroup, successRows []
 		if  appendRows > 0 {
 			// executebatch
 			insertSql := buffers.String()
+			connection.Exec("use " + db)
 			affectedRows := executeBatchInsert(insertSql, connection)
 			
 			successRows[threadIndex] += affectedRows

packaging/cfg/taos.cfg

@@ -155,7 +155,7 @@
 # maxVnodeConnections   10000
 
 # mnode take into account while balance, for cluster version only 
-# mgmtEqualVnodeNum     4
+# mnodeEqualVnodeNum     4
 
 # number of seconds allowed for a dnode to be offline, for cluster version only 
 # offlineThreshold      864000

src/client/inc/tsclient.h

@@ -284,8 +284,8 @@ typedef struct {
 typedef struct STscObj {
   void *             signature;
   void *             pTimer;
-  char               mgmtIp[TSDB_USER_LEN];
+  char               mnodeIp[TSDB_USER_LEN];
-  uint16_t           mgmtPort;
+  uint16_t           mnodePort;
   char               user[TSDB_USER_LEN];
   char               pass[TSDB_KEY_LEN];
   char               acctId[TSDB_DB_NAME_LEN];

src/client/src/tscFunctionImpl.c

@@ -478,7 +478,7 @@ int32_t count_load_data_info(SQLFunctionCtx *pCtx, TSKEY start, TSKEY end, int32
   if (colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
     return BLK_DATA_NO_NEEDED;
   } else {
-    return BLK_DATA_FILEDS_NEEDED;
+    return BLK_DATA_STATIS_NEEDED;
   }
 }
 
@@ -690,7 +690,7 @@ static void sum_func_second_merge(SQLFunctionCtx *pCtx) {
 }
 
 static int32_t precal_req_load_info(SQLFunctionCtx *pCtx, TSKEY start, TSKEY end, int32_t colId) {
-  return BLK_DATA_FILEDS_NEEDED;
+  return BLK_DATA_STATIS_NEEDED;
 }
 
 static int32_t data_req_load_info(SQLFunctionCtx *pCtx, TSKEY start, TSKEY end, int32_t colId) {

src/client/src/tscParseInsert.c

@@ -1361,7 +1361,7 @@ int tsParseSql(SSqlObj *pSql, bool initialParse) {
   /*
    * the pRes->code may be modified or released by another thread in tscTableMetaCallBack function,
    * so do NOT use pRes->code to determine if the getTableMeta/getMetricMeta function
-   * invokes new threads to get data from mgmt node or simply retrieves data from cache.
+   * invokes new threads to get data from mnode or simply retrieves data from cache.
    *
    * do NOT assign return code to pRes->code for the same reason since it may be released by another thread
    * pRes->code = ret;

src/client/src/tscServer.c

@@ -60,10 +60,10 @@ static void tscSetDnodeIpList(SSqlObj* pSql, SCMVgroupInfo* pVgroupInfo) {
 
 void tscPrintMgmtIp() {
   if (tscMgmtIpSet.numOfIps <= 0) {
-    tscError("invalid mgmt IP list:%d", tscMgmtIpSet.numOfIps);
+    tscError("invalid mnode IP list:%d", tscMgmtIpSet.numOfIps);
   } else {
     for (int i = 0; i < tscMgmtIpSet.numOfIps; ++i) {
-      tscTrace("mgmt index:%d %s:%d", i, tscMgmtIpSet.fqdn[i], tscMgmtIpSet.port[i]);
+      tscTrace("mnode index:%d %s:%d", i, tscMgmtIpSet.fqdn[i], tscMgmtIpSet.port[i]);
     }
   }
 }
@@ -78,7 +78,7 @@ void tscSetMgmtIpList(SRpcIpSet *pIpList) {
 
 void tscUpdateIpSet(void *ahandle, SRpcIpSet *pIpSet) {
   tscMgmtIpSet = *pIpSet;
-  tscTrace("mgmt IP list is changed for ufp is called, numOfIps:%d inUse:%d", tscMgmtIpSet.numOfIps, tscMgmtIpSet.inUse);
+  tscTrace("mnode IP list is changed for ufp is called, numOfIps:%d inUse:%d", tscMgmtIpSet.numOfIps, tscMgmtIpSet.inUse);
   for (int32_t i = 0; i < tscMgmtIpSet.numOfIps; ++i) {
     tscTrace("index:%d fqdn:%s port:%d", i, tscMgmtIpSet.fqdn[i], tscMgmtIpSet.port[i]);
   }
@@ -237,10 +237,8 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) {
     rpcMsg->code = TSDB_CODE_NETWORK_UNAVAIL;
   } else {
     STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
-    if (rpcMsg->code == TSDB_CODE_NOT_ACTIVE_TABLE || rpcMsg->code == TSDB_CODE_INVALID_TABLE_ID ||
+    if (rpcMsg->code == TSDB_CODE_INVALID_TABLE_ID || rpcMsg->code == TSDB_CODE_INVALID_VGROUP_ID || 
-        rpcMsg->code == TSDB_CODE_INVALID_VNODE_ID || rpcMsg->code == TSDB_CODE_NOT_ACTIVE_VNODE ||
+        rpcMsg->code == TSDB_CODE_NETWORK_UNAVAIL) {
-        rpcMsg->code == TSDB_CODE_NETWORK_UNAVAIL || rpcMsg->code == TSDB_CODE_NOT_ACTIVE_TABLE ||
-        rpcMsg->code == TSDB_CODE_TABLE_ID_MISMATCH) {
       /*
        * not_active_table: 1. the virtual node may fail to create table, since the procedure of create table is asynchronized,
        *                   the virtual node may have not create table till now, so try again by using the new metermeta.

src/client/src/tscSql.c

@@ -88,7 +88,7 @@ STscObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con
 
   strncpy(pObj->user, user, TSDB_USER_LEN);
   taosEncryptPass((uint8_t *)pass, strlen(pass), pObj->pass);
-  pObj->mgmtPort = port ? port : tsDnodeShellPort;
+  pObj->mnodePort = port ? port : tsDnodeShellPort;
 
   if (db) {
     int32_t len = strlen(db);
@@ -596,9 +596,9 @@ void taos_free_result(TAOS_RES *res) {
   if ((pCmd->command == TSDB_SQL_SELECT ||
        pCmd->command == TSDB_SQL_SHOW ||
        pCmd->command == TSDB_SQL_RETRIEVE ||
-       pCmd->command == TSDB_SQL_FETCH) &&
+       pCmd->command == TSDB_SQL_FETCH) && pRes->code == TSDB_CODE_SUCCESS &&
-       (pRes->code != TSDB_CODE_QUERY_CANCELLED && ((pCmd->command < TSDB_SQL_LOCAL && pRes->completed == false) ||
+       ((pCmd->command < TSDB_SQL_LOCAL && pRes->completed == false) ||
-       (pRes->code == TSDB_CODE_SUCCESS && pCmd->command == TSDB_SQL_SELECT && pSql->pStream == NULL && pTableMetaInfo->pTableMeta != NULL)))) {
+       (pCmd->command == TSDB_SQL_SELECT && pSql->pStream == NULL && pTableMetaInfo->pTableMeta != NULL))) {
     pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
 
     tscTrace("%p send msg to free qhandle in vnode, code:%d, numOfRows:%d, command:%s", pSql, pRes->code, pRes->numOfRows,

src/client/src/tscSubquery.c

@@ -1764,6 +1764,11 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
       break;
     }
   
+    /*
+     * assign the callback function to fetchFp to make sure that the error process function can restore
+     * the callback function (multiVnodeInsertMerge) correctly.
+     */
+    pNew->fetchFp = pNew->fp;
     pSql->pSubs[i] = pNew;
     pNew->fetchFp = pNew->fp;
     

src/client/src/tscSystem.c

@@ -57,9 +57,9 @@ int32_t tscInitRpc(const char *user, const char *secret, void** pDnodeConn) {
     memset(&rpcInit, 0, sizeof(rpcInit));
     rpcInit.localPort = 0;
     rpcInit.label = "TSC";
-    rpcInit.numOfThreads = tscNumOfThreads;
+    rpcInit.numOfThreads = 1;  // every DB connection has only one thread
     rpcInit.cfp = tscProcessMsgFromServer;
-    rpcInit.sessions = tsMaxVnodeConnections;
+    rpcInit.sessions = tsMaxConnections;
     rpcInit.connType = TAOS_CONN_CLIENT;
     rpcInit.user = (char*)user;
     rpcInit.idleTime = 2000;
@@ -116,12 +116,12 @@ void taos_init_imp() {
   }
 
   if (tscSetMgmtIpListFromCfg(tsFirst, tsSecond) < 0) {
-    tscError("failed to init mgmt IP list");
+    tscError("failed to init mnode IP list");
     return;
   } 
 
   tscInitMsgsFp();
-  int queueSize = tsMaxVnodeConnections + tsMaxMeterConnections + tsMaxMgmtConnections + tsMaxMgmtConnections;
+  int queueSize = tsMaxConnections*2;
 
   if (tscEmbedded == 0) {
     tscNumOfThreads = tsNumOfCores * tsNumOfThreadsPerCore / 2.0;
@@ -137,7 +137,7 @@ void taos_init_imp() {
     return;
   }
 
-  tscTmr = taosTmrInit(tsMaxMgmtConnections * 2, 200, 60000, "TSC");
+  tscTmr = taosTmrInit(tsMaxConnections * 2, 200, 60000, "TSC");
   if(0 == tscEmbedded){
     taosTmrReset(tscCheckDiskUsage, 10, NULL, tscTmr, &tscCheckDiskUsageTmr);      
   }

src/client/src/tscUtil.c

@@ -1850,8 +1850,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
   STableMetaInfo* pFinalInfo = NULL;
 
   if (pPrevSql == NULL) {
-    STableMeta* pTableMeta = taosCacheAcquireByName(tscCacheHandle, name);
+    STableMeta* pTableMeta = taosCacheAcquireByData(tscCacheHandle, pTableMetaInfo->pTableMeta);  // get by name may failed due to the cache cleanup
-    // todo handle error
     assert(pTableMeta != NULL);
     pFinalInfo = tscAddTableMetaInfo(pNewQueryInfo, name, pTableMeta, pTableMetaInfo->vgroupList, pTableMetaInfo->tagColList);
   } else {  // transfer the ownership of pTableMeta to the newly create sql object.

src/common/inc/tglobal.h

@@ -87,20 +87,18 @@ extern int16_t tsWAL;
 extern int32_t tsReplications;
 
 extern int16_t tsAffectedRowsMod;
-extern int32_t tsNumOfMPeers;
+extern int32_t tsNumOfMnodes;
 extern int32_t tsMaxShellConns;
 extern int32_t tsMaxTables;
 
 extern char tsDefaultDB[];
 extern char tsDefaultUser[];
 extern char tsDefaultPass[];
-extern int32_t tsMaxMeterConnections;
+extern int32_t tsMaxConnections;
-extern int32_t tsMaxVnodeConnections;
-extern int32_t tsMaxMgmtConnections;
 
 extern int32_t tsBalanceInterval;
 extern int32_t tsOfflineThreshold;
-extern int32_t tsMgmtEqualVnodeNum;
+extern int32_t tsMnodeEqualVnodeNum;
 
 extern int32_t tsEnableHttpModule;
 extern int32_t tsEnableMqttModule;

src/common/src/tglobal.c

@@ -105,19 +105,17 @@ int32_t tsReplications  = TSDB_DEFAULT_REPLICA_NUM;
  * 1: affected rows include those duplicate records
  */
 int16_t tsAffectedRowsMod = 0;
-int32_t tsNumOfMPeers = 3;
+int32_t tsNumOfMnodes = 3;
-int32_t tsMaxShellConns = 2000;
+int32_t tsMaxShellConns = 5000;
 
 char    tsDefaultDB[TSDB_DB_NAME_LEN] = {0};
 char    tsDefaultUser[64] = "root";
 char    tsDefaultPass[64] = "taosdata";
-int32_t tsMaxMeterConnections = 10000;
+int32_t tsMaxConnections = 50;
-int32_t tsMaxMgmtConnections = 2000;
-int32_t tsMaxVnodeConnections = 10000;
 
 int32_t tsBalanceInterval = 300;  // seconds
 int32_t tsOfflineThreshold = 86400*100;   // seconds 10days
-int32_t tsMgmtEqualVnodeNum = 4;
+int32_t tsMnodeEqualVnodeNum = 4;
 
 int32_t tsEnableHttpModule = 1;
 int32_t tsEnableMqttModule = 0;   // not finished yet, not started it by default
@@ -407,8 +405,8 @@ static void doInitGlobalConfig() {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
 
-  cfg.option = "numOfMPeers";
+  cfg.option = "numOfMnodes";
-  cfg.ptr = &tsNumOfMPeers;
+  cfg.ptr = &tsNumOfMnodes;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
   cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
   cfg.minValue = 1;
@@ -427,7 +425,7 @@ static void doInitGlobalConfig() {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
 
-  // 0-any; 1-mgmt; 2-dnode
+  // 0-any; 1-mnode; 2-vnode
   cfg.option = "alternativeRole";
   cfg.ptr = &tsAlternativeRole;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
@@ -680,7 +678,7 @@ static void doInitGlobalConfig() {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
 
-  cfg.option = "wallevel";
+  cfg.option = "walLevel";
   cfg.ptr = &tsWAL;
   cfg.valType = TAOS_CFG_VTYPE_INT16;
   cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
@@ -814,32 +812,12 @@ static void doInitGlobalConfig() {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
 
-  cfg.option = "maxMeterConnections";
+  cfg.option = "maxConnections";
-  cfg.ptr = &tsMaxMeterConnections;
+  cfg.ptr = &tsMaxConnections;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
   cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = 10;
+  cfg.minValue = 1;
-  cfg.maxValue = 50000000;
+  cfg.maxValue = 100;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
-
-  cfg.option = "maxMgmtConnections";
-  cfg.ptr = &tsMaxMgmtConnections;
-  cfg.valType = TAOS_CFG_VTYPE_INT32;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = 10;
-  cfg.maxValue = 50000000;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
-
-  cfg.option = "maxVnodeConnections";
-  cfg.ptr = &tsMaxVnodeConnections;
-  cfg.valType = TAOS_CFG_VTYPE_INT32;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = 10;
-  cfg.maxValue = 50000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
@@ -875,8 +853,8 @@ static void doInitGlobalConfig() {
   taosInitConfigOption(cfg);
 
   // module configs
-  cfg.option = "mgmtEqualVnodeNum";
+  cfg.option = "mnodeEqualVnodeNum";
-  cfg.ptr = &tsMgmtEqualVnodeNum;
+  cfg.ptr = &tsMnodeEqualVnodeNum;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
   cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
   cfg.minValue = 0;

src/cq/src/cqMain.c

@@ -15,17 +15,19 @@
 
 #define _DEFAULT_SOURCE
 
+#include <errno.h>
+#include <pthread.h>
 #include <stdlib.h>
 #include <string.h>
-#include <pthread.h>
+
-#include <errno.h>
+#include "taos.h"
 #include "taosdef.h"
 #include "taosmsg.h"
+#include "tcq.h"
+#include "tdataformat.h"
 #include "tglobal.h"
 #include "tlog.h"
 #include "twal.h"
-#include "tcq.h"
-#include "taos.h"
 
 #define cError(...) { if (cqDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR CQ  ", cqDebugFlag, __VA_ARGS__); }}
 #define cWarn(...)  { if (cqDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN CQ  ", cqDebugFlag, __VA_ARGS__); }}
@@ -49,8 +51,7 @@ typedef struct SCqObj {
   int            tid;      // table ID
   int            rowSize;  // bytes of a row
   char *         sqlStr;   // SQL string
-  int      columns;  // number of columns
+  STSchema *     pSchema;  // pointer to schema array
-  SSchema *pSchema;  // pointer to schema array
   void *         pStream;
   struct SCqObj *prev;
   struct SCqObj *next;
@@ -152,7 +153,7 @@ void cqStop(void *handle) {
   pthread_mutex_unlock(&pContext->mutex);
 }
 
-void *cqCreate(void *handle, int tid, char *sqlStr, SSchema *pSchema, int columns) {
+void *cqCreate(void *handle, int tid, char *sqlStr, STSchema *pSchema) {
   SCqContext *pContext = handle;
 
   SCqObj *pObj = calloc(sizeof(SCqObj), 1);
@@ -162,11 +163,7 @@ void *cqCreate(void *handle, int tid, char *sqlStr, SSchema *pSchema, int column
   pObj->sqlStr = malloc(strlen(sqlStr)+1);
   strcpy(pObj->sqlStr, sqlStr);
 
-  pObj->columns = columns;
+  pObj->pSchema = tdDupSchema(pSchema);
-
-  int size = sizeof(SSchema) * columns;
-  pObj->pSchema = malloc(size);
-  memcpy(pObj->pSchema, pSchema, size);
 
   cTrace("vgId:%d, id:%d CQ:%s is created", pContext->vgId, pObj->tid, pObj->sqlStr);
 

src/cq/test/cqtest.c

@@ -59,21 +59,16 @@ int main(int argc, char *argv[]) {
     exit(-1);
   }
 
-  SSchema schema[2];
+  STSchema *pSchema = tdNewSchema(2);
-  schema[0].type = TSDB_DATA_TYPE_TIMESTAMP;
+  tdSchemaAddCol(pSchema, TSDB_DATA_TYPE_TIMESTAMP, 0, 8);
-  strcpy(schema[0].name, "ts");
+  tdSchemaAddCol(pSchema, TSDB_DATA_TYPE_INT, 1, 4);
-  schema[0].colId = 0;
-  schema[0].bytes = 8;
-
-  schema[1].type = TSDB_DATA_TYPE_INT;
-  strcpy(schema[1].name, "avgspeed");
-  schema[1].colId = 1;
-  schema[1].bytes = 4;
 
   for (int sid =1; sid<10; ++sid) {
-    cqCreate(pCq, sid, "select avg(speed) from demo.t1 sliding(1s) interval(5s)", schema, 2);
+    cqCreate(pCq, sid, "select avg(speed) from demo.t1 sliding(1s) interval(5s)", pSchema);
   }
 
+  tdFreeSchema(pSchema);
+
   while (1) {
     char c = getchar();
     

src/dnode/inc/dnodeMPeer.h

@@ -13,17 +13,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MGMT_DCLIENT_H
+#ifndef TDENGINE_DNODE_MPEER_H
-#define TDENGINE_MGMT_DCLIENT_H
+#define TDENGINE_DNODE_MPEER_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-int32_t mgmtInitDClient();
+int32_t dnodeInitMnodePeer();
-void    mgmtCleanupDClient();
+void    dnodeCleanupMnodePeer();
-void    mgmtAddDClientRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg));
+int32_t dnodeAllocateMnodePqueue();
-void    mgmtSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg);
+void    dnodeFreeMnodePqueue();
+void    dnodeDispatchToMnodePeerQueue(SRpcMsg *pMsg);
 
 #ifdef __cplusplus
 }

src/dnode/inc/dnodeMRead.h

@@ -13,23 +13,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MGMT_USER_H
+#ifndef TDENGINE_DNODE_MREAD_H
-#define TDENGINE_MGMT_USER_H
+#define TDENGINE_DNODE_MREAD_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "mgmtDef.h"
 
-int32_t   mgmtInitUsers();
+int32_t dnodeInitMnodeRead();
-void      mgmtCleanUpUsers();
+void    dnodeCleanupMnodeRead();
-SUserObj *mgmtGetUser(char *name);
+int32_t dnodeAllocateMnodeRqueue();
-void *    mgmtGetNextUser(void *pIter, SUserObj **pUser);
+void    dnodeFreeMnodeRqueue();
-void      mgmtIncUserRef(SUserObj *pUser);
+void    dnodeDispatchToMnodeReadQueue(SRpcMsg *rpcMsg);
-void      mgmtDecUserRef(SUserObj *pUser);
-SUserObj *mgmtGetUserFromConn(void *pConn);
-int32_t   mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass);
-void      mgmtDropAllUsers(SAcctObj *pAcct);
 
 #ifdef __cplusplus
 }

src/dnode/inc/dnodeMWrite.h

@@ -0,0 +1,33 @@
+/*
+ * 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 TDENGINE_DNODE_MWRITE_H
+#define TDENGINE_DNODE_MWRITE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t dnodeInitMnodeWrite();
+void    dnodeCleanupMnodeWrite();
+int32_t dnodeAllocateMnodeWqueue();
+void    dnodeFreeMnodeWqueue();
+void    dnodeDispatchToMnodeWriteQueue(SRpcMsg *pMsg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/dnode/inc/dnodeMgmt.h

@@ -32,6 +32,10 @@ void*   dnodeGetVnodeWal(void *pVnode);
 void*   dnodeGetVnodeTsdb(void *pVnode);
 void    dnodeReleaseVnode(void *pVnode);
 
+void    dnodeSendRedirectMsg(SRpcMsg *rpcMsg, bool forShell);
+void    dnodeGetMnodeIpSetForPeer(void *ipSet);
+void    dnodeGetMnodeIpSetForShell(void *ipSet);
+
 #ifdef __cplusplus
 }
 #endif

src/dnode/inc/dnodePeer.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_DNODE_DNODE_H
+#ifndef TDENGINE_DNODE_PEER_H
-#define TDENGINE_DNODE_DNODE_H
+#define TDENGINE_DNODE_PEER_H
 
 #ifdef __cplusplus
 extern "C" {

src/dnode/inc/dnodeVRead.h

@@ -13,15 +13,15 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_DNODE_READ_H
+#ifndef TDENGINE_DNODE_VREAD_H
-#define TDENGINE_DNODE_READ_H
+#define TDENGINE_DNODE_VREAD_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-int32_t dnodeInitRead();
+int32_t dnodeInitVnodeRead();
-void    dnodeCleanupRead();
+void    dnodeCleanupVnodeRead();
 void    dnodeDispatchToVnodeReadQueue(SRpcMsg *pMsg);
 
 #ifdef __cplusplus

src/dnode/inc/dnodeVWrite.h

@@ -13,17 +13,16 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_DNODE_WRITE_H
+#ifndef TDENGINE_DNODE_VWRITE_H
-#define TDENGINE_DNODE_WRITE_H
+#define TDENGINE_DNODE_VWRITE_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-int32_t dnodeInitWrite();
+int32_t dnodeInitVnodeWrite();
-void    dnodeCleanupWrite();
+void    dnodeCleanupVnodeWrite();
 void    dnodeDispatchToVnodeWriteQueue(SRpcMsg *pMsg);
-void    dnodeSendWriteResponse(void *pVnode, void *param, int32_t code);
 
 #ifdef __cplusplus
 }

src/dnode/src/dnodeMPeer.c

@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "taoserror.h"
+#include "taosmsg.h"
+#include "tutil.h"
+#include "tqueue.h"
+#include "twal.h"
+#include "tglobal.h"
+#include "mnode.h"
+#include "dnode.h"
+#include "dnodeInt.h"
+#include "dnodeMgmt.h"
+#include "dnodeMWrite.h"
+
+typedef struct {
+  pthread_t thread;
+  int32_t   workerId;
+} SMPeerWorker;
+
+typedef struct {
+  int32_t       num;
+  SMPeerWorker *peerWorker;
+} SMPeerWorkerPool;
+
+static SMPeerWorkerPool tsMPeerPool;
+static taos_qset        tsMPeerQset;
+static taos_queue       tsMPeerQueue;
+
+static void *dnodeProcessMnodePeerQueue(void *param);
+
+int32_t dnodeInitMnodePeer() {
+  tsMPeerQset = taosOpenQset();
+  
+  tsMPeerPool.num = 1;
+  tsMPeerPool.peerWorker = (SMPeerWorker *)calloc(sizeof(SMPeerWorker), tsMPeerPool.num);
+
+  if (tsMPeerPool.peerWorker == NULL) return -1;
+  for (int32_t i = 0; i < tsMPeerPool.num; ++i) {
+    SMPeerWorker *pWorker = tsMPeerPool.peerWorker + i;
+    pWorker->workerId = i;
+  }
+
+  dPrint("dnode mpeer is opened");
+  return 0;
+}
+
+void dnodeCleanupMnodePeer() {
+  for (int32_t i = 0; i < tsMPeerPool.num; ++i) {
+    SMPeerWorker *pWorker = tsMPeerPool.peerWorker + i;
+    if (pWorker->thread) {
+      taosQsetThreadResume(tsMPeerQset);
+    }
+  }
+
+  for (int32_t i = 0; i < tsMPeerPool.num; ++i) {
+    SMPeerWorker *pWorker = tsMPeerPool.peerWorker + i;
+    if (pWorker->thread) {
+      pthread_join(pWorker->thread, NULL);
+    }
+  }
+
+  dPrint("dnode mpeer is closed");
+}
+
+int32_t dnodeAllocateMnodePqueue() {
+  tsMPeerQueue = taosOpenQueue();
+  if (tsMPeerQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY;
+
+  taosAddIntoQset(tsMPeerQset, tsMPeerQueue, NULL);
+
+  for (int32_t i = 0; i < tsMPeerPool.num; ++i) {
+    SMPeerWorker *pWorker = tsMPeerPool.peerWorker + i;
+    pWorker->workerId = i;
+
+    pthread_attr_t thAttr;
+    pthread_attr_init(&thAttr);
+    pthread_attr_setdetachstate(&thAttr, PTHREAD_CREATE_JOINABLE);
+
+    if (pthread_create(&pWorker->thread, &thAttr, dnodeProcessMnodePeerQueue, pWorker) != 0) {
+      dError("failed to create thread to process mpeer queue, reason:%s", strerror(errno));
+    }
+
+    pthread_attr_destroy(&thAttr);
+    dTrace("dnode mpeer worker:%d is launched, total:%d", pWorker->workerId, tsMPeerPool.num);
+  }
+
+  dTrace("dnode mpeer queue:%p is allocated", tsMPeerQueue);
+  return TSDB_CODE_SUCCESS;
+}
+
+void dnodeFreeMnodePqueue() {
+  taosCloseQueue(tsMPeerQueue);
+  tsMPeerQueue = NULL;
+}
+
+void dnodeDispatchToMnodePeerQueue(SRpcMsg *pMsg) {
+  if (!mnodeIsRunning() || tsMPeerQueue == NULL) {
+    dnodeSendRedirectMsg(pMsg, false);
+    return;
+  }
+
+  SMnodeMsg *pPeer = (SMnodeMsg *)taosAllocateQitem(sizeof(SMnodeMsg));
+  mnodeCreateMsg(pPeer, pMsg);
+  taosWriteQitem(tsMPeerQueue, TAOS_QTYPE_RPC, pPeer);
+}
+
+static void dnodeFreeMnodePeerMsg(SMnodeMsg *pPeer) {
+  mnodeCleanupMsg(pPeer);
+  taosFreeQitem(pPeer);
+}
+
+static void dnodeSendRpcMnodePeerRsp(SMnodeMsg *pPeer, int32_t code) {
+  if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
+
+  SRpcMsg rpcRsp = {
+    .handle  = pPeer->rpcMsg.handle,
+    .pCont   = pPeer->rpcRsp.rsp,
+    .contLen = pPeer->rpcRsp.len,
+    .code    = code,
+  };
+
+  rpcSendResponse(&rpcRsp);
+  dnodeFreeMnodePeerMsg(pPeer);
+}
+
+static void *dnodeProcessMnodePeerQueue(void *param) {
+  SMnodeMsg *pPeerMsg;
+  int32_t    type;
+  void *     unUsed;
+  
+  while (1) {
+    if (taosReadQitemFromQset(tsMPeerQset, &type, (void **)&pPeerMsg, &unUsed) == 0) {
+      dTrace("dnodeProcessMnodePeerQueue: got no message from qset, exiting...");
+      break;
+    }
+
+    dTrace("msg:%s will be processed in mpeer queue", taosMsg[pPeerMsg->rpcMsg.msgType]);    
+    int32_t code = mnodeProcessPeerReq(pPeerMsg);    
+    dnodeSendRpcMnodePeerRsp(pPeerMsg, code);    
+  }
+
+  return NULL;
+}

src/dnode/src/dnodeMRead.c

@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "taoserror.h"
+#include "taosmsg.h"
+#include "tutil.h"
+#include "tqueue.h"
+#include "twal.h"
+#include "tglobal.h"
+#include "mnode.h"
+#include "dnode.h"
+#include "dnodeInt.h"
+#include "dnodeMgmt.h"
+#include "dnodeMRead.h"
+
+typedef struct {
+  pthread_t thread;
+  int32_t   workerId;
+} SMReadWorker;
+
+typedef struct {
+  int32_t       num;
+  SMReadWorker *readWorker;
+} SMReadWorkerPool;
+
+static SMReadWorkerPool tsMReadPool;
+static taos_qset        tsMReadQset;
+static taos_queue       tsMReadQueue;
+
+static void *dnodeProcessMnodeReadQueue(void *param);
+
+int32_t dnodeInitMnodeRead() {
+  tsMReadQset = taosOpenQset();
+
+  tsMReadPool.num = tsNumOfCores * tsNumOfThreadsPerCore / 2;
+  tsMReadPool.num = MAX(2, tsMReadPool.num);
+  tsMReadPool.num = MIN(4, tsMReadPool.num);
+  tsMReadPool.readWorker = (SMReadWorker *)calloc(sizeof(SMReadWorker), tsMReadPool.num);
+
+  if (tsMReadPool.readWorker == NULL) return -1;
+  for (int32_t i = 0; i < tsMReadPool.num; ++i) {
+    SMReadWorker *pWorker = tsMReadPool.readWorker + i;
+    pWorker->workerId = i;
+  }
+
+  dPrint("dnode mread is opened");
+  return 0;
+}
+
+void dnodeCleanupMnodeRead() {
+  for (int32_t i = 0; i < tsMReadPool.num; ++i) {
+    SMReadWorker *pWorker = tsMReadPool.readWorker + i;
+    if (pWorker->thread) {
+      taosQsetThreadResume(tsMReadQset);
+    }
+  }
+
+  for (int32_t i = 0; i < tsMReadPool.num; ++i) {
+    SMReadWorker *pWorker = tsMReadPool.readWorker + i;
+    if (pWorker->thread) {
+      pthread_join(pWorker->thread, NULL);
+    }
+  }
+
+  taosCloseQset(tsMReadQset);
+  free(tsMReadPool.readWorker);
+
+  dPrint("dnode mread is closed");
+}
+
+int32_t dnodeAllocateMnodeRqueue() {
+  tsMReadQueue = taosOpenQueue();
+  if (tsMReadQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY;
+
+  taosAddIntoQset(tsMReadQset, tsMReadQueue, NULL);
+
+  for (int32_t i = 0; i < tsMReadPool.num; ++i) {
+    SMReadWorker *pWorker = tsMReadPool.readWorker + i;
+    pWorker->workerId = i;
+
+    pthread_attr_t thAttr;
+    pthread_attr_init(&thAttr);
+    pthread_attr_setdetachstate(&thAttr, PTHREAD_CREATE_JOINABLE);
+
+    if (pthread_create(&pWorker->thread, &thAttr, dnodeProcessMnodeReadQueue, pWorker) != 0) {
+      dError("failed to create thread to process mread queue, reason:%s", strerror(errno));
+    }
+
+    pthread_attr_destroy(&thAttr);
+    dTrace("dnode mread worker:%d is launched, total:%d", pWorker->workerId, tsMReadPool.num);
+  }
+
+  dTrace("dnode mread queue:%p is allocated", tsMReadQueue);
+  return TSDB_CODE_SUCCESS;
+}
+
+void dnodeFreeMnodeRqueue() {
+  taosCloseQueue(tsMReadQueue);
+  tsMReadQueue = NULL;
+}
+
+void dnodeDispatchToMnodeReadQueue(SRpcMsg *pMsg) {
+  if (!mnodeIsRunning() || tsMReadQueue == NULL) {
+    dnodeSendRedirectMsg(pMsg, true);
+    return;
+  }
+
+  SMnodeMsg *pRead = (SMnodeMsg *)taosAllocateQitem(sizeof(SMnodeMsg));
+  mnodeCreateMsg(pRead, pMsg);
+  taosWriteQitem(tsMReadQueue, TAOS_QTYPE_RPC, pRead);
+}
+
+static void dnodeFreeMnodeReadMsg(SMnodeMsg *pRead) {
+  mnodeCleanupMsg(pRead);
+  taosFreeQitem(pRead);
+}
+
+static void dnodeSendRpcMnodeReadRsp(SMnodeMsg *pRead, int32_t code) {
+  if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
+  if (code == TSDB_CODE_ACTION_NEED_REPROCESSED) {
+    // may be a auto create req, should put into write queue
+    dnodeReprocessMnodeWriteMsg(pRead);
+    return;
+  }
+
+  SRpcMsg rpcRsp = {
+    .handle  = pRead->rpcMsg.handle,
+    .pCont   = pRead->rpcRsp.rsp,
+    .contLen = pRead->rpcRsp.len,
+    .code    = code,
+  };
+
+  rpcSendResponse(&rpcRsp);
+  dnodeFreeMnodeReadMsg(pRead);
+}
+
+static void *dnodeProcessMnodeReadQueue(void *param) {
+  SMnodeMsg *pReadMsg;
+  int32_t    type;
+  void *     unUsed;
+  
+  while (1) {
+    if (taosReadQitemFromQset(tsMReadQset, &type, (void **)&pReadMsg, &unUsed) == 0) {
+      dTrace("dnodeProcessMnodeReadQueue: got no message from qset, exiting...");
+      break;
+    }
+
+    dTrace("%p, msg:%s will be processed in mread queue", pReadMsg->rpcMsg.ahandle, taosMsg[pReadMsg->rpcMsg.msgType]);    
+    int32_t code = mnodeProcessRead(pReadMsg);    
+    dnodeSendRpcMnodeReadRsp(pReadMsg, code);   
+  }
+
+  return NULL;
+}

src/dnode/src/dnodeMWrite.c

@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "taoserror.h"
+#include "taosmsg.h"
+#include "tutil.h"
+#include "ttimer.h"
+#include "tqueue.h"
+#include "twal.h"
+#include "tglobal.h"
+#include "mnode.h"
+#include "dnode.h"
+#include "dnodeInt.h"
+#include "dnodeMgmt.h"
+#include "dnodeMWrite.h"
+
+typedef struct {
+  pthread_t thread;
+  int32_t   workerId;
+} SMWriteWorker;
+
+typedef struct {
+  int32_t        num;
+  SMWriteWorker *writeWorker;
+} SMWriteWorkerPool;
+
+static SMWriteWorkerPool tsMWritePool;
+static taos_qset         tsMWriteQset;
+static taos_queue        tsMWriteQueue;
+extern void *            tsDnodeTmr;
+
+static void *dnodeProcessMnodeWriteQueue(void *param);
+
+int32_t dnodeInitMnodeWrite() {
+  tsMWriteQset = taosOpenQset();
+  
+  tsMWritePool.num = 1;
+  tsMWritePool.writeWorker = (SMWriteWorker *)calloc(sizeof(SMWriteWorker), tsMWritePool.num);
+
+  if (tsMWritePool.writeWorker == NULL) return -1;
+  for (int32_t i = 0; i < tsMWritePool.num; ++i) {
+    SMWriteWorker *pWorker = tsMWritePool.writeWorker + i;
+    pWorker->workerId = i;
+  }
+
+  dPrint("dnode mwrite is opened");
+  return 0;
+}
+
+void dnodeCleanupMnodeWrite() {
+  for (int32_t i = 0; i < tsMWritePool.num; ++i) {
+    SMWriteWorker *pWorker = tsMWritePool.writeWorker + i;
+    if (pWorker->thread) {
+      taosQsetThreadResume(tsMWriteQset);
+    }
+  }
+
+  for (int32_t i = 0; i < tsMWritePool.num; ++i) {
+    SMWriteWorker *pWorker = tsMWritePool.writeWorker + i;
+    if (pWorker->thread) {
+      pthread_join(pWorker->thread, NULL);
+    }
+  }
+
+  dPrint("dnode mwrite is closed");
+}
+
+int32_t dnodeAllocateMnodeWqueue() {
+  tsMWriteQueue = taosOpenQueue();
+  if (tsMWriteQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY;
+
+  taosAddIntoQset(tsMWriteQset, tsMWriteQueue, NULL);
+
+  for (int32_t i = 0; i < tsMWritePool.num; ++i) {
+    SMWriteWorker *pWorker = tsMWritePool.writeWorker + i;
+    pWorker->workerId = i;
+
+    pthread_attr_t thAttr;
+    pthread_attr_init(&thAttr);
+    pthread_attr_setdetachstate(&thAttr, PTHREAD_CREATE_JOINABLE);
+
+    if (pthread_create(&pWorker->thread, &thAttr, dnodeProcessMnodeWriteQueue, pWorker) != 0) {
+      dError("failed to create thread to process mwrite queue, reason:%s", strerror(errno));
+    }
+
+    pthread_attr_destroy(&thAttr);
+    dTrace("dnode mwrite worker:%d is launched, total:%d", pWorker->workerId, tsMWritePool.num);
+  }
+
+  dTrace("dnode mwrite queue:%p is allocated", tsMWriteQueue);
+  return TSDB_CODE_SUCCESS;
+}
+
+void dnodeFreeMnodeWqueue() {
+  taosCloseQueue(tsMWriteQueue);
+  tsMWriteQueue = NULL;
+}
+
+void dnodeDispatchToMnodeWriteQueue(SRpcMsg *pMsg) {
+  if (!mnodeIsRunning() || tsMWriteQueue == NULL) {
+    dnodeSendRedirectMsg(pMsg, true);
+    return;
+  }
+
+  SMnodeMsg *pWrite = (SMnodeMsg *)taosAllocateQitem(sizeof(SMnodeMsg));
+  mnodeCreateMsg(pWrite, pMsg);
+  taosWriteQitem(tsMWriteQueue, TAOS_QTYPE_RPC, pWrite);
+}
+
+static void dnodeFreeMnodeWriteMsg(SMnodeMsg *pWrite) {
+  mnodeCleanupMsg(pWrite);
+  taosFreeQitem(pWrite);
+}
+
+void dnodeSendRpcMnodeWriteRsp(void *pRaw, int32_t code) {
+  SMnodeMsg *pWrite = pRaw;
+  if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
+  if (code == TSDB_CODE_ACTION_NEED_REPROCESSED) {
+    dnodeReprocessMnodeWriteMsg(pWrite);
+    return;
+  }
+
+  SRpcMsg rpcRsp = {
+    .handle  = pWrite->rpcMsg.handle,
+    .pCont   = pWrite->rpcRsp.rsp,
+    .contLen = pWrite->rpcRsp.len,
+    .code    = code,
+  };
+
+  rpcSendResponse(&rpcRsp);
+  dnodeFreeMnodeWriteMsg(pWrite);
+}
+
+static void *dnodeProcessMnodeWriteQueue(void *param) {
+  SMnodeMsg *pWriteMsg;
+  int32_t    type;
+  void *     unUsed;
+  
+  while (1) {
+    if (taosReadQitemFromQset(tsMWriteQset, &type, (void **)&pWriteMsg, &unUsed) == 0) {
+      dTrace("dnodeProcessMnodeWriteQueue: got no message from qset, exiting...");
+      break;
+    }
+
+    dTrace("%p, msg:%s will be processed in mwrite queue", pWriteMsg->rpcMsg.ahandle, taosMsg[pWriteMsg->rpcMsg.msgType]);    
+    int32_t code = mnodeProcessWrite(pWriteMsg);    
+    dnodeSendRpcMnodeWriteRsp(pWriteMsg, code);
+  }
+
+  return NULL;
+}
+
+void dnodeReprocessMnodeWriteMsg(void *pMsg) {
+  SMnodeMsg *pWrite = pMsg;
+
+  if (!mnodeIsRunning() || tsMWriteQueue == NULL) {
+    dnodeSendRedirectMsg(pMsg, true);
+    dnodeFreeMnodeWriteMsg(pWrite);
+  } else {    
+    taosWriteQitem(tsMWriteQueue, TAOS_QTYPE_RPC, pWrite);
+  }
+}
+
+static void dnodeDoDelayReprocessMnodeWriteMsg(void *param, void *tmrId) {
+  dnodeReprocessMnodeWriteMsg(param);
+}
+
+void dnodeDelayReprocessMnodeWriteMsg(void *pMsg) {
+  SMnodeMsg *mnodeMsg = pMsg;
+  void *unUsed = NULL;
+  taosTmrReset(dnodeDoDelayReprocessMnodeWriteMsg, 300, mnodeMsg, tsDnodeTmr, &unUsed);
+}

src/dnode/src/dnodeMain.c

@@ -25,8 +25,11 @@
 #include "dnodePeer.h"
 #include "dnodeModule.h"
 #include "dnodeVRead.h"
-#include "dnodeShell.h"
 #include "dnodeVWrite.h"
+#include "dnodeMRead.h"
+#include "dnodeMWrite.h"
+#include "dnodeMPeer.h"
+#include "dnodeShell.h"
 
 static int32_t dnodeInitStorage();
 static void dnodeCleanupStorage();
@@ -65,8 +68,11 @@ int32_t dnodeInitSystem() {
   dPrint("start to initialize TDengine on %s", tsLocalEp);
 
   if (dnodeInitStorage() != 0) return -1;
-  if (dnodeInitRead() != 0) return -1;
+  if (dnodeInitVnodeRead() != 0) return -1;
-  if (dnodeInitWrite() != 0) return -1;
+  if (dnodeInitVnodeWrite() != 0) return -1;
+  if (dnodeInitMnodeRead() != 0) return -1;
+  if (dnodeInitMnodeWrite() != 0) return -1;
+  if (dnodeInitMnodePeer() != 0) return -1;
   if (dnodeInitClient() != 0) return -1;
   if (dnodeInitServer() != 0) return -1;
   if (dnodeInitMgmt() != 0) return -1;
@@ -89,8 +95,11 @@ void dnodeCleanUpSystem() {
     dnodeCleanupMgmt();
     dnodeCleanupServer();
     dnodeCleanupClient();
-    dnodeCleanupWrite();
+    dnodeCleanupMnodePeer();
-    dnodeCleanupRead();
+    dnodeCleanupMnodeWrite();
+    dnodeCleanupMnodeRead();
+    dnodeCleanupVnodeWrite();
+    dnodeCleanupVnodeRead();
     dnodeCleanupStorage();
     taos_cleanup();
     taosCloseLog();

src/dnode/src/dnodeMgmt.c

@@ -20,7 +20,6 @@
 #include "taosmsg.h"
 #include "ttime.h"
 #include "ttimer.h"
-#include "trpc.h"
 #include "tsdb.h"
 #include "twal.h"
 #include "tsync.h"
@@ -39,6 +38,15 @@
 
 #define MPEER_CONTENT_LEN 2000
 
+void *          tsDnodeTmr = NULL;
+static void *   tsStatusTimer = NULL;
+static uint32_t tsRebootTime;
+
+static SRpcIpSet     tsDMnodeIpSetForPeer = {0};
+static SRpcIpSet     tsDMnodeIpSetForShell = {0};
+static SDMMnodeInfos tsDMnodeInfos = {0};
+static SDMDnodeCfg   tsDnodeCfg = {0};
+
 static void   dnodeUpdateMnodeInfos(SDMMnodeInfos *pMnodes);
 static bool   dnodeReadMnodeInfos();
 static void   dnodeSaveMnodeInfos();
@@ -48,14 +56,6 @@ static void   dnodeSaveDnodeCfg();
 static void   dnodeProcessStatusRsp(SRpcMsg *pMsg);
 static void   dnodeSendStatusMsg(void *handle, void *tmrId);
 
-static void    *tsDnodeTmr = NULL;
-static void    *tsStatusTimer = NULL;
-static uint32_t tsRebootTime;
-
-static SRpcIpSet     tsMnodeIpSet  = {0};
-static SDMMnodeInfos tsMnodeInfos = {0};
-static SDMDnodeCfg   tsDnodeCfg = {0};
-
 static int32_t  dnodeOpenVnodes();
 static void     dnodeCloseVnodes();
 static int32_t  dnodeProcessCreateVnodeMsg(SRpcMsg *pMsg);
@@ -81,22 +81,40 @@ int32_t dnodeInitMgmt() {
   }
   
   if (!dnodeReadMnodeInfos()) {
-    memset(&tsMnodeIpSet, 0, sizeof(SRpcIpSet));
+    memset(&tsDMnodeIpSetForPeer, 0, sizeof(SRpcIpSet));
-    memset(&tsMnodeInfos, 0, sizeof(SDMMnodeInfos));
+    memset(&tsDMnodeIpSetForShell, 0, sizeof(SRpcIpSet));
-    tsMnodeIpSet.numOfIps = 1;
+    memset(&tsDMnodeInfos, 0, sizeof(SDMMnodeInfos));
-    taosGetFqdnPortFromEp(tsFirst, tsMnodeIpSet.fqdn[0], &tsMnodeIpSet.port[0]);
+
-    tsMnodeIpSet.port[0] += TSDB_PORT_DNODEDNODE;
+    tsDMnodeIpSetForPeer.numOfIps = 1;
+    taosGetFqdnPortFromEp(tsFirst, tsDMnodeIpSetForPeer.fqdn[0], &tsDMnodeIpSetForPeer.port[0]);
+    tsDMnodeIpSetForPeer.port[0] += TSDB_PORT_DNODEDNODE;
+    
+    tsDMnodeIpSetForShell.numOfIps = 1;
+    taosGetFqdnPortFromEp(tsFirst, tsDMnodeIpSetForShell.fqdn[0], &tsDMnodeIpSetForShell.port[0]);
+    tsDMnodeIpSetForShell.port[0] += TSDB_PORT_DNODESHELL;
+    
     if (strcmp(tsSecond, tsFirst) != 0) {
-      tsMnodeIpSet.numOfIps = 2;
+      tsDMnodeIpSetForPeer.numOfIps = 2;
-      taosGetFqdnPortFromEp(tsSecond, tsMnodeIpSet.fqdn[1], &tsMnodeIpSet.port[1]);
+      taosGetFqdnPortFromEp(tsSecond, tsDMnodeIpSetForPeer.fqdn[1], &tsDMnodeIpSetForPeer.port[1]);
-      tsMnodeIpSet.port[1] += TSDB_PORT_DNODEDNODE;
+      tsDMnodeIpSetForPeer.port[1] += TSDB_PORT_DNODEDNODE;
+
+      tsDMnodeIpSetForShell.numOfIps = 2;
+      taosGetFqdnPortFromEp(tsSecond, tsDMnodeIpSetForShell.fqdn[1], &tsDMnodeIpSetForShell.port[1]);
+      tsDMnodeIpSetForShell.port[1] += TSDB_PORT_DNODESHELL;
     }
   } else {
-    tsMnodeIpSet.inUse = tsMnodeInfos.inUse;
+    tsDMnodeIpSetForPeer.inUse = tsDMnodeInfos.inUse;
-    tsMnodeIpSet.numOfIps = tsMnodeInfos.nodeNum;
+    tsDMnodeIpSetForPeer.numOfIps = tsDMnodeInfos.nodeNum;
-    for (int32_t i = 0; i < tsMnodeInfos.nodeNum; i++) {
+    for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) {
-      taosGetFqdnPortFromEp(tsMnodeInfos.nodeInfos[i].nodeEp, tsMnodeIpSet.fqdn[i], &tsMnodeIpSet.port[i]);
+      taosGetFqdnPortFromEp(tsDMnodeInfos.nodeInfos[i].nodeEp, tsDMnodeIpSetForPeer.fqdn[i], &tsDMnodeIpSetForPeer.port[i]);
-      tsMnodeIpSet.port[i] += TSDB_PORT_DNODEDNODE;
+      tsDMnodeIpSetForPeer.port[i] += TSDB_PORT_DNODEDNODE;
+    }
+
+    tsDMnodeIpSetForShell.inUse = tsDMnodeInfos.inUse;
+    tsDMnodeIpSetForShell.numOfIps = tsDMnodeInfos.nodeNum;
+    for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) {
+      taosGetFqdnPortFromEp(tsDMnodeInfos.nodeInfos[i].nodeEp, tsDMnodeIpSetForShell.fqdn[i], &tsDMnodeIpSetForShell.port[i]);
+      tsDMnodeIpSetForShell.port[i] += TSDB_PORT_DNODESHELL;
     }
   }
 
@@ -265,23 +283,23 @@ static int32_t dnodeProcessConfigDnodeMsg(SRpcMsg *pMsg) {
   return taosCfgDynamicOptions(pCfg->config);
 }
 
-void dnodeUpdateIpSet(SRpcIpSet *pIpSet) {
+void dnodeUpdateMnodeIpSetForPeer(SRpcIpSet *pIpSet) {
-  dPrint("mnode IP list is changed, numOfIps:%d inUse:%d", pIpSet->numOfIps, pIpSet->inUse);
+  dPrint("mnode IP list for peer is changed, numOfIps:%d inUse:%d", pIpSet->numOfIps, pIpSet->inUse);
   for (int i = 0; i < pIpSet->numOfIps; ++i) {
     dPrint("mnode index:%d %s:%u", i, pIpSet->fqdn[i], pIpSet->port[i])
   }
 
-  tsMnodeIpSet = *pIpSet;
+  tsDMnodeIpSetForPeer = *pIpSet;
 }
 
-void dnodeGetMnodeDnodeIpSet(void *ipSetRaw) {
+void dnodeGetMnodeIpSetForPeer(void *ipSetRaw) {
   SRpcIpSet *ipSet = ipSetRaw;
-  ipSet->numOfIps = tsMnodeInfos.nodeNum;
+  *ipSet = tsDMnodeIpSetForPeer;
-  ipSet->inUse = tsMnodeInfos.inUse;
-  for (int32_t i = 0; i < tsMnodeInfos.nodeNum; ++i) {
-    taosGetFqdnPortFromEp(tsMnodeInfos.nodeInfos[i].nodeEp, ipSet->fqdn[i], &ipSet->port[i]);
-    ipSet->port[i] += TSDB_PORT_DNODEDNODE;
 }
+
+void dnodeGetMnodeIpSetForShell(void *ipSetRaw) {
+  SRpcIpSet *ipSet = ipSetRaw;
+  *ipSet = tsDMnodeIpSetForShell;
 }
 
 static void dnodeProcessStatusRsp(SRpcMsg *pMsg) {
@@ -321,22 +339,29 @@ static void dnodeProcessStatusRsp(SRpcMsg *pMsg) {
 }
 
 static void dnodeUpdateMnodeInfos(SDMMnodeInfos *pMnodes) {
-  bool mnodesChanged = (memcmp(&tsMnodeInfos, pMnodes, sizeof(SDMMnodeInfos)) != 0);
+  bool mnodesChanged = (memcmp(&tsDMnodeInfos, pMnodes, sizeof(SDMMnodeInfos)) != 0);
-  bool mnodesNotInit = (tsMnodeInfos.nodeNum == 0);
+  bool mnodesNotInit = (tsDMnodeInfos.nodeNum == 0);
   if (!(mnodesChanged || mnodesNotInit)) return;
 
-  memcpy(&tsMnodeInfos, pMnodes, sizeof(SDMMnodeInfos));
+  memcpy(&tsDMnodeInfos, pMnodes, sizeof(SDMMnodeInfos));
-
+  dPrint("mnode infos is changed, nodeNum:%d inUse:%d", tsDMnodeInfos.nodeNum, tsDMnodeInfos.inUse);
-  tsMnodeIpSet.inUse = tsMnodeInfos.inUse;
+  for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) {
-  tsMnodeIpSet.numOfIps = tsMnodeInfos.nodeNum;
+    dPrint("mnode index:%d, %s", tsDMnodeInfos.nodeInfos[i].nodeId, tsDMnodeInfos.nodeInfos[i].nodeEp);
-  for (int32_t i = 0; i < tsMnodeInfos.nodeNum; i++) {
-    taosGetFqdnPortFromEp(tsMnodeInfos.nodeInfos[i].nodeEp, tsMnodeIpSet.fqdn[i], &tsMnodeIpSet.port[i]);
-    tsMnodeIpSet.port[i] += TSDB_PORT_DNODEDNODE;
   }
 
-  dPrint("mnodes is changed, nodeNum:%d inUse:%d", tsMnodeInfos.nodeNum, tsMnodeInfos.inUse);
+  tsDMnodeIpSetForPeer.inUse = tsDMnodeInfos.inUse;
-  for (int32_t i = 0; i < tsMnodeInfos.nodeNum; i++) {
+  tsDMnodeIpSetForPeer.numOfIps = tsDMnodeInfos.nodeNum;
-    dPrint("mnode:%d, %s", tsMnodeInfos.nodeInfos[i].nodeId, tsMnodeInfos.nodeInfos[i].nodeEp);
+  for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) {
+    taosGetFqdnPortFromEp(tsDMnodeInfos.nodeInfos[i].nodeEp, tsDMnodeIpSetForPeer.fqdn[i], &tsDMnodeIpSetForPeer.port[i]);
+    tsDMnodeIpSetForPeer.port[i] += TSDB_PORT_DNODEDNODE;
+    dPrint("mnode index:%d, for peer %s %d", i, tsDMnodeIpSetForPeer.fqdn[i], tsDMnodeIpSetForPeer.port[i]);
+  }
+
+  tsDMnodeIpSetForShell.inUse = tsDMnodeInfos.inUse;
+  tsDMnodeIpSetForShell.numOfIps = tsDMnodeInfos.nodeNum;
+  for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) {
+    taosGetFqdnPortFromEp(tsDMnodeInfos.nodeInfos[i].nodeEp, tsDMnodeIpSetForShell.fqdn[i], &tsDMnodeIpSetForShell.port[i]);
+    dPrint("mnode index:%d, for shell %s %d", i, tsDMnodeIpSetForShell.fqdn[i], tsDMnodeIpSetForShell.port[i]);
   }
 
   dnodeSaveMnodeInfos();
@@ -344,11 +369,12 @@ static void dnodeUpdateMnodeInfos(SDMMnodeInfos *pMnodes) {
 }
 
 static bool dnodeReadMnodeInfos() {
-  char ipFile[TSDB_FILENAME_LEN] = {0};
+  char ipFile[TSDB_FILENAME_LEN*2] = {0};
-  sprintf(ipFile, "%s/mgmtIpList.json", tsDnodeDir);
+  
+  sprintf(ipFile, "%s/mnodeIpList.json", tsDnodeDir);
   FILE *fp = fopen(ipFile, "r");
   if (!fp) {
-    dTrace("failed to read mnode mgmtIpList.json, file not exist");
+    dTrace("failed to read mnodeIpList.json, file not exist");
     return false;
   }
 
@@ -359,39 +385,39 @@ static bool dnodeReadMnodeInfos() {
   if (len <= 0) {
     free(content);
     fclose(fp);
-    dError("failed to read mnode mgmtIpList.json, content is null");
+    dError("failed to read mnodeIpList.json, content is null");
     return false;
   }
 
   cJSON* root = cJSON_Parse(content);
   if (root == NULL) {
-    dError("failed to read mnode mgmtIpList.json, invalid json format");
+    dError("failed to read mnodeIpList.json, invalid json format");
     goto PARSE_OVER;
   }
 
   cJSON* inUse = cJSON_GetObjectItem(root, "inUse");
   if (!inUse || inUse->type != cJSON_Number) {
-    dError("failed to read mnode mgmtIpList.json, inUse not found");
+    dError("failed to read mnodeIpList.json, inUse not found");
     goto PARSE_OVER;
   }
-  tsMnodeInfos.inUse = inUse->valueint;
+  tsDMnodeInfos.inUse = inUse->valueint;
 
   cJSON* nodeNum = cJSON_GetObjectItem(root, "nodeNum");
   if (!nodeNum || nodeNum->type != cJSON_Number) {
-    dError("failed to read mnode mgmtIpList.json, nodeNum not found");
+    dError("failed to read mnodeIpList.json, nodeNum not found");
     goto PARSE_OVER;
   }
-  tsMnodeInfos.nodeNum = nodeNum->valueint;
+  tsDMnodeInfos.nodeNum = nodeNum->valueint;
 
   cJSON* nodeInfos = cJSON_GetObjectItem(root, "nodeInfos");
   if (!nodeInfos || nodeInfos->type != cJSON_Array) {
-    dError("failed to read mnode mgmtIpList.json, nodeInfos not found");
+    dError("failed to read mnodeIpList.json, nodeInfos not found");
     goto PARSE_OVER;
   }
 
   int size = cJSON_GetArraySize(nodeInfos);
-  if (size != tsMnodeInfos.nodeNum) {
+  if (size != tsDMnodeInfos.nodeNum) {
-    dError("failed to read mnode mgmtIpList.json, nodeInfos size not matched");
+    dError("failed to read mnodeIpList.json, nodeInfos size not matched");
     goto PARSE_OVER;
   }
 
@@ -401,24 +427,24 @@ static bool dnodeReadMnodeInfos() {
 
     cJSON *nodeId = cJSON_GetObjectItem(nodeInfo, "nodeId");
     if (!nodeId || nodeId->type != cJSON_Number) {
-      dError("failed to read mnode mgmtIpList.json, nodeId not found");
+      dError("failed to read mnodeIpList.json, nodeId not found");
       goto PARSE_OVER;
     }
-    tsMnodeInfos.nodeInfos[i].nodeId = nodeId->valueint;
+    tsDMnodeInfos.nodeInfos[i].nodeId = nodeId->valueint;
 
     cJSON *nodeEp = cJSON_GetObjectItem(nodeInfo, "nodeEp");
     if (!nodeEp || nodeEp->type != cJSON_String || nodeEp->valuestring == NULL) {
-      dError("failed to read mnode mgmtIpList.json, nodeName not found");
+      dError("failed to read mnodeIpList.json, nodeName not found");
       goto PARSE_OVER;
     }
-    strncpy(tsMnodeInfos.nodeInfos[i].nodeEp, nodeEp->valuestring, TSDB_EP_LEN);
+    strncpy(tsDMnodeInfos.nodeInfos[i].nodeEp, nodeEp->valuestring, TSDB_EP_LEN);
  }
 
   ret = true;
 
-  dPrint("read mnode iplist successed, numOfIps:%d inUse:%d", tsMnodeInfos.nodeNum, tsMnodeInfos.inUse);
+  dPrint("read mnode iplist successed, numOfIps:%d inUse:%d", tsDMnodeInfos.nodeNum, tsDMnodeInfos.inUse);
-  for (int32_t i = 0; i < tsMnodeInfos.nodeNum; i++) {
+  for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) {
-    dPrint("mnode:%d, %s", tsMnodeInfos.nodeInfos[i].nodeId, tsMnodeInfos.nodeInfos[i].nodeEp);
+    dPrint("mnode:%d, %s", tsDMnodeInfos.nodeInfos[i].nodeId, tsDMnodeInfos.nodeInfos[i].nodeEp);
   }
 
 PARSE_OVER:
@@ -430,7 +456,7 @@ PARSE_OVER:
 
 static void dnodeSaveMnodeInfos() {
   char ipFile[TSDB_FILENAME_LEN] = {0};
-  sprintf(ipFile, "%s/mgmtIpList.json", tsDnodeDir);
+  sprintf(ipFile, "%s/mnodeIpList.json", tsDnodeDir);
   FILE *fp = fopen(ipFile, "w");
   if (!fp) return;
 
@@ -439,13 +465,13 @@ static void dnodeSaveMnodeInfos() {
   char *  content = calloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
-  len += snprintf(content + len, maxLen - len, "  \"inUse\": %d,\n", tsMnodeInfos.inUse);
+  len += snprintf(content + len, maxLen - len, "  \"inUse\": %d,\n", tsDMnodeInfos.inUse);
-  len += snprintf(content + len, maxLen - len, "  \"nodeNum\": %d,\n", tsMnodeInfos.nodeNum);
+  len += snprintf(content + len, maxLen - len, "  \"nodeNum\": %d,\n", tsDMnodeInfos.nodeNum);
   len += snprintf(content + len, maxLen - len, "  \"nodeInfos\": [{\n");
-  for (int32_t i = 0; i < tsMnodeInfos.nodeNum; i++) {
+  for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) {
-    len += snprintf(content + len, maxLen - len, "    \"nodeId\": %d,\n", tsMnodeInfos.nodeInfos[i].nodeId);
+    len += snprintf(content + len, maxLen - len, "    \"nodeId\": %d,\n", tsDMnodeInfos.nodeInfos[i].nodeId);
-    len += snprintf(content + len, maxLen - len, "    \"nodeEp\": \"%s\"\n", tsMnodeInfos.nodeInfos[i].nodeEp);
+    len += snprintf(content + len, maxLen - len, "    \"nodeEp\": \"%s\"\n", tsDMnodeInfos.nodeInfos[i].nodeEp);
-    if (i < tsMnodeInfos.nodeNum -1) {
+    if (i < tsDMnodeInfos.nodeNum -1) {
       len += snprintf(content + len, maxLen - len, "  },{\n");  
     } else {
       len += snprintf(content + len, maxLen - len, "  }]\n");  
@@ -461,11 +487,11 @@ static void dnodeSaveMnodeInfos() {
 }
 
 char *dnodeGetMnodeMasterEp() {
-  return tsMnodeInfos.nodeInfos[tsMnodeIpSet.inUse].nodeEp;
+  return tsDMnodeInfos.nodeInfos[tsDMnodeIpSetForPeer.inUse].nodeEp;
 }
 
 void* dnodeGetMnodeInfos() {
-  return &tsMnodeInfos;
+  return &tsDMnodeInfos;
 }
 
 static void dnodeSendStatusMsg(void *handle, void *tmrId) {
@@ -508,11 +534,12 @@ static void dnodeSendStatusMsg(void *handle, void *tmrId) {
     .msgType = TSDB_MSG_TYPE_DM_STATUS
   };
 
-  dnodeSendMsgToDnode(&tsMnodeIpSet, &rpcMsg);
+  dnodeSendMsgToDnode(&tsDMnodeIpSetForPeer, &rpcMsg);
 }
 
 static bool dnodeReadDnodeCfg() {
-  char dnodeCfgFile[TSDB_FILENAME_LEN] = {0};
+  char dnodeCfgFile[TSDB_FILENAME_LEN*2] = {0};
+  
   sprintf(dnodeCfgFile, "%s/dnodeCfg.json", tsDnodeDir);
 
   FILE *fp = fopen(dnodeCfgFile, "r");
@@ -590,3 +617,24 @@ int32_t dnodeGetDnodeId() {
   return tsDnodeCfg.dnodeId;
 }
 
+void dnodeSendRedirectMsg(SRpcMsg *rpcMsg, bool forShell) {
+  SRpcConnInfo connInfo;
+  rpcGetConnInfo(rpcMsg->handle, &connInfo);
+
+  SRpcIpSet ipSet = {0};
+  if (forShell) {
+    dnodeGetMnodeIpSetForShell(&ipSet);
+  } else {
+    dnodeGetMnodeIpSetForPeer(&ipSet);
+  }
+  
+  dTrace("msg:%s will be redirected, dnodeIp:%s user:%s, numOfIps:%d inUse:%d", taosMsg[rpcMsg->msgType],
+         taosIpStr(connInfo.clientIp), connInfo.user, ipSet.numOfIps, ipSet.inUse);
+
+  for (int i = 0; i < ipSet.numOfIps; ++i) {
+    dTrace("mnode index:%d %s:%d", i, ipSet.fqdn[i], ipSet.port[i]);
+    ipSet.port[i] = htons(ipSet.port[i]);
+  }
+
+  rpcSendRedirectRsp(rpcMsg->handle, &ipSet);
+}

src/dnode/src/dnodeModule.c

@@ -17,7 +17,6 @@
 #include "os.h"
 #include "taosdef.h"
 #include "tglobal.h"
-#include "trpc.h"
 #include "mnode.h"
 #include "http.h"
 #include "mqtt.h"
@@ -46,12 +45,12 @@ static void dnodeUnSetModuleStatus(int32_t module) {
 }
 
 static void dnodeAllocModules() {
-  tsModule[TSDB_MOD_MGMT].enable       = false;
+  tsModule[TSDB_MOD_MNODE].enable       = false;
-  tsModule[TSDB_MOD_MGMT].name         = "mgmt";
+  tsModule[TSDB_MOD_MNODE].name         = "mnode";
-  tsModule[TSDB_MOD_MGMT].initFp       = mgmtInitSystem;
+  tsModule[TSDB_MOD_MNODE].initFp       = mnodeInitSystem;
-  tsModule[TSDB_MOD_MGMT].cleanUpFp    = mgmtCleanUpSystem;
+  tsModule[TSDB_MOD_MNODE].cleanUpFp    = mnodeCleanupSystem;
-  tsModule[TSDB_MOD_MGMT].startFp      = mgmtStartSystem;
+  tsModule[TSDB_MOD_MNODE].startFp      = mnodeStartSystem;
-  tsModule[TSDB_MOD_MGMT].stopFp       = mgmtStopSystem;
+  tsModule[TSDB_MOD_MNODE].stopFp       = mnodeStopSystem;
 
   tsModule[TSDB_MOD_HTTP].enable       = (tsEnableHttpModule == 1);
   tsModule[TSDB_MOD_HTTP].name         = "http";
@@ -94,8 +93,8 @@ void dnodeCleanUpModules() {
     }
   }
 
-  if (tsModule[TSDB_MOD_MGMT].enable && tsModule[TSDB_MOD_MGMT].cleanUpFp) {
+  if (tsModule[TSDB_MOD_MNODE].enable && tsModule[TSDB_MOD_MNODE].cleanUpFp) {
-    (*tsModule[TSDB_MOD_MGMT].cleanUpFp)();
+    (*tsModule[TSDB_MOD_MNODE].cleanUpFp)();
   }
 }
 
@@ -125,7 +124,7 @@ void dnodeStartModules() {
 }
 
 void dnodeProcessModuleStatus(uint32_t moduleStatus) {
-  for (int32_t module = TSDB_MOD_MGMT; module < TSDB_MOD_HTTP; ++module) {
+  for (int32_t module = TSDB_MOD_MNODE; module < TSDB_MOD_HTTP; ++module) {
     bool enableModule = moduleStatus & (1 << module);
     if (!tsModule[module].enable && enableModule) {
       dPrint("module status:%u is received, start %s module", tsModuleStatus, tsModule[module].name);

src/dnode/src/dnodePeer.c

@@ -22,14 +22,14 @@
 #include "os.h"
 #include "taosmsg.h"
 #include "tglobal.h"
-#include "trpc.h"
+#include "mnode.h"
 #include "dnode.h"
 #include "dnodeInt.h"
 #include "dnodeMgmt.h"
 #include "dnodeVWrite.h"
-#include "mnode.h"
+#include "dnodeMPeer.h"
 
-extern void dnodeUpdateIpSet(SRpcIpSet *pIpSet);
+extern void dnodeUpdateMnodeIpSetForPeer(SRpcIpSet *pIpSet);
 static void (*dnodeProcessReqMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *);
 static void dnodeProcessReqMsgFromDnode(SRpcMsg *pMsg, SRpcIpSet *);
 static void (*dnodeProcessRspMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *rpcMsg);
@@ -48,11 +48,11 @@ int32_t dnodeInitServer() {
   dnodeProcessReqMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM] = dnodeDispatchToDnodeMgmt;
   dnodeProcessReqMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE] = dnodeDispatchToDnodeMgmt;
 
-  dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = mgmtProcessReqMsgFromDnode;
+  dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = dnodeDispatchToMnodePeerQueue;
-  dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = mgmtProcessReqMsgFromDnode;
+  dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = dnodeDispatchToMnodePeerQueue;
-  dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_GRANT]        = mgmtProcessReqMsgFromDnode;
+  dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_AUTH]         = dnodeDispatchToMnodePeerQueue;
-  dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_STATUS]       = mgmtProcessReqMsgFromDnode;
+  dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_GRANT]        = dnodeDispatchToMnodePeerQueue;
-  dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_AUTH]         = mgmtProcessReqMsgFromDnode;
+  dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_STATUS]       = dnodeDispatchToMnodePeerQueue;
   
   SRpcInit rpcInit;
   memset(&rpcInit, 0, sizeof(rpcInit));
@@ -105,12 +105,10 @@ static void dnodeProcessReqMsgFromDnode(SRpcMsg *pMsg, SRpcIpSet *pIpSet) {
   if (dnodeProcessReqMsgFp[pMsg->msgType]) {
     (*dnodeProcessReqMsgFp[pMsg->msgType])(pMsg);
   } else {
+    dTrace("RPC %p, message:%s not processed", pMsg->handle, taosMsg[pMsg->msgType]);
     rspMsg.code = TSDB_CODE_MSG_NOT_PROCESSED;
     rpcSendResponse(&rspMsg);
     rpcFreeCont(pMsg->pCont);
-    dTrace("RPC %p, message:%s not processed", pMsg->handle, taosMsg[pMsg->msgType]); 
-    return;
-
   }
 }
 
@@ -146,12 +144,14 @@ void dnodeCleanupClient() {
 }
 
 static void dnodeProcessRspFromDnode(SRpcMsg *pMsg, SRpcIpSet *pIpSet) {
+  if (pMsg->msgType == TSDB_MSG_TYPE_DM_STATUS_RSP && pIpSet) {
+    dnodeUpdateMnodeIpSetForPeer(pIpSet);
+  }
 
   if (dnodeProcessRspMsgFp[pMsg->msgType]) {    
-    if (pMsg->msgType == TSDB_MSG_TYPE_DM_STATUS_RSP && pIpSet) dnodeUpdateIpSet(pIpSet);
     (*dnodeProcessRspMsgFp[pMsg->msgType])(pMsg);
   } else {
-    dError("RPC %p, msg:%s is not processed", pMsg->handle, taosMsg[pMsg->msgType]);
+    mnodeProcessPeerRsp(pMsg);
   }
 
   rpcFreeCont(pMsg->pCont);
@@ -167,6 +167,6 @@ void dnodeSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg) {
 
 void dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp) {
   SRpcIpSet ipSet = {0};
-  dnodeGetMnodeDnodeIpSet(&ipSet);
+  dnodeGetMnodeIpSetForPeer(&ipSet);
   rpcSendRecv(tsDnodeClientRpc, &ipSet, rpcMsg, rpcRsp);
 }

src/dnode/src/dnodeShell.c

@@ -18,7 +18,6 @@
 #include "taoserror.h"
 #include "taosdef.h"
 #include "taosmsg.h"
-#include "trpc.h"
 #include "tglobal.h"
 #include "http.h"
 #include "mnode.h"
@@ -26,6 +25,8 @@
 #include "dnodeInt.h"
 #include "dnodeVRead.h"
 #include "dnodeVWrite.h"
+#include "dnodeMRead.h"
+#include "dnodeMWrite.h"
 #include "dnodeShell.h"
 
 static void  (*dnodeProcessShellMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *);
@@ -35,43 +36,41 @@ static void  * tsDnodeShellRpc = NULL;
 static int32_t tsDnodeQueryReqNum  = 0;
 static int32_t tsDnodeSubmitReqNum = 0;
 
-void mgmtProcessMsgFromShell(SRpcMsg *rpcMsg);
-
 int32_t dnodeInitShell() {
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_SUBMIT] = dnodeDispatchToVnodeWriteQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_QUERY]  = dnodeDispatchToVnodeReadQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_FETCH]  = dnodeDispatchToVnodeReadQueue;
 
   // the following message shall be treated as mnode write
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CONNECT]     = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT]  = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT]  = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_ACCT]   = dnodeDispatchToMnodeWriteQueue; 
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_ACCT]   = mgmtProcessMsgFromShell; 
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = dnodeDispatchToMnodeWriteQueue; 
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = mgmtProcessMsgFromShell; 
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_USER]  = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_USER]  = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_USER]   = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_USER]   = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE]= dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE]= mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE]  = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE]  = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB]   = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB]   = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB]     = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB]     = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB]    = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB]    = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE]= dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE]= mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE]  = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE]  = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM]= dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM]= mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY]  = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY]  = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN]   = dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN]   = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE]= dnodeDispatchToMnodeWriteQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT]   = mgmtProcessMsgFromShell;
   
   // the following message shall be treated as mnode query 
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_USE_DB]      = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT]   = dnodeDispatchToMnodeReadQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLE_META]  = mgmtProcessMsgFromShell; 
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CONNECT]     = dnodeDispatchToMnodeReadQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_STABLE_VGROUP]= mgmtProcessMsgFromShell;   
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_USE_DB]      = dnodeDispatchToMnodeReadQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLE_META]  = dnodeDispatchToMnodeReadQueue; 
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_SHOW]        = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_STABLE_VGROUP]= dnodeDispatchToMnodeReadQueue;   
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE]    = mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = dnodeDispatchToMnodeReadQueue;
-  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE]= mgmtProcessMsgFromShell;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_SHOW]        = dnodeDispatchToMnodeReadQueue;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE]    = dnodeDispatchToMnodeReadQueue;
 
   int32_t numOfThreads = tsNumOfCores * tsNumOfThreadsPerCore;
   numOfThreads = (int32_t) ((1.0 - tsRatioOfQueryThreads) * numOfThreads / 2.0);
@@ -85,7 +84,7 @@ int32_t dnodeInitShell() {
   rpcInit.label        = "SHELL";
   rpcInit.numOfThreads = numOfThreads;
   rpcInit.cfp          = dnodeProcessMsgFromShell;
-  rpcInit.sessions     = TSDB_SESSIONS_PER_DNODE;
+  rpcInit.sessions     = tsMaxShellConns;
   rpcInit.connType     = TAOS_CONN_SERVER;
   rpcInit.idleTime     = tsShellActivityTimer * 1000;
   rpcInit.afp          = dnodeRetrieveUserAuthInfo;
@@ -139,7 +138,7 @@ void dnodeProcessMsgFromShell(SRpcMsg *pMsg, SRpcIpSet *pIpSet) {
 }
 
 static int dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
-  int code = mgmtRetriveAuth(user, spi, encrypt, secret, ckey);
+  int code = mnodeRetriveAuth(user, spi, encrypt, secret, ckey);
   if (code != TSDB_CODE_NOT_READY) return code;
 
   SDMAuthMsg *pMsg = rpcMallocCont(sizeof(SDMAuthMsg));
@@ -169,6 +168,44 @@ static int dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, char
   return rpcRsp.code;
 }
 
+void *dnodeSendCfgTableToRecv(int32_t vgId, int32_t sid) {
+  dTrace("vgId:%d, sid:%d send config table msg to mnode", vgId, sid);
+
+  int32_t contLen = sizeof(SDMConfigTableMsg);
+  SDMConfigTableMsg *pMsg = rpcMallocCont(contLen);
+
+  pMsg->dnodeId = htonl(dnodeGetDnodeId());
+  pMsg->vgId = htonl(vgId);
+  pMsg->sid = htonl(sid);
+
+  SRpcMsg rpcMsg = {0};
+  rpcMsg.pCont = pMsg;
+  rpcMsg.contLen = contLen;
+  rpcMsg.msgType = TSDB_MSG_TYPE_DM_CONFIG_TABLE;
+
+  SRpcMsg rpcRsp = {0};
+  dnodeSendMsgToDnodeRecv(&rpcMsg, &rpcRsp);
+  terrno = rpcRsp.code;
+  
+  if (rpcRsp.code != 0) {
+    rpcFreeCont(rpcRsp.pCont);
+    dError("vgId:%d, sid:%d failed to config table from mnode", vgId, sid);
+    return NULL;
+  } else {
+    dPrint("vgId:%d, sid:%d config table msg is received", vgId, sid);
+    
+    // delete this after debug finished
+    SMDCreateTableMsg *pTable = rpcRsp.pCont;
+    int16_t   numOfColumns = htons(pTable->numOfColumns);
+    int16_t   numOfTags = htons(pTable->numOfTags);
+    int32_t   sid = htonl(pTable->sid);
+    uint64_t  uid = htobe64(pTable->uid);
+    dPrint("table:%s, numOfColumns:%d numOfTags:%d sid:%d uid:%d", pTable->tableId, numOfColumns, numOfTags, sid, uid);
+
+    return rpcRsp.pCont;
+  }
+}
+
 SDnodeStatisInfo dnodeGetStatisInfo() {
   SDnodeStatisInfo info = {0};
   if (dnodeGetRunStatus() == TSDB_DNODE_RUN_STATUS_RUNING) {

src/dnode/src/dnodeSystem.c

@@ -29,7 +29,11 @@ int32_t main(int32_t argc, char *argv[]) {
   for (int32_t i = 1; i < argc; ++i) {
     if (strcmp(argv[i], "-c") == 0) {
       if (i < argc - 1) {        
-        strcpy(configDir, argv[++i]);
+        if (strlen(argv[++i]) > TSDB_FILENAME_LEN - 1) {
+          printf("config file path overflow");
+          exit(EXIT_FAILURE);
+        }
+        strcpy(configDir, argv[i]);
       } else {
         printf("'-c' requires a parameter, default:%s\n", configDir);
         exit(EXIT_FAILURE);

src/dnode/src/dnodeVRead.c

@@ -19,7 +19,6 @@
 #include "taosmsg.h"
 #include "tutil.h"
 #include "tqueue.h"
-#include "trpc.h"
 #include "twal.h"
 #include "tglobal.h"
 #include "dnodeInt.h"
@@ -53,7 +52,7 @@ static void  dnodeHandleIdleReadWorker(SReadWorker *);
 static SReadWorkerPool readPool;
 static taos_qset       readQset;
 
-int32_t dnodeInitRead() {
+int32_t dnodeInitVnodeRead() {
   readQset = taosOpenQset();
 
   readPool.min = 2;
@@ -71,7 +70,7 @@ int32_t dnodeInitRead() {
   return 0;
 }
 
-void dnodeCleanupRead() {
+void dnodeCleanupVnodeRead() {
   for (int i=0; i < readPool.max; ++i) {
     SReadWorker *pWorker = readPool.readWorker + i;
     if (pWorker->thread) {
@@ -142,7 +141,7 @@ void dnodeDispatchToVnodeReadQueue(SRpcMsg *pMsg) {
   }
 }
 
-void *dnodeAllocateRqueue(void *pVnode) {
+void *dnodeAllocateVnodeRqueue(void *pVnode) {
   taos_queue queue = taosOpenQueue();
   if (queue == NULL) return NULL;
 
@@ -172,7 +171,7 @@ void *dnodeAllocateRqueue(void *pVnode) {
   return queue;
 }
 
-void dnodeFreeRqueue(void *rqueue) {
+void dnodeFreeVnodeRqueue(void *rqueue) {
   taosCloseQueue(rqueue);
 
   // dynamically adjust the number of threads

src/dnode/src/dnodeVWrite.c

@@ -22,9 +22,9 @@
 #include "trpc.h"
 #include "tsdb.h"
 #include "twal.h"
+#include "tdataformat.h"
 #include "tglobal.h"
 #include "vnode.h"
-#include "tdataformat.h"
 #include "dnodeInt.h"
 #include "dnodeVWrite.h"
 #include "dnodeMgmt.h"
@@ -54,7 +54,7 @@ static void  dnodeHandleIdleWorker(SWriteWorker *pWorker);
 
 SWriteWorkerPool wWorkerPool;
 
-int32_t dnodeInitWrite() {
+int32_t dnodeInitVnodeWrite() {
   wWorkerPool.max = tsNumOfCores;
   wWorkerPool.writeWorker = (SWriteWorker *)calloc(sizeof(SWriteWorker), wWorkerPool.max);
   if (wWorkerPool.writeWorker == NULL) return -1;
@@ -67,7 +67,7 @@ int32_t dnodeInitWrite() {
   return 0;
 }
 
-void dnodeCleanupWrite() {
+void dnodeCleanupVnodeWrite() {
   for (int32_t i = 0; i < wWorkerPool.max; ++i) {
     SWriteWorker *pWorker =  wWorkerPool.writeWorker + i;
     if (pWorker->thread) {
@@ -122,14 +122,17 @@ void dnodeDispatchToVnodeWriteQueue(SRpcMsg *pMsg) {
   }
 }
 
-void *dnodeAllocateWqueue(void *pVnode) {
+void *dnodeAllocateVnodeWqueue(void *pVnode) {
   SWriteWorker *pWorker = wWorkerPool.writeWorker + wWorkerPool.nextId;
   void *queue = taosOpenQueue();
   if (queue == NULL) return NULL;
 
   if (pWorker->qset == NULL) {
     pWorker->qset = taosOpenQset();
-    if (pWorker->qset == NULL) return NULL;
+    if (pWorker->qset == NULL) {
+      taosCloseQueue(queue);
+      return NULL;
+    }
 
     taosAddIntoQset(pWorker->qset, queue, pVnode);
     pWorker->qall = taosAllocateQall();
@@ -157,13 +160,13 @@ void *dnodeAllocateWqueue(void *pVnode) {
   return queue;
 }
 
-void dnodeFreeWqueue(void *wqueue) {
+void dnodeFreeVnodeWqueue(void *wqueue) {
   taosCloseQueue(wqueue);
 
   // dynamically adjust the number of threads
 }
 
-void dnodeSendRpcWriteRsp(void *pVnode, void *param, int32_t code) {
+void dnodeSendRpcVnodeWriteRsp(void *pVnode, void *param, int32_t code) {
   SWriteMsg *pWrite = (SWriteMsg *)param;
 
   if (code > 0) return;
@@ -223,7 +226,7 @@ static void *dnodeProcessWriteQueue(void *param) {
       taosGetQitem(pWorker->qall, &type, &item);
       if (type == TAOS_QTYPE_RPC) {
         pWrite = (SWriteMsg *)item;
-        dnodeSendRpcWriteRsp(pVnode, item, pWrite->rpcMsg.code); 
+        dnodeSendRpcVnodeWriteRsp(pVnode, item, pWrite->rpcMsg.code); 
       } else {
         taosFreeQitem(item);
         vnodeRelease(pVnode);

src/inc/dnode.h

@@ -37,22 +37,33 @@ typedef enum {
 SDnodeRunStatus dnodeGetRunStatus();
 SDnodeStatisInfo dnodeGetStatisInfo();
 
-void *dnodeAllocateWqueue(void *pVnode);
-void  dnodeFreeWqueue(void *queue);
-void *dnodeAllocateRqueue(void *pVnode);
-void  dnodeFreeRqueue(void *rqueue);
-void  dnodeSendRpcWriteRsp(void *pVnode, void *param, int32_t code);
-
 bool    dnodeIsFirstDeploy();
 char *  dnodeGetMnodeMasterEp();
-void     dnodeGetMnodeDnodeIpSet(void *ipSet);
+void    dnodeGetMnodeIpSetForPeer(void *ipSet);
+void    dnodeGetMnodeIpSetForShell(void *ipSet);
 void *  dnodeGetMnodeInfos();
 int32_t dnodeGetDnodeId();
 
 void  dnodeAddClientRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg));
-void     dnodeAddServerMsgHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg));
 void  dnodeSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg);
 void  dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp);
+void *dnodeSendCfgTableToRecv(int32_t vgId, int32_t sid);
+
+void *dnodeAllocateVnodeWqueue(void *pVnode);
+void  dnodeFreeVnodeWqueue(void *queue);
+void *dnodeAllocateVnodeRqueue(void *pVnode);
+void  dnodeFreeVnodeRqueue(void *rqueue);
+void  dnodeSendRpcVnodeWriteRsp(void *pVnode, void *param, int32_t code);
+
+int32_t dnodeAllocateMnodePqueue();
+void    dnodeFreeMnodePqueue();
+int32_t dnodeAllocateMnodeRqueue();
+void    dnodeFreeMnodeRqueue();
+int32_t dnodeAllocateMnodeWqueue();
+void    dnodeFreeMnodeWqueue();
+void    dnodeSendRpcMnodeWriteRsp(void *pMsg, int32_t code);
+void    dnodeReprocessMnodeWriteMsg(void *pMsg);
+void    dnodeDelayReprocessMnodeWriteMsg(void *pMsg);
 
 #ifdef __cplusplus
 }

src/inc/mnode.h

@@ -13,23 +13,58 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MGMT_H
+#ifndef TDENGINE_MNODE_H
-#define TDENGINE_MGMT_H
+#define TDENGINE_MNODE_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-int32_t mgmtInitSystem();
+#include "trpc.h"
-int32_t mgmtStartSystem();
+
-void    mgmtCleanUpSystem();
+struct SAcctObj;
-void    mgmtStopSystem();
+struct SDnodeObj;
+struct SUserObj;
+struct SDbObj;
+struct SVgObj;
+struct STableObj;
+
+typedef struct {
+  int32_t len;
+  void *  rsp;
+} SMnodeRsp;
+
+typedef struct SMnodeMsg {
+  SRpcMsg   rpcMsg;
+  SMnodeRsp rpcRsp;
+  int8_t    received;
+  int8_t    successed;
+  int8_t    expected;
+  int8_t    retry;
+  int32_t   code;
+  struct SAcctObj * pAcct;
+  struct SDnodeObj *pDnode;
+  struct SUserObj * pUser;
+  struct SDbObj *   pDb;
+  struct SVgObj *   pVgroup;
+  struct STableObj *pTable;
+} SMnodeMsg;
+
+void    mnodeCreateMsg(SMnodeMsg *pMsg, SRpcMsg *rpcMsg);
+int32_t mnodeInitMsg(SMnodeMsg *pMsg);
+void    mnodeCleanupMsg(SMnodeMsg *pMsg);
+
+int32_t mnodeInitSystem();
+int32_t mnodeStartSystem();
+void    mnodeCleanupSystem();
+void    mnodeStopSystem();
 void    sdbUpdateSync();
-
+bool    mnodeIsRunning();
-int32_t mgmtRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey);
+int32_t mnodeProcessRead(SMnodeMsg *pMsg);
-void    mgmtProcessMsgFromShell(SRpcMsg *rpcMsg);
+int32_t mnodeProcessWrite(SMnodeMsg *pMsg);
-void    mgmtProcessReqMsgFromDnode(SRpcMsg *rpcMsg);
+int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg);
-
+void    mnodeProcessPeerRsp(SRpcMsg *pMsg);
+int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey);
 
 #ifdef __cplusplus
 }

src/inc/taosdef.h

@@ -203,6 +203,7 @@ void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size);
 #define TSDB_COL_NAME_LEN         64
 #define TSDB_MAX_SAVED_SQL_LEN    TSDB_MAX_COLUMNS * 64
 #define TSDB_MAX_SQL_LEN          TSDB_PAYLOAD_SIZE
+#define TSDB_MAX_SQL_SHOW_LEN     256
 #define TSDB_MAX_ALLOWED_SQL_LEN  (8*1024*1024U)          // sql length should be less than 6mb
 
 #define TSDB_MAX_BYTES_PER_ROW    TSDB_MAX_COLUMNS * 64
@@ -337,9 +338,6 @@ void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size);
 #define TSDB_ORDER_ASC   1
 #define TSDB_ORDER_DESC  2
 
-#define TSDB_SESSIONS_PER_VNODE (300)
-#define TSDB_SESSIONS_PER_DNODE (TSDB_SESSIONS_PER_VNODE * TSDB_MAX_VNODES)
-
 #define TSDB_DEFAULT_MNODES_HASH_SIZE   5
 #define TSDB_DEFAULT_DNODES_HASH_SIZE   10
 #define TSDB_DEFAULT_ACCOUNTS_HASH_SIZE 10
@@ -373,7 +371,7 @@ typedef enum {
 } ETableType;
 
 typedef enum {
-  TSDB_MOD_MGMT,
+  TSDB_MOD_MNODE,
   TSDB_MOD_HTTP,
   TSDB_MOD_MONITOR,
   TSDB_MOD_MQTT,

src/inc/taoserror.h

@@ -72,9 +72,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_NO_RESOURCE,                0, 0x0018, "no resource"
 TAOS_DEFINE_ERROR(TSDB_CODE_OPS_NOT_SUPPORT,            0, 0x0019, "operations not support")
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_OPTION,             0, 0x001A, "invalid option")
 TAOS_DEFINE_ERROR(TSDB_CODE_NOT_CONFIGURED,             0, 0x001B, "not configured")
-TAOS_DEFINE_ERROR(TSDB_CODE_NODE_OFFLINE,               0, 0x001C, "node offline")
+TAOS_DEFINE_ERROR(TSDB_CODE_NETWORK_UNAVAIL,            0, 0x001C, "network unavailable")
-TAOS_DEFINE_ERROR(TSDB_CODE_NETWORK_UNAVAIL,            0, 0x001D, "network unavailable")
+TAOS_DEFINE_ERROR(TSDB_CODE_AUTH_REQUIRED,              0, 0x001D, "auth required")
-TAOS_DEFINE_ERROR(TSDB_CODE_AUTH_REQUIRED,              0, 0x001E, "auth required")
 
 // db
 TAOS_DEFINE_ERROR(TSDB_CODE_DB_NOT_SELECTED,            0, 0x0100, "db not selected")
@@ -94,16 +93,13 @@ TAOS_DEFINE_ERROR(TSDB_CODE_NO_USER_FROM_CONN,          0, 0x0185, "can not get
 TAOS_DEFINE_ERROR(TSDB_CODE_TABLE_ALREADY_EXIST,        0, 0x0200, "table already exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE_ID,           0, 0x0201, "invalid table id")
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE_TYPE,         0, 0x0202, "invalid table typee")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE,              0, 0x0203, "invalid table name")
+TAOS_DEFINE_ERROR(TSDB_CODE_NOT_SUPER_TABLE,            0, 0x0203, "no super table")           // operation only available for super table
-TAOS_DEFINE_ERROR(TSDB_CODE_NOT_SUPER_TABLE,            0, 0x0204, "no super table")           // operation only available for super table
+TAOS_DEFINE_ERROR(TSDB_CODE_TAG_ALREAY_EXIST,           0, 0x0204, "tag already exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_NOT_ACTIVE_TABLE,           0, 0x0205, "not active table")
+TAOS_DEFINE_ERROR(TSDB_CODE_TAG_NOT_EXIST,              0, 0x0205, "tag not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_TABLE_ID_MISMATCH,          0, 0x0206, "table id mismatch")
+TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_ALREAY_EXIST,         0, 0x0206, "field already exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_TAG_ALREAY_EXIST,           0, 0x0207, "tag already exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_NOT_EXIST,            0, 0x0207, "field not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_TAG_NOT_EXIST,              0, 0x0208, "tag not exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_COL_NAME_TOO_LONG,          0, 0x0209, "column name too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_ALREAY_EXIST,         0, 0x0209, "field already exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TAGS,              0, 0x0209, "too many tags")
-TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_NOT_EXIST,            0, 0x020A, "field not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_COL_NAME_TOO_LONG,          0, 0x020B, "column name too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TAGS,              0, 0x020C, "too many tags")
 
 
 // dnode & mnode
@@ -148,15 +144,13 @@ TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_CPU_LIMITED,          0, 0x038F, "grant cpu li
 
 // server
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_VGROUP_ID,          0, 0x0400, "invalid vgroup id")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_VNODE_ID,           0, 0x0401, "invalid vnode id")
+TAOS_DEFINE_ERROR(TSDB_CODE_VG_INIT_FAILED,             0, 0x0402, "vgroup init failed")
-TAOS_DEFINE_ERROR(TSDB_CODE_NOT_ACTIVE_VNODE,           0, 0x0402, "not active vnode")
+TAOS_DEFINE_ERROR(TSDB_CODE_SERV_NO_DISKSPACE,          0, 0x0403, "server no diskspace")
-TAOS_DEFINE_ERROR(TSDB_CODE_VG_INIT_FAILED,             0, 0x0403, "vg init failed")
+TAOS_DEFINE_ERROR(TSDB_CODE_SERV_OUT_OF_MEMORY,         0, 0x0404, "server out of memory")
-TAOS_DEFINE_ERROR(TSDB_CODE_SERV_NO_DISKSPACE,          0, 0x0404, "server no diskspace")
+TAOS_DEFINE_ERROR(TSDB_CODE_NO_DISK_PERMISSIONS,        0, 0x0405, "no disk permissions")
-TAOS_DEFINE_ERROR(TSDB_CODE_SERV_OUT_OF_MEMORY,         0, 0x0405, "server out of memory")
+TAOS_DEFINE_ERROR(TSDB_CODE_FILE_CORRUPTED,             0, 0x0406, "file corrupted")
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_DISK_PERMISSIONS,        0, 0x0406, "no disk permissions")
+TAOS_DEFINE_ERROR(TSDB_CODE_MEMORY_CORRUPTED,           0, 0x0407, "memory corrupted")
-TAOS_DEFINE_ERROR(TSDB_CODE_FILE_CORRUPTED,             0, 0x0407, "file corrupted")
+TAOS_DEFINE_ERROR(TSDB_CODE_NOT_SUCH_FILE_OR_DIR,       0, 0x0408, "no such file or directory")
-TAOS_DEFINE_ERROR(TSDB_CODE_MEMORY_CORRUPTED,           0, 0x0408, "memory corrupted")
-TAOS_DEFINE_ERROR(TSDB_CODE_NOT_SUCH_FILE_OR_DIR,       0, 0x0409, "no such file or directory")
 
 // client
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CLIENT_VERSION,     0, 0x0481, "invalid client version")

src/inc/taosmsg.h

@@ -669,8 +669,8 @@ typedef struct {
 } SCMCreateDnodeMsg, SCMDropDnodeMsg;
 
 typedef struct {
-  uint32_t dnode;
+  int32_t dnodeId;
-  int32_t  vnode;
+  int32_t vgId;
   int32_t sid;
 } SDMConfigTableMsg;
 

src/inc/tbalance.h

@@ -26,7 +26,7 @@ struct SDnodeObj;
 int32_t balanceInit();
 void    balanceCleanUp();
 void    balanceNotify();
-void    balanceUpdateMgmt();
+void    balanceUpdateMnode();
 void    balanceReset();
 int32_t balanceAllocVnodes(struct SVgObj *pVgroup);
 int32_t balanceDropDnode(struct SDnodeObj *pDnode);

src/inc/tcq.h

@@ -19,6 +19,7 @@
 extern "C" {
 #endif
 
+#include "tdataformat.h"
 
 typedef int (*FCqWrite)(void *ahandle, void *pHead, int type);
 
@@ -40,7 +41,7 @@ void  cqStart(void *handle);
 void  cqStop(void *handle);
 
 // cqCreate is called by TSDB to start an instance of CQ 
-void *cqCreate(void *handle, int sid, char *sqlStr, SSchema *pSchema, int columns);
+void *cqCreate(void *handle, int sid, char *sqlStr, STSchema *pSchema);
 
 // cqDrop is called by TSDB to stop an instance of CQ, handle is the return value of cqCreate
 void  cqDrop(void *handle);

src/inc/trpc.h

@@ -28,21 +28,21 @@ extern "C" {
 
 extern int tsRpcHeadSize;
 
-typedef struct {
+typedef struct SRpcIpSet {
   int8_t    inUse; 
   int8_t    numOfIps;
   uint16_t  port[TSDB_MAX_REPLICA];
   char      fqdn[TSDB_MAX_REPLICA][TSDB_FQDN_LEN];
 } SRpcIpSet;
 
-typedef struct {
+typedef struct SRpcConnInfo {
   uint32_t  clientIp;
   uint16_t  clientPort;
   uint32_t  serverIp;
   char      user[TSDB_USER_LEN];
 } SRpcConnInfo;
 
-typedef struct {
+typedef struct SRpcMsg {
   uint8_t msgType;
   void   *pCont;
   int     contLen;
@@ -51,7 +51,7 @@ typedef struct {
   void   *ahandle;  //app handle set by client, for debug purpose
 } SRpcMsg;
 
-typedef struct {
+typedef struct SRpcInit {
   uint16_t localPort; // local port
   char  *label;        // for debug purpose
   int    numOfThreads; // number of threads to handle connections

src/inc/tsdb.h

@@ -43,6 +43,8 @@ typedef struct {
   void *cqH;
   int (*notifyStatus)(void *, int status);
   int (*eventCallBack)(void *);
+  void *(*cqCreateFunc)(void *handle, int sid, char *sqlStr, STSchema *pSchema);
+  void (*cqDropFunc)(void *handle);
 } STsdbAppH;
 
 // --------- TSDB REPOSITORY CONFIGURATION DEFINITION
@@ -71,7 +73,7 @@ typedef void TsdbRepoT;  // use void to hide implementation details from outside
 
 int        tsdbCreateRepo(char *rootDir, STsdbCfg *pCfg, void *limiter);
 int32_t    tsdbDropRepo(TsdbRepoT *repo);
-TsdbRepoT *tsdbOpenRepo(char *tsdbDir, STsdbAppH *pAppH);
+TsdbRepoT *tsdbOpenRepo(char *rootDir, STsdbAppH *pAppH);
 int32_t    tsdbCloseRepo(TsdbRepoT *repo, int toCommit);
 int32_t    tsdbConfigRepo(TsdbRepoT *repo, STsdbCfg *pCfg);
 

src/kit/shell/src/shellDarwin.c

@@ -97,7 +97,11 @@ void shellParseArgument(int argc, char *argv[], struct arguments *arguments) {
       }
     } else if (strcmp(argv[i], "-c") == 0) {
       if (i < argc - 1) { 
-        strcpy(configDir, argv[++i]);
+        if (strlen(argv[++i]) > TSDB_FILENAME_LEN - 1) {
+          fprintf(stderr, "config file path: %s overflow max len %d\n", argv[i], TSDB_FILENAME_LEN - 1);
+          exit(EXIT_FAILURE);
+        }
+        strcpy(configDir, argv[i]);
       } else {
         fprintf(stderr, "Option -c requires an argument\n");
         exit(EXIT_FAILURE);

src/kit/shell/src/shellLinux.c

@@ -81,6 +81,11 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
         fprintf(stderr, "Invalid path %s\n", arg);
         return -1;
       }       
+      if (strlen(full_path.we_wordv[0]) > TSDB_FILENAME_LEN - 1) {
+        fprintf(stderr, "config file path: %s overflow max len %d\n", full_path.we_wordv[0], TSDB_FILENAME_LEN - 1);
+        wordfree(&full_path);
+        return -1;
+      }
       strcpy(configDir, full_path.we_wordv[0]);
       wordfree(&full_path);
       break;

src/kit/shell/src/shellWindows.c

@@ -77,7 +77,11 @@ void shellParseArgument(int argc, char *argv[], struct arguments *arguments) {
       }
     } else if (strcmp(argv[i], "-c") == 0) {
       if (i < argc - 1) {   
-        strcpy(configDir, argv[++i]);
+        if (strlen(argv[++i]) > TSDB_FILENAME_LEN - 1) {
+          fprintf(stderr, "config file path: %s overflow max len %d\n", argv[i], TSDB_FILENAME_LEN - 1);
+          exit(EXIT_FAILURE);
+        }
+        strcpy(configDir, argv[i]);
       } else {
         fprintf(stderr, "Option -c requires an argument\n");
         exit(EXIT_FAILURE);

src/kit/taosdemo/taosdemo.c

@@ -49,7 +49,7 @@ static struct argp_option options[] = {
   {0, 'h', "host",                     0, "The host to connect to TDEngine. Default is localhost.",                                                           0},
   {0, 'p', "port",                     0, "The TCP/IP port number to use for the connection. Default is 0.",                                                  1},
   {0, 'u', "user",                     0, "The TDEngine user name to use when connecting to the server. Default is 'root'.",                                  2},
-  {0, 'a', "password",                 0, "The password to use when connecting to the server. Default is 'taosdata'.",                                        3},
+  {0, 'P', "password",                 0, "The password to use when connecting to the server. Default is 'taosdata'.",                                        3},
   {0, 'd', "database",                 0, "Destination database. Default is 'test'.",                                                                         3},
   {0, 'm', "table_prefix",             0, "Table prefix name. Default is 't'.",                                                                               3},
   {0, 'M', 0,                          0, "Use metric flag.",                                                                                                 13},
@@ -58,12 +58,15 @@ static struct argp_option options[] = {
   {0, 'b', "type_of_cols",             0, "The data_type of columns: 'INT', 'TINYINT', 'SMALLINT', 'BIGINT', 'FLOAT', 'DOUBLE', 'BINARY'. Default is 'INT'.", 7},
   {0, 'w', "length_of_binary",         0, "The length of data_type 'BINARY'. Only applicable when type of cols is 'BINARY'. Default is 8",                    8},
   {0, 'l', "num_of_cols_per_record",   0, "The number of columns per record. Default is 3.",                                                                  8},
-  {0, 'c', "num_of_conns",             0, "The number of connections. Default is 10.",                                                                        9},
+  {0, 'T', "num_of_threads",           0, "The number of threads. Default is 10.",                                                                            9},
   {0, 'r', "num_of_records_per_req",   0, "The number of records per request. Default is 1000.",                                                              10},
   {0, 't', "num_of_tables",            0, "The number of tables. Default is 10000.",                                                                          11},
   {0, 'n', "num_of_records_per_table", 0, "The number of records per table. Default is 100000.",                                                              12},
-  {0, 'f', "config_directory",         0, "Configuration directory. Default is '/etc/taos/'.",                                                                14},
+  {0, 'c', "config_directory",         0, "Configuration directory. Default is '/etc/taos/'.",                                                                14},
   {0, 'x', 0,                          0, "Insert only flag.",                                                                                                13},
+  {0, 'O', "order",                    0, "Insert mode--0: In order, 1: Out of order. Default is in order.",                                                  14},
+  {0, 'R', "rate",                     0, "Out of order data's rate--if order=1 Default 10, min: 0, max: 50.",                                                14},
+  {0, 'D', "delete table",             0, "Delete data methods——0: don't delete, 1: delete by table, 2: delete by stable, 3: delete by database",             14},
   {0}};
 
 /* Used by main to communicate with parse_opt. */
@@ -81,11 +84,14 @@ typedef struct DemoArguments {
   char  *datatype[MAX_NUM_DATATYPE];
   int    len_of_binary;
   int    num_of_CPR;
-  int    num_of_connections;
+  int    num_of_threads;
   int    num_of_RPR;
   int    num_of_tables;
   int    num_of_DPT;
   int    abort;
+  int    order;
+  int    rate;
+  int    method_of_delete;
   char **arg_list;
 } SDemoArguments;
 
@@ -106,7 +112,7 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
     case 'u':
       arguments->user = arg;
       break;
-    case 'a':
+    case 'P':
       arguments->password = arg;
       break;
     case 'o':
@@ -115,8 +121,8 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
     case 'q':
       arguments->mode = atoi(arg);
       break;
-    case 'c':
+    case 'T':
-      arguments->num_of_connections = atoi(arg);
+      arguments->num_of_threads = atoi(arg);
       break;
     case 'r':
       arguments->num_of_RPR = atoi(arg);
@@ -176,7 +182,7 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
     case 'x':
       arguments->insert_only = true;
       break;
-    case 'f':
+    case 'c':
       if (wordexp(arg, &full_path, 0) != 0) {
         fprintf(stderr, "Invalid path %s\n", arg);
         return -1;
@@ -184,6 +190,30 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
       taos_options(TSDB_OPTION_CONFIGDIR, full_path.we_wordv[0]);
       wordfree(&full_path);
       break;
+    case 'O':
+      arguments->order = atoi(arg);
+      if (arguments->order > 1 || arguments->order < 0)
+      {
+        arguments->order = 0;
+      } else if (arguments->order == 1)
+      {
+        arguments->rate = 10;
+      }
+      break;
+    case 'R':
+      arguments->rate = atoi(arg);
+      if (arguments->order == 1 && (arguments->rate > 50 || arguments->rate <= 0))
+      {
+        arguments->rate = 10;
+      }
+      break;
+    case 'D':
+      arguments->method_of_delete = atoi(arg);
+      if (arguments->method_of_delete < 0 || arguments->method_of_delete > 3)
+      {
+        arguments->method_of_delete = 0;
+      }
+      break;
     case OPT_ABORT:
       arguments->abort = 1;
       break;
@@ -217,6 +247,8 @@ typedef struct {
   int ncols_per_record;
   int nrecords_per_table;
   int nrecords_per_request;
+  int data_of_order;
+  int data_of_rate;
   int64_t start_time;
   bool do_aggreFunc;
 
@@ -236,6 +268,8 @@ typedef struct {
   int    ncols_per_record;
   char **data_type;
   int    len_of_binary;
+  int data_of_order;
+  int data_of_rate;
 
   sem_t *mutex_sem;
   int   *notFinished;
@@ -258,6 +292,8 @@ void *readMetric(void *sarg);
 
 void *syncWrite(void *sarg);
 
+void *deleteTable();
+
 void *asyncWrite(void *sarg);
 
 void generateData(char *res, char **data_type, int num_of_cols, int64_t timestamp, int len_of_binary);
@@ -291,11 +327,14 @@ int main(int argc, char *argv[]) {
                                 },
                                 8,               // len_of_binary
                                 1,               // num_of_CPR
-                                1,               // num_of_connections
+                                1,               // num_of_connections/thread
                                 1,               // num_of_RPR
                                 1,               // num_of_tables
                                 50000,           // num_of_DPT
                                 0,               // abort
+                                0,               // order
+                                0,               // rate
+                                0,               // method_of_delete
                                 NULL             // arg_list
                                 };
 
@@ -304,7 +343,7 @@ int main(int argc, char *argv[]) {
   // For demo use, change default values for some parameters;
   arguments.num_of_tables = 10000;
   arguments.num_of_CPR = 3; 
-  arguments.num_of_connections = 10;
+  arguments.num_of_threads = 10;
   arguments.num_of_DPT = 100000;
   arguments.num_of_RPR = 1000;
   arguments.use_metric = true;
@@ -330,8 +369,11 @@ int main(int argc, char *argv[]) {
   char *tb_prefix = arguments.tb_prefix;
   int len_of_binary = arguments.len_of_binary;
   int ncols_per_record = arguments.num_of_CPR;
+  int order = arguments.order;
+  int rate = arguments.rate;
+  int method_of_delete = arguments.method_of_delete;
   int ntables = arguments.num_of_tables;
-  int nconnections = arguments.num_of_connections;
+  int threads = arguments.num_of_threads;
   int nrecords_per_table = arguments.num_of_DPT;
   int nrecords_per_request = arguments.num_of_RPR;
   bool use_metric = arguments.use_metric;
@@ -371,12 +413,19 @@ int main(int argc, char *argv[]) {
   printf("# Binary Length(If applicable):      %d\n",
           (strcasestr(dataString, "BINARY") != NULL) ? len_of_binary : -1);
   printf("# Number of Columns per record:      %d\n", ncols_per_record);
-  printf("# Number of Connections:             %d\n", nconnections);
+  printf("# Number of Threads:                 %d\n", threads);
   printf("# Number of Tables:                  %d\n", ntables);
   printf("# Number of Data per Table:          %d\n", nrecords_per_table);
   printf("# Records/Request:                   %d\n", nrecords_per_request);
   printf("# Database name:                     %s\n", db_name);
   printf("# Table prefix:                      %s\n", tb_prefix);
+  if (order == 1)
+  {
+    printf("# Data order:                        %d\n", order);
+    printf("# Data out of order rate:            %d\n", rate);
+
+  }
+  printf("# Delete method:                     %d\n", method_of_delete);
   printf("# Test time:                         %d-%02d-%02d %02d:%02d:%02d\n", tm.tm_year + 1900, tm.tm_mon + 1,
           tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
   printf("###################################################################\n\n");
@@ -392,12 +441,18 @@ int main(int argc, char *argv[]) {
   fprintf(fp, "# Binary Length(If applicable):      %d\n",
           (strcasestr(dataString, "BINARY") != NULL) ? len_of_binary : -1);
   fprintf(fp, "# Number of Columns per record:      %d\n", ncols_per_record);
-  fprintf(fp, "# Number of Connections:             %d\n", nconnections);
+  fprintf(fp, "# Number of Threads:                 %d\n", threads);
   fprintf(fp, "# Number of Tables:                  %d\n", ntables);
   fprintf(fp, "# Number of Data per Table:          %d\n", nrecords_per_table);
   fprintf(fp, "# Records/Request:                   %d\n", nrecords_per_request);
   fprintf(fp, "# Database name:                     %s\n", db_name);
   fprintf(fp, "# Table prefix:                      %s\n", tb_prefix);
+  if (order == 1)
+  {
+    printf("# Data order:                        %d\n", order);
+    printf("# Data out of order rate:            %d\n", rate);
+
+  }
   fprintf(fp, "# Test time:                         %d-%02d-%02d %02d:%02d:%02d\n", tm.tm_year + 1900, tm.tm_mon + 1,
           tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
   fprintf(fp, "###################################################################\n\n");
@@ -414,7 +469,7 @@ int main(int argc, char *argv[]) {
 
   sprintf(command, "drop database %s;", db_name);
   taos_query(taos, command);
-  sleep(3);
+  
 
   sprintf(command, "create database %s;", db_name);
   taos_query(taos, command);
@@ -479,22 +534,22 @@ int main(int argc, char *argv[]) {
     taos_close(taos);
   }
   /* Wait for table to create  */
-  sleep(5);
+  
 
   /* Insert data */
   double ts = getCurrentTime();
   printf("Inserting data......\n");
-  pthread_t *pids = malloc(nconnections * sizeof(pthread_t));
+  pthread_t *pids = malloc(threads * sizeof(pthread_t));
-  info *infos = malloc(nconnections * sizeof(info));
+  info *infos = malloc(threads * sizeof(info));
 
-  int a = ntables / nconnections;
+  int a = ntables / threads;
   if (a < 1) {
-    nconnections = ntables;
+    threads = ntables;
     a = 1;
   }
-  int b = ntables % nconnections;
+  int b = ntables % threads;
   int last = 0;
-  for (int i = 0; i < nconnections; i++) {
+  for (int i = 0; i < threads; i++) {
     info *t_info = infos + i;
     t_info->threadID = i;
     strcpy(t_info->db_name, db_name);
@@ -507,6 +562,8 @@ int main(int argc, char *argv[]) {
     t_info->len_of_binary = len_of_binary;
     t_info->nrecords_per_request = nrecords_per_request;
     t_info->start_table_id = last;
+    t_info->data_of_order = order;
+    t_info->data_of_rate = rate;
     t_info->end_table_id = i < b ? last + a : last + a - 1;
     last = t_info->end_table_id + 1;
 
@@ -520,15 +577,15 @@ int main(int argc, char *argv[]) {
       pthread_create(pids + i, NULL, asyncWrite, t_info);
     }
   }
-  for (int i = 0; i < nconnections; i++) {
+  for (int i = 0; i < threads; i++) {
     pthread_join(pids[i], NULL);
   }
 
   double t = getCurrentTime() - ts;
   if (query_mode == SYNC) {
-    printf("SYNC Insert with %d connections:\n", nconnections);
+    printf("SYNC Insert with %d connections:\n", threads);
   } else {
-    printf("ASYNC Insert with %d connections:\n", nconnections);
+    printf("ASYNC Insert with %d connections:\n", threads);
   }
 
   fprintf(fp, "|%10.d  |  %10.2f    |  %10.2f     |  %10.4f   |\n\n",
@@ -540,7 +597,7 @@ int main(int argc, char *argv[]) {
          t, ntables * nrecords_per_table, nrecords_per_request,
          ntables * nrecords_per_table / t);
 
-  for (int i = 0; i < nconnections; i++) {
+  for (int i = 0; i < threads; i++) {
     info *t_info = infos + i;
     taos_close(t_info->taos);
     sem_destroy(&(t_info->mutex_sem));
@@ -551,6 +608,55 @@ int main(int argc, char *argv[]) {
   free(infos);
   fclose(fp);
 
+  if (method_of_delete != 0)
+  {
+    TAOS *dtaos = taos_connect(ip_addr, user, pass, db_name, port);
+    double dts = getCurrentTime();
+    printf("Deleteing %d table(s)......\n", ntables);
+
+    switch (method_of_delete)
+    {
+    case 1:
+      // delete by table
+      /* Create all the tables; */
+      for (int i = 0; i < ntables; i++) {
+        sprintf(command, "drop table %s.%s%d;", db_name, tb_prefix, i);
+        queryDB(dtaos, command);
+      }
+      break;
+    case 2:
+      // delete by stable
+      if (!use_metric) {
+        break;
+      }
+      else
+      {
+        sprintf(command, "drop table %s.meters;", db_name);
+        queryDB(dtaos, command);
+      }
+      break;
+    case 3:
+      // delete by database
+      sprintf(command, "drop database %s;", db_name);
+      queryDB(dtaos, command);
+      break;
+    default:
+      break;
+    }
+
+    printf("Table(s) droped!\n");
+    taos_close(dtaos);
+
+    double dt = getCurrentTime() - dts;
+    printf("Spent %.4f seconds to drop %d tables\n", dt, ntables);
+
+    FILE *fp = fopen(arguments.output_file, "a");
+    fprintf(fp, "Spent %.4f seconds to drop %d tables\n", dt, ntables);
+    fclose(fp);
+
+  }
+  
+
   if (!insert_only) {
     // query data
     pthread_t read_id;
@@ -735,7 +841,15 @@ void *syncWrite(void *sarg) {
       pstr += sprintf(pstr, "insert into %s.%s%d values", winfo->db_name, winfo->tb_prefix, tID);
       int k;
       for (k = 0; k < winfo->nrecords_per_request;) {
-        generateData(data, data_type, ncols_per_record, tmp_time++, len_of_binary);
+        int rand_num = rand() % 100;
+        if (winfo->data_of_order ==1 && rand_num < winfo->data_of_rate)
+        {
+          long d = tmp_time - rand() % 1000000 + rand_num;
+          generateData(data, data_type, ncols_per_record, d, len_of_binary);
+        } else 
+        {
+          generateData(data, data_type, ncols_per_record, tmp_time += 1000, len_of_binary);
+        }
         pstr += sprintf(pstr, " %s", data);
         inserted++;
         k++;
@@ -774,6 +888,8 @@ void *asyncWrite(void *sarg) {
     tb_info->mutex_sem = &(winfo->mutex_sem);
     tb_info->notFinished = &(winfo->notFinished);
     tb_info->lock_sem = &(winfo->lock_sem);
+    tb_info->data_of_order = winfo->data_of_order;
+    tb_info->data_of_rate = winfo->data_of_rate;
 
     /* char buff[BUFFER_SIZE] = "\0"; */
     /* sprintf(buff, "insert into %s values (0, 0)", tb_info->tb_name); */
@@ -815,7 +931,15 @@ void callBack(void *param, TAOS_RES *res, int code) {
   pstr += sprintf(pstr, "insert into %s values", tb_info->tb_name);
 
   for (int i = 0; i < tb_info->nrecords_per_request; i++) {
-    generateData(data, datatype, ncols_per_record, tmp_time++, len_of_binary);
+    int rand_num = rand() % 100;
+    if (tb_info->data_of_order ==1 && rand_num < tb_info->data_of_rate)
+    {
+      long d = tmp_time - rand() % 1000000 + rand_num;
+      generateData(data, datatype, ncols_per_record, d, len_of_binary);
+    } else 
+    {
+      generateData(data, datatype, ncols_per_record, tmp_time += 1000, len_of_binary);
+    }
     pstr += sprintf(pstr, "%s", data);
     tb_info->counter++;
 

src/mnode/inc/mgmtDb.h

@@ -1,56 +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 TDENGINE_MGMT_DB_H
-#define TDENGINE_MGMT_DB_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "mgmtDef.h"
-
-enum _TSDB_DB_STATUS {
-  TSDB_DB_STATUS_READY,
-  TSDB_DB_STATUS_DROPPING
-};
-
-// api
-int32_t mgmtInitDbs();
-void    mgmtCleanUpDbs();
-SDbObj *mgmtGetDb(char *db);
-SDbObj *mgmtGetDbByTableId(char *db);
-void *  mgmtGetNextDb(void *pIter, SDbObj **pDb);
-void    mgmtIncDbRef(SDbObj *pDb);
-void    mgmtDecDbRef(SDbObj *pDb);
-bool    mgmtCheckIsMonitorDB(char *db, char *monitordb);
-void    mgmtDropAllDbs(SAcctObj *pAcct);
-
-// util func
-void mgmtAddSuperTableIntoDb(SDbObj *pDb);
-void mgmtRemoveSuperTableFromDb(SDbObj *pDb);
-void mgmtAddTableIntoDb(SDbObj *pDb);
-void mgmtRemoveTableFromDb(SDbObj *pDb);
-void mgmtAddVgroupIntoDb(SVgObj *pVgroup);
-void mgmtAddVgroupIntoDbTail(SVgObj *pVgroup);
-void mgmtRemoveVgroupFromDb(SVgObj *pVgroup);
-void mgmtMoveVgroupToTail(SVgObj *pVgroup);
-void mgmtMoveVgroupToHead(SVgObj *pVgroup);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mgmtShell.h

@@ -1,49 +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 TDENGINE_MGMT_SHELL_H
-#define TDENGINE_MGMT_SHELL_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "mgmtDef.h"
-
-int32_t mgmtInitShell();
-void    mgmtCleanUpShell();
-void    mgmtAddShellMsgHandle(uint8_t msgType, void (*fp)(SQueuedMsg *queuedMsg));
-
-typedef int32_t (*SShowMetaFp)(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-typedef int32_t (*SShowRetrieveFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-void mgmtAddShellShowMetaHandle(uint8_t showType, SShowMetaFp fp);
-void mgmtAddShellShowRetrieveHandle(uint8_t showType, SShowRetrieveFp fp);
-
-void mgmtAddToShellQueue(SQueuedMsg *queuedMsg);
-void mgmtDealyedAddToShellQueue(SQueuedMsg *queuedMsg);
-void mgmtSendSimpleResp(void *thandle, int32_t code);
-
-bool  mgmtCheckQhandle(uint64_t qhandle);
-void *mgmtSaveQhandle(void *qhandle, int32_t size);
-void  mgmtFreeQhandle(void *qhandle, bool forceRemove);
-
-void *mgmtMallocQueuedMsg(SRpcMsg *rpcMsg);
-void *mgmtCloneQueuedMsg(SQueuedMsg *pSrcMsg);
-void  mgmtFreeQueuedMsg(SQueuedMsg *pMsg);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mgmtVgroup.h

@@ -1,56 +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 TDENGINE_MGMT_VGROUP_H
-#define TDENGINE_MGMT_VGROUP_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "mgmtDef.h"
-
-int32_t mgmtInitVgroups();
-void    mgmtCleanUpVgroups();
-SVgObj *mgmtGetVgroup(int32_t vgId);
-void    mgmtIncVgroupRef(SVgObj *pVgroup);
-void    mgmtDecVgroupRef(SVgObj *pVgroup);
-void    mgmtDropAllDbVgroups(SDbObj *pDropDb, bool sendMsg);
-void    mgmtDropAllDnodeVgroups(SDnodeObj *pDropDnode);
-void    mgmtUpdateAllDbVgroups(SDbObj *pAlterDb);
-
-void *  mgmtGetNextVgroup(void *pIter, SVgObj **pVgroup);
-void    mgmtUpdateVgroup(SVgObj *pVgroup);
-void    mgmtUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *dnodeId, SVnodeLoad *pVload);
-
-void    mgmtCreateVgroup(SQueuedMsg *pMsg, SDbObj *pDb);
-void    mgmtDropVgroup(SVgObj *pVgroup, void *ahandle);
-void    mgmtAlterVgroup(SVgObj *pVgroup, void *ahandle);
-SVgObj *mgmtGetAvailableVgroup(SDbObj *pDb);
-
-void    mgmtAddTableIntoVgroup(SVgObj *pVgroup, SChildTableObj *pTable);
-void    mgmtRemoveTableFromVgroup(SVgObj *pVgroup, SChildTableObj *pTable);
-void    mgmtSendCreateVnodeMsg(SVgObj *pVgroup, SRpcIpSet *ipSet, void *ahandle);
-void    mgmtSendDropVnodeMsg(int32_t vgId, SRpcIpSet *ipSet, void *ahandle);
-void    mgmtSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle);
-
-SRpcIpSet mgmtGetIpSetFromVgroup(SVgObj *pVgroup);
-SRpcIpSet mgmtGetIpSetFromIp(char *ep);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mnodeAcct.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MGMT_ACCT_H
+#ifndef TDENGINE_MNODE_ACCT_H
-#define TDENGINE_MGMT_ACCT_H
+#define TDENGINE_MNODE_ACCT_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -22,16 +22,16 @@ extern "C" {
 
 #include "tacct.h"
 
-int32_t mgmtInitAccts();
+int32_t mnodeInitAccts();
-void    mgmtCleanUpAccts();
+void    mnodeCleanupAccts();
-void *  mgmtGetAcct(char *acctName);
+void *  mnodeGetAcct(char *acctName);
-void *  mgmtGetNextAcct(void *pIter, SAcctObj **pAcct);
+void *  mnodeGetNextAcct(void *pIter, SAcctObj **pAcct);
-void    mgmtIncAcctRef(SAcctObj *pAcct);
+void    mnodeIncAcctRef(SAcctObj *pAcct);
-void    mgmtDecAcctRef(SAcctObj *pAcct);
+void    mnodeDecAcctRef(SAcctObj *pAcct);
-void    mgmtAddDbToAcct(SAcctObj *pAcct, SDbObj *pDb);
+void    mnodeAddDbToAcct(SAcctObj *pAcct, SDbObj *pDb);
-void    mgmtDropDbFromAcct(SAcctObj *pAcct, SDbObj *pDb);
+void    mnodeDropDbFromAcct(SAcctObj *pAcct, SDbObj *pDb);
-void    mgmtAddUserToAcct(SAcctObj *pAcct, SUserObj *pUser);
+void    mnodeAddUserToAcct(SAcctObj *pAcct, SUserObj *pUser);
-void    mgmtDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser);
+void    mnodeDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser);
 
 #ifdef __cplusplus
 }

src/mnode/inc/mnodeDb.h

@@ -0,0 +1,56 @@
+/*
+ * 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 TDENGINE_MNODE_DB_H
+#define TDENGINE_MNODE_DB_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "mnodeDef.h"
+
+enum _TSDB_DB_STATUS {
+  TSDB_DB_STATUS_READY,
+  TSDB_DB_STATUS_DROPPING
+};
+
+// api
+int32_t mnodeInitDbs();
+void    mnodeCleanupDbs();
+SDbObj *mnodeGetDb(char *db);
+SDbObj *mnodeGetDbByTableId(char *db);
+void *  mnodeGetNextDb(void *pIter, SDbObj **pDb);
+void    mnodeIncDbRef(SDbObj *pDb);
+void    mnodeDecDbRef(SDbObj *pDb);
+bool    mnodeCheckIsMonitorDB(char *db, char *monitordb);
+void    mnodeDropAllDbs(SAcctObj *pAcct);
+
+// util func
+void mnodeAddSuperTableIntoDb(SDbObj *pDb);
+void mnodeRemoveSuperTableFromDb(SDbObj *pDb);
+void mnodeAddTableIntoDb(SDbObj *pDb);
+void mnodeRemoveTableFromDb(SDbObj *pDb);
+void mnodeAddVgroupIntoDb(SVgObj *pVgroup);
+void mnodeAddVgroupIntoDbTail(SVgObj *pVgroup);
+void mnodeRemoveVgroupFromDb(SVgObj *pVgroup);
+void mnodeMoveVgroupToTail(SVgObj *pVgroup);
+void mnodeMoveVgroupToHead(SVgObj *pVgroup);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/mnode/inc/mnodeDef.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MGMT_DEF_H
+#ifndef TDENGINE_MNODE_DEF_H
-#define TDENGINE_MGMT_DEF_H
+#define TDENGINE_MNODE_DEF_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -65,7 +65,7 @@ typedef struct SMnodeObj {
   int8_t     role;
 } SMnodeObj;
 
-typedef struct {
+typedef struct STableObj {
   char  *tableId;
   int8_t type;
 } STableObj;
@@ -220,6 +220,7 @@ typedef struct SAcctObj {
 
 typedef struct {
   int8_t   type;
+  int32_t  index;
   char     db[TSDB_DB_NAME_LEN + 1];
   void *   pIter;
   int16_t  numOfColumns;
@@ -228,31 +229,10 @@ typedef struct {
   int32_t  numOfReads;
   int16_t  offset[TSDB_MAX_COLUMNS];
   int16_t  bytes[TSDB_MAX_COLUMNS];
-  void *   signature;
   uint16_t payloadLen;
   char     payload[];
 } SShowObj;
 
-typedef struct {
-  uint8_t  msgType;
-  int8_t   received;
-  int8_t   successed;
-  int8_t   expected;
-  int8_t   retry;
-  int8_t   maxRetry;
-  int32_t  contLen;
-  int32_t  code;
-  void     *ahandle;
-  void     *thandle;
-  void     *pCont;
-  SAcctObj *pAcct;
-  SDnodeObj*pDnode;
-  SUserObj *pUser;
-  SDbObj   *pDb;
-  SVgObj   *pVgroup;
-  STableObj *pTable;
-} SQueuedMsg;
-
 #ifdef __cplusplus
 }
 #endif

src/mnode/inc/mnodeDnode.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_CLUSTER_H
+#ifndef TDENGINE_MNODE_DNODE_H
-#define TDENGINE_CLUSTER_H
+#define TDENGINE_MNODE_DNODE_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -27,21 +27,27 @@ typedef enum {
   TAOS_DN_STATUS_READY
 } EDnodeStatus;
 
-int32_t mgmtInitDnodes();
+typedef enum {
-void    mgmtCleanupDnodes();
+  TAOS_DN_ALTERNATIVE_ROLE_ANY,
+  TAOS_DN_ALTERNATIVE_ROLE_MNODE,
+  TAOS_DN_ALTERNATIVE_ROLE_VNODE
+} EDnodeAlternativeRole;
 
-char*   mgmtGetDnodeStatusStr(int32_t dnodeStatus);
+int32_t mnodeInitDnodes();
+void    mnodeCleanupDnodes();
+
+char*   mnodeGetDnodeStatusStr(int32_t dnodeStatus);
 void    mgmtMonitorDnodeModule();
 
-int32_t mgmtGetDnodesNum();
+int32_t mnodeGetDnodesNum();
-int32_t mgmtGetOnlinDnodesNum();
+int32_t mnodeGetOnlinDnodesNum();
-void *  mgmtGetNextDnode(void *pIter, SDnodeObj **pDnode);
+void *  mnodeGetNextDnode(void *pIter, SDnodeObj **pDnode);
-void    mgmtIncDnodeRef(SDnodeObj *pDnode);
+void    mnodeIncDnodeRef(SDnodeObj *pDnode);
-void    mgmtDecDnodeRef(SDnodeObj *pDnode);
+void    mnodeDecDnodeRef(SDnodeObj *pDnode);
-void *  mgmtGetDnode(int32_t dnodeId);
+void *  mnodeGetDnode(int32_t dnodeId);
-void *  mgmtGetDnodeByEp(char *ep);
+void *  mnodeGetDnodeByEp(char *ep);
-void    mgmtUpdateDnode(SDnodeObj *pDnode);
+void    mnodeUpdateDnode(SDnodeObj *pDnode);
-int32_t mgmtDropDnode(SDnodeObj *pDnode);
+int32_t mnodeDropDnode(SDnodeObj *pDnode);
 
 extern int32_t tsAccessSquence;
 

src/mnode/inc/mnodeInt.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MGMT_LOG_H
+#ifndef TDENGINE_MNODE_LOG_H
-#define TDENGINE_MGMT_LOG_H
+#define TDENGINE_MNODE_LOG_H
 
 #ifdef __cplusplus
 extern "C" {

src/mnode/inc/mnodeMnode.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MGMT_MNODE_H
+#ifndef TDENGINE_MNODE_MNODE_H
-#define TDENGINE_MGMT_MNODE_H
+#define TDENGINE_MNODE_MNODE_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -28,23 +28,25 @@ typedef enum {
   TAOS_MN_STATUS_READY
 } EMnodeStatus;
 
-int32_t mgmtInitMnodes();
+int32_t mnodeInitMnodes();
-void    mgmtCleanupMnodes();
+void    mnodeCleanupMnodes();
 
-int32_t mgmtAddMnode(int32_t dnodeId);
+int32_t mnodeAddMnode(int32_t dnodeId);
-int32_t mgmtDropMnode(int32_t dnodeId);
+int32_t mnodeDropMnode(int32_t dnodeId);
-void    mgmtDropMnodeLocal(int32_t dnodeId);
+void    mnodeDropMnodeLocal(int32_t dnodeId);
 
-void *  mgmtGetMnode(int32_t mnodeId);
+void *  mnodeGetMnode(int32_t mnodeId);
-int32_t mgmtGetMnodesNum();
+int32_t mnodeGetMnodesNum();
-void *  mgmtGetNextMnode(void *pIter, struct SMnodeObj **pMnode);
+void *  mnodeGetNextMnode(void *pIter, struct SMnodeObj **pMnode);
-void    mgmtIncMnodeRef(struct SMnodeObj *pMnode);
+void    mnodeIncMnodeRef(struct SMnodeObj *pMnode);
-void    mgmtDecMnodeRef(struct SMnodeObj *pMnode);
+void    mnodeDecMnodeRef(struct SMnodeObj *pMnode);
 
-char *  mgmtGetMnodeRoleStr();
+char *  mnodeGetMnodeRoleStr();
-void    mgmtGetMnodeIpSet(SRpcIpSet *ipSet);
+void    mnodeGetMnodeIpSetForPeer(SRpcIpSet *ipSet);
-void    mgmtGetMnodeInfos(void *mnodes);
+void    mnodeGetMnodeIpSetForShell(SRpcIpSet *ipSet);
-void    mgmtUpdateMnodeIpSet();
+
+void    mnodeGetMnodeInfos(void *mnodes);
+void    mnodeUpdateMnodeIpSet();
 
 #ifdef __cplusplus
 }

src/mnode/inc/mnodePeer.h

@@ -0,0 +1,33 @@
+/*
+ * 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 TDENGINE_MNODE_PEER_H
+#define TDENGINE_MNODE_PEER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "mnodeDef.h"
+
+void    mnodeAddPeerRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg));
+void    mnodeAddPeerMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg));
+int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg);
+void    mnodeProcessPeerRsp(SRpcMsg *pMsg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/mnode/inc/mnodeProfile.h

@@ -13,16 +13,16 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MGMT_PROFILE_H
+#ifndef TDENGINE_MNODE_PROFILE_H
-#define TDENGINE_MGMT_PROFILE_H
+#define TDENGINE_MNODE_PROFILE_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "mgmtDef.h"
+#include "mnodeDef.h"
 
-int32_t mgmtInitProfile();
+int32_t mnodeInitProfile();
-void    mgmtCleanUpProfile();
+void    mnodeCleanupProfile();
 
 #ifdef __cplusplus
 }

src/mnode/inc/mnodeRead.h

@@ -13,15 +13,16 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MGMT_DSERVER_H
+#ifndef TDENGINE_MNODE_READ_H
-#define TDENGINE_MGMT_DSERVER_H
+#define TDENGINE_MNODE_READ_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
+#include "mnodeDef.h"
 
-int32_t mgmtInitServer();
+void    mnodeAddReadMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg));
-void    mgmtCleanupServer();
+int32_t mnodeProcessRead(SMnodeMsg *pMsg);
 
 #ifdef __cplusplus
 }

src/mnode/inc/mnodeShow.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 TDENGINE_MNODE_SHELL_H
+#define TDENGINE_MNODE_SHELL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "mnodeDef.h"
+
+int32_t mnodeInitShow();
+void    mnodeCleanUpShow();
+
+typedef int32_t (*SShowMetaFp)(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
+typedef int32_t (*SShowRetrieveFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn);
+void mnodeAddShowMetaHandle(uint8_t showType, SShowMetaFp fp);
+void mnodeAddShowRetrieveHandle(uint8_t showType, SShowRetrieveFp fp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/mnode/inc/mnodeTable.h

@@ -20,18 +20,18 @@
 extern "C" {
 #endif
 
-#include "mgmtDef.h"
+#include "mnodeDef.h"
 
-int32_t mgmtInitTables();
+int32_t mnodeInitTables();
-void    mgmtCleanUpTables();
+void    mnodeCleanupTables();
-void *  mgmtGetTable(char *tableId);
+void *  mnodeGetTable(char *tableId);
-void    mgmtIncTableRef(void *pTable);
+void    mnodeIncTableRef(void *pTable);
-void    mgmtDecTableRef(void *pTable);
+void    mnodeDecTableRef(void *pTable);
-void *  mgmtGetNextChildTable(void *pIter, SChildTableObj **pTable);
+void *  mnodeGetNextChildTable(void *pIter, SChildTableObj **pTable);
-void *  mgmtGetNextSuperTable(void *pIter, SSuperTableObj **pTable);
+void *  mnodeGetNextSuperTable(void *pIter, SSuperTableObj **pTable);
-void    mgmtDropAllChildTables(SDbObj *pDropDb);
+void    mnodeDropAllChildTables(SDbObj *pDropDb);
-void    mgmtDropAllSuperTables(SDbObj *pDropDb);
+void    mnodeDropAllSuperTables(SDbObj *pDropDb);
-void    mgmtDropAllChildTablesInVgroups(SVgObj *pVgroup);
+void    mnodeDropAllChildTablesInVgroups(SVgObj *pVgroup);
 
 #ifdef __cplusplus
 }

src/mnode/inc/mnodeUser.h

@@ -0,0 +1,38 @@
+/*
+ * 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 TDENGINE_MNODE_USER_H
+#define TDENGINE_MNODE_USER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "mnodeDef.h"
+
+int32_t   mnodeInitUsers();
+void      mnodeCleanupUsers();
+SUserObj *mnodeGetUser(char *name);
+void *    mnodeGetNextUser(void *pIter, SUserObj **pUser);
+void      mnodeIncUserRef(SUserObj *pUser);
+void      mnodeDecUserRef(SUserObj *pUser);
+SUserObj *mnodeGetUserFromConn(void *pConn);
+int32_t   mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass);
+void      mnodeDropAllUsers(SAcctObj *pAcct);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/mnode/inc/mnodeVgroup.h

@@ -0,0 +1,57 @@
+/*
+ * 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 TDENGINE_MNODE_VGROUP_H
+#define TDENGINE_MNODE_VGROUP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct SMnodeMsg;
+
+int32_t mnodeInitVgroups();
+void    mnodeCleanupVgroups();
+SVgObj *mnodeGetVgroup(int32_t vgId);
+void    mnodeIncVgroupRef(SVgObj *pVgroup);
+void    mnodeDecVgroupRef(SVgObj *pVgroup);
+void    mnodeDropAllDbVgroups(SDbObj *pDropDb);
+void    mnodeSendDropAllDbVgroupsMsg(SDbObj *pDropDb);
+void    mnodeDropAllDnodeVgroups(SDnodeObj *pDropDnode);
+void    mnodeUpdateAllDbVgroups(SDbObj *pAlterDb);
+
+void *  mnodeGetNextVgroup(void *pIter, SVgObj **pVgroup);
+void    mnodeUpdateVgroup(SVgObj *pVgroup);
+void    mnodeUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *dnodeId, SVnodeLoad *pVload);
+
+int32_t mnodeCreateVgroup(struct SMnodeMsg *pMsg, SDbObj *pDb);
+void    mnodeDropVgroup(SVgObj *pVgroup, void *ahandle);
+void    mnodeAlterVgroup(SVgObj *pVgroup, void *ahandle);
+SVgObj *mnodeGetAvailableVgroup(SDbObj *pDb);
+
+void    mnodeAddTableIntoVgroup(SVgObj *pVgroup, SChildTableObj *pTable);
+void    mnodeRemoveTableFromVgroup(SVgObj *pVgroup, SChildTableObj *pTable);
+void    mnodeSendCreateVnodeMsg(SVgObj *pVgroup, SRpcIpSet *ipSet, void *ahandle);
+void    mnodeSendDropVnodeMsg(int32_t vgId, SRpcIpSet *ipSet, void *ahandle);
+void    mnodeSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle);
+
+SRpcIpSet mnodeGetIpSetFromVgroup(SVgObj *pVgroup);
+SRpcIpSet mnodeGetIpSetFromIp(char *ep);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/mnode/inc/mnodeWrite.h

@@ -0,0 +1,31 @@
+/*
+ * 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 TDENGINE_MNODE_WRITE_H
+#define TDENGINE_MNODE_WRITE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "mnodeDef.h"
+
+void    mnodeAddWriteMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg));
+int32_t mnodeProcessRead(SMnodeMsg *pMsg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/mnode/src/mgmtServer.c

@@ -1,106 +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 "os.h"
-#include "taoserror.h"
-#include "trpc.h"
-#include "tsched.h"
-#include "tsystem.h"
-#include "tutil.h"
-#include "tgrant.h"
-#include "tbalance.h"
-#include "tglobal.h"
-#include "dnode.h"
-#include "mgmtDef.h"
-#include "mgmtInt.h"
-#include "mgmtDb.h"
-#include "mgmtMnode.h"
-#include "mgmtProfile.h"
-#include "mgmtShell.h"
-#include "mgmtSdb.h"
-#include "mgmtTable.h"
-#include "mgmtVgroup.h"
-
-static void (*mgmtProcessDnodeMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *rpcMsg);
-static void  *tsMgmtServerQhandle = NULL;
-
-int32_t mgmtInitServer() {
-
-  tsMgmtServerQhandle = taosInitScheduler(tsMaxShellConns, 1, "MS");
-
-  mPrint("server connection to dnode is opened");
-  return 0;
-}
-
-void mgmtCleanupServer() {
-  if (tsMgmtServerQhandle) {
-    taosCleanUpScheduler(tsMgmtServerQhandle);
-    tsMgmtServerQhandle = NULL;
-  }
-}
-
-void dnodeAddServerMsgHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)) {
-  mgmtProcessDnodeMsgFp[msgType] = fp;
-}
-
-static void mgmtProcessRequestFromDnode(SSchedMsg *sched) {
-  SRpcMsg *pMsg = sched->msg;
-  (*mgmtProcessDnodeMsgFp[pMsg->msgType])(pMsg);
-  rpcFreeCont(pMsg->pCont);
-  free(pMsg);
-}
-
-static void mgmtAddToServerQueue(SRpcMsg *pMsg) {
-  SSchedMsg schedMsg;
-  schedMsg.msg = pMsg;
-  schedMsg.fp  = mgmtProcessRequestFromDnode;
-  taosScheduleTask(tsMgmtServerQhandle, &schedMsg);
-}
-
-void mgmtProcessReqMsgFromDnode(SRpcMsg *rpcMsg) {
-  if (mgmtProcessDnodeMsgFp[rpcMsg->msgType] == NULL) {
-    mError("%s is not processed in mnode", taosMsg[rpcMsg->msgType]);
-    mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_MSG_NOT_PROCESSED);
-    rpcFreeCont(rpcMsg->pCont);
-  }
-
-  if (rpcMsg->pCont == NULL) {
-    mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_INVALID_MSG_LEN);
-    return;
-  }
-
-  if (!sdbIsMaster()) {
-    SRpcConnInfo connInfo;
-    rpcGetConnInfo(rpcMsg->handle, &connInfo);
-    
-    SRpcIpSet ipSet = {0};
-    dnodeGetMnodeDnodeIpSet(&ipSet);
-    for (int i = 0; i < ipSet.numOfIps; ++i) 
-      ipSet.port[i] = htons(ipSet.port[i]);
-    
-    mTrace("conn from dnode ip:%s user:%s redirect msg, inUse:%d", taosIpStr(connInfo.clientIp), connInfo.user, ipSet.inUse);
-    for (int32_t i = 0; i < ipSet.numOfIps; ++i) {
-      mTrace("mnode index:%d %s:%d", i, ipSet.fqdn[i], htons(ipSet.port[i]));
-    }
-    rpcSendRedirectRsp(rpcMsg->handle, &ipSet);
-    return;
-  }
-  
-  SRpcMsg *pMsg = malloc(sizeof(SRpcMsg));
-  memcpy(pMsg, rpcMsg, sizeof(SRpcMsg));
-  mgmtAddToServerQueue(pMsg);
-}
-

src/mnode/src/mgmtShell.c

@@ -1,561 +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 "os.h"
-#include "taosmsg.h"
-#include "taoserror.h"
-#include "trpc.h"
-#include "tsched.h"
-#include "tutil.h"
-#include "ttimer.h"
-#include "tgrant.h"
-#include "tglobal.h"
-#include "tcache.h"
-#include "dnode.h"
-#include "mgmtDef.h"
-#include "mgmtInt.h"
-#include "mgmtAcct.h"
-#include "mgmtDb.h"
-#include "mgmtDnode.h"
-#include "mgmtMnode.h"
-#include "mgmtProfile.h"
-#include "mgmtSdb.h"
-#include "mgmtShell.h"
-#include "mgmtTable.h"
-#include "mgmtUser.h"
-#include "mgmtVgroup.h"
-
-typedef int32_t (*SShowMetaFp)(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-typedef int32_t (*SShowRetrieveFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-
-static bool mgmtCheckMsgReadOnly(SQueuedMsg *pMsg);
-static void mgmtProcessUnSupportMsg(SRpcMsg *rpcMsg);
-static void mgmtProcessShowMsg(SQueuedMsg *queuedMsg);
-static void mgmtProcessRetrieveMsg(SQueuedMsg *queuedMsg);
-static void mgmtProcessHeartBeatMsg(SQueuedMsg *queuedMsg);
-static void mgmtProcessConnectMsg(SQueuedMsg *queuedMsg);
-static void mgmtProcessUseMsg(SQueuedMsg *queuedMsg);
-static void mgmtFreeShowObj(void *data);
-
-void *tsMgmtTmr;
-static void *tsMgmtTranQhandle = NULL;
-static void (*tsMgmtProcessShellMsgFp[TSDB_MSG_TYPE_MAX])(SQueuedMsg *) = {0};
-static void *tsQhandleCache = NULL;
-static SShowMetaFp     tsMgmtShowMetaFp[TSDB_MGMT_TABLE_MAX]     = {0};
-static SShowRetrieveFp tsMgmtShowRetrieveFp[TSDB_MGMT_TABLE_MAX] = {0};
-
-int32_t mgmtInitShell() {
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_SHOW, mgmtProcessShowMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_RETRIEVE, mgmtProcessRetrieveMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_HEARTBEAT, mgmtProcessHeartBeatMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CONNECT, mgmtProcessConnectMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_USE_DB, mgmtProcessUseMsg);
-  
-  tsMgmtTmr = taosTmrInit((tsMaxShellConns) * 3, 200, 3600000, "MND");
-  tsMgmtTranQhandle = taosInitScheduler(tsMaxShellConns, 1, "mnodeT");
-  tsQhandleCache = taosCacheInitWithCb(tsMgmtTmr, 10, mgmtFreeShowObj);
-
-  return 0;
-}
-
-void mgmtCleanUpShell() {
-  if (tsMgmtTmr != NULL){
-    taosTmrCleanUp(tsMgmtTmr);
-    tsMgmtTmr = NULL;
-  }
-
-  if (tsQhandleCache != NULL) {
-    taosCacheCleanup(tsQhandleCache);
-    tsQhandleCache = NULL;
-  }
-  
-  if (tsMgmtTranQhandle != NULL) {
-    taosCleanUpScheduler(tsMgmtTranQhandle);
-    tsMgmtTranQhandle = NULL;
-  }
-}
-
-void mgmtAddShellMsgHandle(uint8_t showType, void (*fp)(SQueuedMsg *queuedMsg)) {
-  tsMgmtProcessShellMsgFp[showType] = fp;
-}
-
-void mgmtAddShellShowMetaHandle(uint8_t showType, SShowMetaFp fp) {
-  tsMgmtShowMetaFp[showType] = fp;
-}
-
-void mgmtAddShellShowRetrieveHandle(uint8_t msgType, SShowRetrieveFp fp) {
-  tsMgmtShowRetrieveFp[msgType] = fp;
-}
-
-void mgmtProcessTranRequest(SSchedMsg *sched) {
-  SQueuedMsg *queuedMsg = sched->msg;
-  (*tsMgmtProcessShellMsgFp[queuedMsg->msgType])(queuedMsg);
-  mgmtFreeQueuedMsg(queuedMsg);
-}
-
-void mgmtAddToShellQueue(SQueuedMsg *queuedMsg) {
-  SSchedMsg schedMsg;
-  schedMsg.msg = queuedMsg;
-  schedMsg.fp  = mgmtProcessTranRequest;
-  taosScheduleTask(tsMgmtTranQhandle, &schedMsg);
-}
-
-static void mgmtDoDealyedAddToShellQueue(void *param, void *tmrId) {
-  mgmtAddToShellQueue(param);
-}
-
-void mgmtDealyedAddToShellQueue(SQueuedMsg *queuedMsg) {
-  void *unUsed = NULL;
-  taosTmrReset(mgmtDoDealyedAddToShellQueue, 300, queuedMsg, tsMgmtTmr, &unUsed);
-}
-
-void mgmtProcessMsgFromShell(SRpcMsg *rpcMsg) {
-
-  mTrace("%p, msg:%s will be processed", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]);
-
-  if (rpcMsg->pCont == NULL) {
-    mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_INVALID_MSG_LEN);
-    return;
-  }
-
-  if (!sdbIsMaster()) {
-    SRpcConnInfo connInfo;
-    rpcGetConnInfo(rpcMsg->handle, &connInfo);
-    
-    SRpcIpSet ipSet = {0};
-    mgmtGetMnodeIpSet(&ipSet);
-    mTrace("conn from shell ip:%s user:%s redirect msg, inUse:%d", taosIpStr(connInfo.clientIp), connInfo.user, ipSet.inUse);
-    for (int32_t i = 0; i < ipSet.numOfIps; ++i) {
-      mTrace("mnode index:%d ip:%s:%d", i, ipSet.fqdn[i], htons(ipSet.port[i]));
-    }
-
-    rpcSendRedirectRsp(rpcMsg->handle, &ipSet);
-    return;
-  }
-
-  if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
-    mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_GRANT_EXPIRED);
-    rpcFreeCont(rpcMsg->pCont);
-    return;
-  }
-
-  if (tsMgmtProcessShellMsgFp[rpcMsg->msgType] == NULL) {
-    mgmtProcessUnSupportMsg(rpcMsg);
-    rpcFreeCont(rpcMsg->pCont);
-    return;
-  }
-
-  SQueuedMsg *pMsg = mgmtMallocQueuedMsg(rpcMsg);
-  if (pMsg == NULL) {
-    mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_INVALID_USER);
-    rpcFreeCont(rpcMsg->pCont);
-    return;
-  }
-  
-  if (mgmtCheckMsgReadOnly(pMsg)) {
-    (*tsMgmtProcessShellMsgFp[rpcMsg->msgType])(pMsg);
-    mgmtFreeQueuedMsg(pMsg);
-  } else {
-    if (!pMsg->pUser->writeAuth) {
-      mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS);
-      mgmtFreeQueuedMsg(pMsg);
-    } else {
-      mgmtAddToShellQueue(pMsg);
-    }
-  }
-}
-
-char *mgmtGetShowTypeStr(int32_t showType) {
-  switch (showType) {
-    case TSDB_MGMT_TABLE_ACCT:    return "show accounts";
-    case TSDB_MGMT_TABLE_USER:    return "show users";
-    case TSDB_MGMT_TABLE_DB:      return "show databases";
-    case TSDB_MGMT_TABLE_TABLE:   return "show tables";
-    case TSDB_MGMT_TABLE_DNODE:   return "show dnodes";
-    case TSDB_MGMT_TABLE_MNODE:   return "show mnodes";
-    case TSDB_MGMT_TABLE_VGROUP:  return "show vgroups";
-    case TSDB_MGMT_TABLE_METRIC:  return "show stables";
-    case TSDB_MGMT_TABLE_MODULE:  return "show modules";
-    case TSDB_MGMT_TABLE_QUERIES: return "show queries";
-    case TSDB_MGMT_TABLE_STREAMS: return "show streams";
-    case TSDB_MGMT_TABLE_CONFIGS: return "show configs";
-    case TSDB_MGMT_TABLE_CONNS:   return "show connections";
-    case TSDB_MGMT_TABLE_SCORES:  return "show scores";
-    case TSDB_MGMT_TABLE_GRANTS:  return "show grants";
-    case TSDB_MGMT_TABLE_VNODES:  return "show vnodes";
-    default:                      return "undefined";
-  }
-}
-
-static void mgmtProcessShowMsg(SQueuedMsg *pMsg) {
-  SCMShowMsg *pShowMsg = pMsg->pCont;
-  if (pShowMsg->type >= TSDB_MGMT_TABLE_MAX) {
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_MSG_TYPE);
-    return;
-  }
-
-  if (!tsMgmtShowMetaFp[pShowMsg->type] || !tsMgmtShowRetrieveFp[pShowMsg->type]) {
-    mError("show type:%s is not support", mgmtGetShowTypeStr(pShowMsg->type));
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_OPS_NOT_SUPPORT);
-    return;
-  }
-
-  int32_t size = sizeof(SCMShowRsp) + sizeof(SSchema) * TSDB_MAX_COLUMNS + TSDB_EXTRA_PAYLOAD_SIZE;
-  SCMShowRsp *pShowRsp = rpcMallocCont(size);
-  if (pShowRsp == NULL) {
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY);
-    return;
-  }
-
-  int32_t showObjSize = sizeof(SShowObj) + htons(pShowMsg->payloadLen);
-  SShowObj *pShow = (SShowObj *) calloc(1, showObjSize);
-  pShow->signature  = pShow;
-  pShow->type       = pShowMsg->type;
-  pShow->payloadLen = htons(pShowMsg->payloadLen);
-  strcpy(pShow->db, pShowMsg->db);
-  memcpy(pShow->payload, pShowMsg->payload, pShow->payloadLen);
-
-  pShow = mgmtSaveQhandle(pShow, showObjSize);
-  pShowRsp->qhandle = htobe64((uint64_t) pShow);
-
-  mTrace("show:%p, type:%s, start to get meta", pShow, mgmtGetShowTypeStr(pShowMsg->type));
-  int32_t code = (*tsMgmtShowMetaFp[pShowMsg->type])(&pShowRsp->tableMeta, pShow, pMsg->thandle);
-  if (code == 0) {
-    SRpcMsg rpcRsp = {
-      .handle  = pMsg->thandle,
-      .pCont   = pShowRsp,
-      .contLen = sizeof(SCMShowRsp) + sizeof(SSchema) * pShow->numOfColumns,
-      .code    = code
-    };
-    rpcSendResponse(&rpcRsp);
-  } else {
-    mError("show:%p, type:%s, failed to get meta, reason:%s", pShow, mgmtGetShowTypeStr(pShowMsg->type), tstrerror(code));
-    mgmtFreeQhandle(pShow, false);
-    SRpcMsg rpcRsp = {
-      .handle = pMsg->thandle,
-      .code   = code
-    };
-    rpcSendResponse(&rpcRsp);
-  }
-}
-
-static void mgmtProcessRetrieveMsg(SQueuedMsg *pMsg) {
-  int32_t rowsToRead = 0;
-  int32_t size = 0;
-  int32_t rowsRead = 0;
-  SRetrieveTableMsg *pRetrieve = pMsg->pCont;
-  pRetrieve->qhandle = htobe64(pRetrieve->qhandle);
-
-  /*
-   * in case of server restart, apps may hold qhandle created by server before
-   * restart, which is actually invalid, therefore, signature check is required.
-   */
-  if (!mgmtCheckQhandle(pRetrieve->qhandle)) {
-    mError("retrieve:%p, qhandle:%p is invalid", pRetrieve, pRetrieve->qhandle);
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_QHANDLE);
-    return;
-  }
-
-  SShowObj *pShow = (SShowObj *)pRetrieve->qhandle;
-  mTrace("show:%p, type:%s, retrieve data", pShow, mgmtGetShowTypeStr(pShow->type));
-
-  if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) {
-    rowsToRead = pShow->numOfRows - pShow->numOfReads;
-  }
-
-  /* return no more than 100 meters in one round trip */
-  if (rowsToRead > 100) rowsToRead = 100;
-
-  /*
-   * the actual number of table may be larger than the value of pShow->numOfRows, if a query is
-   * issued during a continuous create table operation. Therefore, rowToRead may be less than 0.
-   */
-  if (rowsToRead < 0) rowsToRead = 0;
-  size = pShow->rowSize * rowsToRead;
-
-  size += 100;
-  SRetrieveTableRsp *pRsp = rpcMallocCont(size);
-
-  // if free flag is set, client wants to clean the resources
-  if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE)
-    rowsRead = (*tsMgmtShowRetrieveFp[pShow->type])(pShow, pRsp->data, rowsToRead, pMsg->thandle);
-
-  if (rowsRead < 0) {  // TSDB_CODE_ACTION_IN_PROGRESS;
-    rpcFreeCont(pRsp);
-    mgmtFreeQhandle(pShow, false);
-    return;
-  }
-
-  pRsp->numOfRows = htonl(rowsRead);
-  pRsp->precision = htonl(TSDB_TIME_PRECISION_MILLI);  // millisecond time precision
-
-  SRpcMsg rpcRsp = {
-      .handle  = pMsg->thandle,
-      .pCont   = pRsp,
-      .contLen = size,
-      .code    = 0,
-      .msgType = 0
-  };
-  rpcSendResponse(&rpcRsp);
-
-  if (rowsToRead == 0) {
-    mgmtFreeQhandle(pShow, true);
-  } else {
-    mgmtFreeQhandle(pShow, false);
-  }
-}
-
-static void mgmtProcessHeartBeatMsg(SQueuedMsg *pMsg) {
-  SCMHeartBeatRsp *pHBRsp = (SCMHeartBeatRsp *) rpcMallocCont(sizeof(SCMHeartBeatRsp));
-  if (pHBRsp == NULL) {
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY);
-    return;
-  }
-
-  pHBRsp->onlineDnodes = htonl(mgmtGetOnlinDnodesNum());
-  pHBRsp->totalDnodes = htonl(mgmtGetDnodesNum());
-  mgmtGetMnodeIpSet(&pHBRsp->ipList);
-  
-  /*
-   * TODO
-   * Dispose kill stream or kill query message
-   */
-  pHBRsp->queryId = 0;
-  pHBRsp->streamId = 0;
-  pHBRsp->killConnection = 0;
-
-  SRpcMsg rpcRsp = {
-      .handle  = pMsg->thandle,
-      .pCont   = pHBRsp,
-      .contLen = sizeof(SCMHeartBeatRsp),
-      .code    = 0,
-      .msgType = 0
-  };
-  rpcSendResponse(&rpcRsp);
-}
-
-static void mgmtProcessConnectMsg(SQueuedMsg *pMsg) {
-  SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
-  SCMConnectMsg *pConnectMsg = pMsg->pCont;
-
-  SRpcConnInfo connInfo;
-  if (rpcGetConnInfo(pMsg->thandle, &connInfo) != 0) {
-    mError("thandle:%p is already released while process connect msg", pMsg->thandle);
-    return;
-  }
-
-  int32_t code;
-  if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
-    code = TSDB_CODE_GRANT_EXPIRED;
-    goto connect_over;
-  }
-
-  code = taosCheckVersion(pConnectMsg->clientVersion, version, 3);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto connect_over;
-  }
-
-  SUserObj *pUser = pMsg->pUser;
-  SAcctObj *pAcct = pUser->pAcct;
-
-  if (pConnectMsg->db[0]) {
-    char dbName[TSDB_TABLE_ID_LEN * 3] = {0};
-    sprintf(dbName, "%x%s%s", pAcct->acctId, TS_PATH_DELIMITER, pConnectMsg->db);
-    SDbObj *pDb = mgmtGetDb(dbName);
-    if (pDb == NULL) {
-      code = TSDB_CODE_INVALID_DB;
-      goto connect_over;
-    }
-    mgmtDecDbRef(pDb);
-  }
-
-  SCMConnectRsp *pConnectRsp = rpcMallocCont(sizeof(SCMConnectRsp));
-  if (pConnectRsp == NULL) {
-    code = TSDB_CODE_SERV_OUT_OF_MEMORY;
-    goto connect_over;
-  }
-
-  sprintf(pConnectRsp->acctId, "%x", pAcct->acctId);
-  strcpy(pConnectRsp->serverVersion, version);
-  pConnectRsp->writeAuth = pUser->writeAuth;
-  pConnectRsp->superAuth = pUser->superAuth;
-
-  mgmtGetMnodeIpSet(&pConnectRsp->ipList);
-  
-connect_over:
-  rpcRsp.code = code;
-  if (code != TSDB_CODE_SUCCESS) {
-    mLError("user:%s login from %s, result:%s", connInfo.user, taosIpStr(connInfo.clientIp), tstrerror(code));
-  } else {
-    mLPrint("user:%s login from %s, result:%s", connInfo.user, taosIpStr(connInfo.clientIp), tstrerror(code));
-    rpcRsp.pCont   = pConnectRsp;
-    rpcRsp.contLen = sizeof(SCMConnectRsp);
-  }
-  rpcSendResponse(&rpcRsp);
-}
-
-static void mgmtProcessUseMsg(SQueuedMsg *pMsg) {
-  SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
-  
-  SCMUseDbMsg *pUseDbMsg = pMsg->pCont;
-  
-  // todo check for priority of current user
-  int32_t code = TSDB_CODE_SUCCESS;
-  if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDb(pUseDbMsg->db);
-  if (pMsg->pDb == NULL) {
-    code = TSDB_CODE_INVALID_DB;
-  }
-  
-  rpcRsp.code = code;
-  rpcSendResponse(&rpcRsp);
-}
-
-/**
- * check if we need to add mgmtProcessTableMetaMsg into tranQueue, which will be executed one-by-one.
- */
-static bool mgmtCheckTableMetaMsgReadOnly(SQueuedMsg *pMsg) {
-  SCMTableInfoMsg *pInfo = pMsg->pCont;
-  if (pMsg->pTable == NULL) pMsg->pTable = mgmtGetTable(pInfo->tableId);
-  if (pMsg->pTable != NULL) return true;
-
-  // If table does not exists and autoCreate flag is set, we add the handler into task queue
-  int16_t autoCreate = htons(pInfo->createFlag);
-  if (autoCreate == 1) {
-    mTrace("table:%s auto created task added", pInfo->tableId);
-    return false;
-  }
-  
-  return true;
-}
-
-static bool mgmtCheckMsgReadOnly(SQueuedMsg *pMsg) {
-  if (pMsg->msgType == TSDB_MSG_TYPE_CM_TABLE_META) {
-    return mgmtCheckTableMetaMsgReadOnly(pMsg);
-  }
-
-  if (pMsg->msgType == TSDB_MSG_TYPE_CM_STABLE_VGROUP || pMsg->msgType == TSDB_MSG_TYPE_CM_RETRIEVE    ||
-      pMsg->msgType == TSDB_MSG_TYPE_CM_SHOW          || pMsg->msgType == TSDB_MSG_TYPE_CM_TABLES_META ||
-      pMsg->msgType == TSDB_MSG_TYPE_CM_CONNECT) {
-    return true;
-  }
-
-  return false;
-}
-
-static void mgmtProcessUnSupportMsg(SRpcMsg *rpcMsg) {
-  mError("%s is not processed in mnode shell", taosMsg[rpcMsg->msgType]);
-  SRpcMsg rpcRsp = {
-    .msgType = 0,
-    .pCont   = 0,
-    .contLen = 0,
-    .code    = TSDB_CODE_OPS_NOT_SUPPORT,
-    .handle  = rpcMsg->handle
-  };
-  rpcSendResponse(&rpcRsp);
-}
-
-void mgmtSendSimpleResp(void *thandle, int32_t code) {
-  SRpcMsg rpcRsp = {
-      .msgType = 0,
-      .pCont   = 0,
-      .contLen = 0,
-      .code    = code,
-      .handle  = thandle
-  };
-  rpcSendResponse(&rpcRsp);
-}
-
-bool mgmtCheckQhandle(uint64_t qhandle) {
-  void *pSaved = taosCacheAcquireByData(tsQhandleCache, (void *)qhandle);
-  if (pSaved == (void *)qhandle) {
-    mTrace("show:%p, is retrieved", qhandle);
-    return true;
-  } else {
-    mTrace("show:%p, is already released", qhandle);
-    return false;
-  }
-}
-
-void* mgmtSaveQhandle(void *qhandle, int32_t size) {
-  if (tsQhandleCache != NULL) {
-    char key[24];
-    sprintf(key, "show:%p", qhandle);
-    void *newQhandle = taosCachePut(tsQhandleCache, key, qhandle, size, 60);
-    free(qhandle);
-    
-    mTrace("show:%p, is saved", newQhandle);
-    return newQhandle;
-  }
-  
-  return NULL;
-}
-
-static void mgmtFreeShowObj(void *data) {
-  SShowObj *pShow = data;
-  sdbFreeIter(pShow->pIter);
-  mTrace("show:%p, is destroyed", pShow);
-}
-
-void mgmtFreeQhandle(void *qhandle, bool forceRemove) {
-  mTrace("show:%p, is released, force:%s", qhandle, forceRemove ? "true" : "false");
-  taosCacheRelease(tsQhandleCache, &qhandle, forceRemove);
-}
-
-void *mgmtMallocQueuedMsg(SRpcMsg *rpcMsg) {
-  SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle);
-  if (pUser == NULL) {
-    return NULL;
-  }
-
-  SQueuedMsg *pMsg = calloc(1, sizeof(SQueuedMsg));
-  pMsg->thandle = rpcMsg->handle;
-  pMsg->msgType = rpcMsg->msgType;
-  pMsg->contLen = rpcMsg->contLen;
-  pMsg->pCont = rpcMsg->pCont;
-  pMsg->pUser = pUser;
-
-  return pMsg;
-}
-
-void mgmtFreeQueuedMsg(SQueuedMsg *pMsg) {
-  if (pMsg != NULL) {
-    rpcFreeCont(pMsg->pCont);
-    if (pMsg->pUser) mgmtDecUserRef(pMsg->pUser);
-    if (pMsg->pDb) mgmtDecDbRef(pMsg->pDb);
-    if (pMsg->pVgroup) mgmtDecVgroupRef(pMsg->pVgroup);
-    if (pMsg->pTable) mgmtDecTableRef(pMsg->pTable);
-    if (pMsg->pAcct) mgmtDecAcctRef(pMsg->pAcct);
-    if (pMsg->pDnode) mgmtDecDnodeRef(pMsg->pDnode);
-    free(pMsg);
-  }
-}
-
-void* mgmtCloneQueuedMsg(SQueuedMsg *pSrcMsg) {
-  SQueuedMsg *pDestMsg = calloc(1, sizeof(SQueuedMsg));
-  
-  pDestMsg->thandle = pSrcMsg->thandle;
-  pDestMsg->msgType = pSrcMsg->msgType;
-  pDestMsg->pCont   = pSrcMsg->pCont;
-  pDestMsg->contLen = pSrcMsg->contLen;
-  pDestMsg->retry   = pSrcMsg->retry;
-  pDestMsg->maxRetry= pSrcMsg->maxRetry;
-  pDestMsg->pUser   = pSrcMsg->pUser;
- 
-  pSrcMsg->pCont = NULL;
-  pSrcMsg->pUser = NULL;
-  
-  return pDestMsg;
-}

src/mnode/src/mnodeAcct.c

@@ -17,59 +17,58 @@
 #include "os.h"
 #include "taoserror.h"
 #include "ttime.h"
-#include "tutil.h"
 #include "dnode.h"
-#include "mgmtDef.h"
+#include "mnodeDef.h"
-#include "mgmtInt.h"
+#include "mnodeInt.h"
-#include "mgmtAcct.h"
+#include "mnodeAcct.h"
-#include "mgmtDb.h"
+#include "mnodeDb.h"
-#include "mgmtSdb.h"
+#include "mnodeSdb.h"
-#include "mgmtUser.h"
+#include "mnodeUser.h"
 
 void *  tsAcctSdb = NULL;
 static int32_t tsAcctUpdateSize;
-static void    mgmtCreateRootAcct();
+static void    mnodeCreateRootAcct();
 
-static int32_t mgmtActionAcctDestroy(SSdbOper *pOper) {
+static int32_t mnodeAcctActionDestroy(SSdbOper *pOper) {
   SAcctObj *pAcct = pOper->pObj;
   pthread_mutex_destroy(&pAcct->mutex);
   tfree(pOper->pObj);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtAcctActionInsert(SSdbOper *pOper) {
+static int32_t mnodeAcctActionInsert(SSdbOper *pOper) {
   SAcctObj *pAcct = pOper->pObj;
   memset(&pAcct->acctInfo, 0, sizeof(SAcctInfo));
   pthread_mutex_init(&pAcct->mutex, NULL);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtActionAcctDelete(SSdbOper *pOper) {
+static int32_t mnodeAcctActionDelete(SSdbOper *pOper) {
   SAcctObj *pAcct = pOper->pObj;
-  mgmtDropAllUsers(pAcct);
+  mnodeDropAllUsers(pAcct);
-  mgmtDropAllDbs(pAcct);
+  mnodeDropAllDbs(pAcct);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtActionAcctUpdate(SSdbOper *pOper) {
+static int32_t mnodeAcctActionUpdate(SSdbOper *pOper) {
   SAcctObj *pAcct = pOper->pObj;
-  SAcctObj *pSaved = mgmtGetAcct(pAcct->user);
+  SAcctObj *pSaved = mnodeGetAcct(pAcct->user);
   if (pAcct != pSaved) {
     memcpy(pSaved, pAcct, tsAcctUpdateSize);
     free(pAcct);
   }
-  mgmtDecAcctRef(pSaved);
+  mnodeDecAcctRef(pSaved);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtActionActionEncode(SSdbOper *pOper) {
+static int32_t mnodeActionActionEncode(SSdbOper *pOper) {
   SAcctObj *pAcct = pOper->pObj;
   memcpy(pOper->rowData, pAcct, tsAcctUpdateSize);
   pOper->rowSize = tsAcctUpdateSize;
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtActionAcctDecode(SSdbOper *pOper) {
+static int32_t mnodeAcctActionDecode(SSdbOper *pOper) {
   SAcctObj *pAcct = (SAcctObj *) calloc(1, sizeof(SAcctObj));
   if (pAcct == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY;
 
@@ -78,16 +77,16 @@ static int32_t mgmtActionAcctDecode(SSdbOper *pOper) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtActionAcctRestored() {
+static int32_t mnodeAcctActionRestored() {
   if (dnodeIsFirstDeploy()) {
-    mgmtCreateRootAcct();
+    mnodeCreateRootAcct();
   }
 
   acctInit();
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t mgmtInitAccts() {
+int32_t mnodeInitAccts() {
   SAcctObj tObj;
   tsAcctUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
 
@@ -98,13 +97,13 @@ int32_t mgmtInitAccts() {
     .maxRowSize   = tsAcctUpdateSize,
     .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
     .keyType      = SDB_KEY_STRING,
-    .insertFp     = mgmtAcctActionInsert,
+    .insertFp     = mnodeAcctActionInsert,
-    .deleteFp     = mgmtActionAcctDelete,
+    .deleteFp     = mnodeAcctActionDelete,
-    .updateFp     = mgmtActionAcctUpdate,
+    .updateFp     = mnodeAcctActionUpdate,
-    .encodeFp     = mgmtActionActionEncode,
+    .encodeFp     = mnodeActionActionEncode,
-    .decodeFp     = mgmtActionAcctDecode,
+    .decodeFp     = mnodeAcctActionDecode,
-    .destroyFp    = mgmtActionAcctDestroy,
+    .destroyFp    = mnodeAcctActionDestroy,
-    .restoredFp   = mgmtActionAcctRestored
+    .restoredFp   = mnodeAcctActionRestored
   };
 
   tsAcctSdb = sdbOpenTable(&tableDesc);
@@ -117,52 +116,52 @@ int32_t mgmtInitAccts() {
   return TSDB_CODE_SUCCESS;
 }
 
-void mgmtCleanUpAccts() {
+void mnodeCleanupAccts() {
   sdbCloseTable(tsAcctSdb);
   acctCleanUp();
 }
 
-void *mgmtGetAcct(char *name) {
+void *mnodeGetAcct(char *name) {
   return sdbGetRow(tsAcctSdb, name);
 }
 
-void *mgmtGetNextAcct(void *pIter, SAcctObj **pAcct) {
+void *mnodeGetNextAcct(void *pIter, SAcctObj **pAcct) {
   return sdbFetchRow(tsAcctSdb, pIter, (void **)pAcct); 
 }
 
-void mgmtIncAcctRef(SAcctObj *pAcct) {
+void mnodeIncAcctRef(SAcctObj *pAcct) {
   sdbIncRef(tsAcctSdb, pAcct);
 }
 
-void mgmtDecAcctRef(SAcctObj *pAcct) {
+void mnodeDecAcctRef(SAcctObj *pAcct) {
   sdbDecRef(tsAcctSdb, pAcct);
 }
 
-void mgmtAddDbToAcct(SAcctObj *pAcct, SDbObj *pDb) {
+void mnodeAddDbToAcct(SAcctObj *pAcct, SDbObj *pDb) {
   atomic_add_fetch_32(&pAcct->acctInfo.numOfDbs, 1);
   pDb->pAcct = pAcct;
-  mgmtIncAcctRef(pAcct);
+  mnodeIncAcctRef(pAcct);
 }
 
-void mgmtDropDbFromAcct(SAcctObj *pAcct, SDbObj *pDb) {
+void mnodeDropDbFromAcct(SAcctObj *pAcct, SDbObj *pDb) {
   atomic_sub_fetch_32(&pAcct->acctInfo.numOfDbs, 1);
   pDb->pAcct = NULL;
-  mgmtDecAcctRef(pAcct);
+  mnodeDecAcctRef(pAcct);
 }
 
-void mgmtAddUserToAcct(SAcctObj *pAcct, SUserObj *pUser) {
+void mnodeAddUserToAcct(SAcctObj *pAcct, SUserObj *pUser) {
   atomic_add_fetch_32(&pAcct->acctInfo.numOfUsers, 1);
   pUser->pAcct = pAcct;
-  mgmtIncAcctRef(pAcct);
+  mnodeIncAcctRef(pAcct);
 }
 
-void mgmtDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser) {
+void mnodeDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser) {
   atomic_sub_fetch_32(&pAcct->acctInfo.numOfUsers, 1);
   pUser->pAcct = NULL;
-  mgmtDecAcctRef(pAcct);
+  mnodeDecAcctRef(pAcct);
 }
 
-static void mgmtCreateRootAcct() {
+static void mnodeCreateRootAcct() {
   int32_t numOfAccts = sdbGetNumOfRows(tsAcctSdb);
   if (numOfAccts != 0) return;
 

src/mnode/src/mnodeBalance.c

@@ -15,22 +15,18 @@
 
 #define _DEFAULT_SOURCE
 #include "os.h"
-#include "trpc.h"
-#include "tbalance.h"
 #include "tglobal.h"
-#include "mgmtDef.h"
+#include "mnodeDef.h"
-#include "mgmtInt.h"
+#include "mnodeInt.h"
-#include "mgmtMnode.h"
+#include "mnodeDnode.h"
-#include "mgmtDnode.h"
+#include "mnodeSdb.h"
-#include "mgmtSdb.h"
-#include "mgmtVgroup.h"
 
 #ifndef _SYNC
 
 int32_t balanceInit() { return TSDB_CODE_SUCCESS; }
 void    balanceCleanUp() {}
 void    balanceNotify() {}
-void    balanceUpdateMgmt() {}
+void    balanceUpdateMnode() {}
 void    balanceReset() {}
 
 int32_t balanceAllocVnodes(SVgObj *pVgroup) {
@@ -40,12 +36,12 @@ int32_t balanceAllocVnodes(SVgObj *pVgroup) {
   float      vnodeUsage = 1000.0;
 
   while (1) {
-    pIter = mgmtGetNextDnode(pIter, &pDnode);
+    pIter = mnodeGetNextDnode(pIter, &pDnode);
     if (pDnode == NULL) break;
 
     if (pDnode->totalVnodes > 0 && pDnode->openVnodes < pDnode->totalVnodes) {
       float openVnodes = pDnode->openVnodes;
-      if (pDnode->isMgmt) openVnodes += tsMgmtEqualVnodeNum;
+      if (pDnode->isMgmt) openVnodes += tsMnodeEqualVnodeNum;
 
       float usage = openVnodes / pDnode->totalVnodes;
       if (usage <= vnodeUsage) {
@@ -53,7 +49,7 @@ int32_t balanceAllocVnodes(SVgObj *pVgroup) {
         vnodeUsage = usage;
       }
     }
-    mgmtDecDnodeRef(pDnode);
+    mnodeDecDnodeRef(pDnode);
   }
 
   sdbFreeIter(pIter);

src/mnode/src/mnodeDb.c

@@ -15,7 +15,6 @@
 
 #define _DEFAULT_SOURCE
 #include "os.h"
-
 #include "taoserror.h"
 #include "tutil.h"
 #include "tgrant.h"
@@ -24,39 +23,41 @@
 #include "tname.h"
 #include "tbalance.h"
 #include "tdataformat.h"
-#include "mgmtDef.h"
+#include "mnode.h"
-#include "mgmtInt.h"
+#include "mnodeDef.h"
-#include "mgmtAcct.h"
+#include "mnodeInt.h"
-#include "mgmtDb.h"
+#include "mnodeAcct.h"
-#include "mgmtDnode.h"
+#include "mnodeDb.h"
-#include "mgmtMnode.h"
+#include "mnodeDnode.h"
-#include "mgmtShell.h"
+#include "mnodeMnode.h"
-#include "mgmtProfile.h"
+#include "mnodeProfile.h"
-#include "mgmtSdb.h"
+#include "mnodeWrite.h"
-#include "mgmtTable.h"
+#include "mnodeSdb.h"
-#include "mgmtUser.h"
+#include "mnodeShow.h"
-#include "mgmtVgroup.h"
+#include "mnodeTable.h"
+#include "mnodeUser.h"
+#include "mnodeVgroup.h"
 
 static void *  tsDbSdb = NULL;
 static int32_t tsDbUpdateSize;
 
-static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate);
+static int32_t mnodeCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate);
-static void    mgmtDropDb(SQueuedMsg *newMsg);
+static int32_t mnodeDropDb(SMnodeMsg *newMsg);
-static int32_t mgmtSetDbDropping(SDbObj *pDb);
+static int32_t mnodeSetDbDropping(SDbObj *pDb);
-static int32_t mgmtGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
+static int32_t mnodeRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void    mgmtProcessCreateDbMsg(SQueuedMsg *pMsg);
+static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg);
-static void    mgmtProcessAlterDbMsg(SQueuedMsg *pMsg);
+static int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg);
-static void    mgmtProcessDropDbMsg(SQueuedMsg *pMsg);
+static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg);
 
-static int32_t mgmtDbActionDestroy(SSdbOper *pOper) {
+static int32_t mnodeDbActionDestroy(SSdbOper *pOper) {
   tfree(pOper->pObj);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDbActionInsert(SSdbOper *pOper) {
+static int32_t mnodeDbActionInsert(SSdbOper *pOper) {
   SDbObj *pDb = pOper->pObj;
-  SAcctObj *pAcct = mgmtGetAcct(pDb->acct);
+  SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
 
   pDb->pHead = NULL;
   pDb->pTail = NULL;
@@ -65,8 +66,8 @@ static int32_t mgmtDbActionInsert(SSdbOper *pOper) {
   pDb->numOfSuperTables = 0;
 
   if (pAcct != NULL) {
-    mgmtAddDbToAcct(pAcct, pDb);
+    mnodeAddDbToAcct(pAcct, pDb);
-    mgmtDecAcctRef(pAcct);
+    mnodeDecAcctRef(pAcct);
   }
   else {
     mError("db:%s, acct:%s info not exist in sdb", pDb->name, pDb->acct);
@@ -76,39 +77,39 @@ static int32_t mgmtDbActionInsert(SSdbOper *pOper) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDbActionDelete(SSdbOper *pOper) {
+static int32_t mnodeDbActionDelete(SSdbOper *pOper) {
   SDbObj *pDb = pOper->pObj;
-  SAcctObj *pAcct = mgmtGetAcct(pDb->acct);
+  SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
 
-  mgmtDropDbFromAcct(pAcct, pDb);
+  mnodeDropAllChildTables(pDb);
-  mgmtDropAllChildTables(pDb);
+  mnodeDropAllSuperTables(pDb);
-  mgmtDropAllSuperTables(pDb);
+  mnodeDropAllDbVgroups(pDb);
-  mgmtDropAllDbVgroups(pDb, false);
+  mnodeDropDbFromAcct(pAcct, pDb);
-  mgmtDecAcctRef(pAcct);
+  mnodeDecAcctRef(pAcct);
   
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDbActionUpdate(SSdbOper *pOper) {
+static int32_t mnodeDbActionUpdate(SSdbOper *pOper) {
   SDbObj *pDb = pOper->pObj;
-  SDbObj *pSaved = mgmtGetDb(pDb->name);
+  SDbObj *pSaved = mnodeGetDb(pDb->name);
   if (pDb != pSaved) {
     memcpy(pSaved, pDb, pOper->rowSize);
     free(pDb);
   }
-  mgmtUpdateAllDbVgroups(pSaved);
+  mnodeUpdateAllDbVgroups(pSaved);
-  mgmtDecDbRef(pSaved);
+  mnodeDecDbRef(pSaved);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDbActionEncode(SSdbOper *pOper) {
+static int32_t mnodeDbActionEncode(SSdbOper *pOper) {
   SDbObj *pDb = pOper->pObj;
   memcpy(pOper->rowData, pDb, tsDbUpdateSize);
   pOper->rowSize = tsDbUpdateSize;
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDbActionDecode(SSdbOper *pOper) {
+static int32_t mnodeDbActionDecode(SSdbOper *pOper) {
   SDbObj *pDb = (SDbObj *) calloc(1, sizeof(SDbObj));
   if (pDb == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY;
   
@@ -117,11 +118,11 @@ static int32_t mgmtDbActionDecode(SSdbOper *pOper) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDbActionRestored() {
+static int32_t mnodeDbActionRestored() {
   return 0;
 }
 
-int32_t mgmtInitDbs() {
+int32_t mnodeInitDbs() {
   SDbObj tObj;
   tsDbUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
 
@@ -132,13 +133,13 @@ int32_t mgmtInitDbs() {
     .maxRowSize   = tsDbUpdateSize,
     .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
     .keyType      = SDB_KEY_STRING,
-    .insertFp     = mgmtDbActionInsert,
+    .insertFp     = mnodeDbActionInsert,
-    .deleteFp     = mgmtDbActionDelete,
+    .deleteFp     = mnodeDbActionDelete,
-    .updateFp     = mgmtDbActionUpdate,
+    .updateFp     = mnodeDbActionUpdate,
-    .encodeFp     = mgmtDbActionEncode,
+    .encodeFp     = mnodeDbActionEncode,
-    .decodeFp     = mgmtDbActionDecode,
+    .decodeFp     = mnodeDbActionDecode,
-    .destroyFp    = mgmtDbActionDestroy,
+    .destroyFp    = mnodeDbActionDestroy,
-    .restoredFp   = mgmtDbActionRestored
+    .restoredFp   = mnodeDbActionRestored
   };
 
   tsDbSdb = sdbOpenTable(&tableDesc);
@@ -147,33 +148,33 @@ int32_t mgmtInitDbs() {
     return -1;
   }
 
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DB, mgmtProcessCreateDbMsg);
+  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DB, mnodeProcessCreateDbMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_ALTER_DB, mgmtProcessAlterDbMsg);
+  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_ALTER_DB, mnodeProcessAlterDbMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_DROP_DB, mgmtProcessDropDbMsg);
+  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_DB, mnodeProcessDropDbMsg);
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_DB, mgmtGetDbMeta);
+  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DB, mnodeGetDbMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_DB, mgmtRetrieveDbs);
+  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DB, mnodeRetrieveDbs);
   
   mTrace("table:dbs table is created");
   return 0;
 }
 
-void *mgmtGetNextDb(void *pIter, SDbObj **pDb) {
+void *mnodeGetNextDb(void *pIter, SDbObj **pDb) {
   return sdbFetchRow(tsDbSdb, pIter, (void **)pDb);
 }
 
-SDbObj *mgmtGetDb(char *db) {
+SDbObj *mnodeGetDb(char *db) {
   return (SDbObj *)sdbGetRow(tsDbSdb, db);
 }
 
-void mgmtIncDbRef(SDbObj *pDb) {
+void mnodeIncDbRef(SDbObj *pDb) {
   return sdbIncRef(tsDbSdb, pDb); 
 }
 
-void mgmtDecDbRef(SDbObj *pDb) { 
+void mnodeDecDbRef(SDbObj *pDb) { 
   return sdbDecRef(tsDbSdb, pDb); 
 }
 
-SDbObj *mgmtGetDbByTableId(char *tableId) {
+SDbObj *mnodeGetDbByTableId(char *tableId) {
   char db[TSDB_TABLE_ID_LEN], *pos;
 
   pos = strstr(tableId, TS_PATH_DELIMITER);
@@ -181,10 +182,10 @@ SDbObj *mgmtGetDbByTableId(char *tableId) {
   memset(db, 0, sizeof(db));
   strncpy(db, tableId, pos - tableId);
 
-  return mgmtGetDb(db);
+  return mnodeGetDb(db);
 }
 
-static int32_t mgmtCheckDbCfg(SDbCfg *pCfg) {
+static int32_t mnodeCheckDbCfg(SDbCfg *pCfg) {
   if (pCfg->cacheBlockSize < TSDB_MIN_CACHE_BLOCK_SIZE || pCfg->cacheBlockSize > TSDB_MAX_CACHE_BLOCK_SIZE) {
     mError("invalid db option cacheBlockSize:%d valid range: [%d, %d]", pCfg->cacheBlockSize, TSDB_MIN_CACHE_BLOCK_SIZE,
            TSDB_MAX_CACHE_BLOCK_SIZE);
@@ -290,7 +291,7 @@ static int32_t mgmtCheckDbCfg(SDbCfg *pCfg) {
   return TSDB_CODE_SUCCESS;
 }
 
-static void mgmtSetDefaultDbCfg(SDbCfg *pCfg) {
+static void mnodeSetDefaultDbCfg(SDbCfg *pCfg) {
   if (pCfg->cacheBlockSize < 0) pCfg->cacheBlockSize = tsCacheBlockSize;
   if (pCfg->totalBlocks < 0) pCfg->totalBlocks = tsBlocksPerVnode;
   if (pCfg->maxTables < 0) pCfg->maxTables = tsMaxTablePerVnode;
@@ -307,13 +308,13 @@ static void mgmtSetDefaultDbCfg(SDbCfg *pCfg) {
   if (pCfg->replications < 0) pCfg->replications = tsReplications;
 }
 
-static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) {
+static int32_t mnodeCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) {
   int32_t code = acctCheck(pAcct, ACCT_GRANT_DB);
   if (code != 0) return code;
 
-  SDbObj *pDb = mgmtGetDb(pCreate->db);
+  SDbObj *pDb = mnodeGetDb(pCreate->db);
   if (pDb != NULL) {
-    mgmtDecDbRef(pDb); 
+    mnodeDecDbRef(pDb); 
     if (pCreate->ignoreExist) {
       mTrace("db:%s, already exist, ignore exist is set", pCreate->db);
       return TSDB_CODE_SUCCESS;
@@ -347,9 +348,9 @@ static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) {
     .replications        = pCreate->replications
   };
 
-  mgmtSetDefaultDbCfg(&pDb->cfg);
+  mnodeSetDefaultDbCfg(&pDb->cfg);
 
-  code = mgmtCheckDbCfg(&pDb->cfg);
+  code = mnodeCheckDbCfg(&pDb->cfg);
   if (code != TSDB_CODE_SUCCESS) {
     tfree(pDb);
     return code;
@@ -371,7 +372,7 @@ static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) {
   return code;
 }
 
-bool mgmtCheckIsMonitorDB(char *db, char *monitordb) {
+bool mnodeCheckIsMonitorDB(char *db, char *monitordb) {
   char dbName[TSDB_DB_NAME_LEN + 1] = {0};
   extractDBName(db, dbName);
 
@@ -380,7 +381,7 @@ bool mgmtCheckIsMonitorDB(char *db, char *monitordb) {
 }
 
 #if 0
-void mgmtPrintVgroups(SDbObj *pDb, char *oper) {
+void mnodePrintVgroups(SDbObj *pDb, char *oper) {
   mPrint("db:%s, vgroup link from head, oper:%s", pDb->name, oper);  
   SVgObj *pVgroup = pDb->pHead;
   while (pVgroup != NULL) {
@@ -397,7 +398,7 @@ void mgmtPrintVgroups(SDbObj *pDb, char *oper) {
 }
 #endif
 
-void mgmtAddVgroupIntoDb(SVgObj *pVgroup) {
+void mnodeAddVgroupIntoDb(SVgObj *pVgroup) {
   SDbObj *pDb = pVgroup->pDb;
 
   pVgroup->next = pDb->pHead;
@@ -410,7 +411,7 @@ void mgmtAddVgroupIntoDb(SVgObj *pVgroup) {
   pDb->numOfVgroups++;
 }
 
-void mgmtAddVgroupIntoDbTail(SVgObj *pVgroup) {
+void mnodeAddVgroupIntoDbTail(SVgObj *pVgroup) {
   SDbObj *pDb = pVgroup->pDb;
   pVgroup->next = NULL;
   pVgroup->prev = pDb->pTail;
@@ -422,7 +423,7 @@ void mgmtAddVgroupIntoDbTail(SVgObj *pVgroup) {
   pDb->numOfVgroups++;
 }
 
-void mgmtRemoveVgroupFromDb(SVgObj *pVgroup) {
+void mnodeRemoveVgroupFromDb(SVgObj *pVgroup) {
   SDbObj *pDb = pVgroup->pDb;
   if (pVgroup->prev) pVgroup->prev->next = pVgroup->next;
   if (pVgroup->next) pVgroup->next->prev = pVgroup->prev;
@@ -431,25 +432,25 @@ void mgmtRemoveVgroupFromDb(SVgObj *pVgroup) {
   pDb->numOfVgroups--;
 }
 
-void mgmtMoveVgroupToTail(SVgObj *pVgroup) {
+void mnodeMoveVgroupToTail(SVgObj *pVgroup) {
-  mgmtRemoveVgroupFromDb(pVgroup);
+  mnodeRemoveVgroupFromDb(pVgroup);
-  mgmtAddVgroupIntoDbTail(pVgroup);
+  mnodeAddVgroupIntoDbTail(pVgroup);
 }
 
-void mgmtMoveVgroupToHead(SVgObj *pVgroup) {
+void mnodeMoveVgroupToHead(SVgObj *pVgroup) {
-  mgmtRemoveVgroupFromDb(pVgroup);
+  mnodeRemoveVgroupFromDb(pVgroup);
-  mgmtAddVgroupIntoDb(pVgroup);
+  mnodeAddVgroupIntoDb(pVgroup);
 }
 
-void mgmtCleanUpDbs() {
+void mnodeCleanupDbs() {
   sdbCloseTable(tsDbSdb);
 }
 
-static int32_t mgmtGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
   SSchema *pSchema = pMeta->schema;
-  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  SUserObj *pUser = mnodeGetUserFromConn(pConn);
   if (pUser == NULL) return 0;
 
   pShow->bytes[cols] = TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE;
@@ -583,32 +584,32 @@ static int32_t mgmtGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn)
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
   pShow->numOfRows = pUser->pAcct->acctInfo.numOfDbs;
 
-  mgmtDecUserRef(pUser);
+  mnodeDecUserRef(pUser);
   return 0;
 }
 
-static char *mgmtGetDbStr(char *src) {
+static char *mnodeGetDbStr(char *src) {
   char *pos = strstr(src, TS_PATH_DELIMITER);
   return ++pos;
 }
 
-static int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+static int32_t mnodeRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t numOfRows = 0;
   SDbObj *pDb = NULL;
   char *  pWrite;
   int32_t cols = 0;
-  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  SUserObj *pUser = mnodeGetUserFromConn(pConn);
   if (pUser == NULL) return 0;
 
   while (numOfRows < rows) {
-    pShow->pIter = mgmtGetNextDb(pShow->pIter, &pDb);
+    pShow->pIter = mnodeGetNextDb(pShow->pIter, &pDb);
     if (pDb == NULL) break;
 
     cols = 0;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
     
-    char* name = mgmtGetDbStr(pDb->name);
+    char* name = mnodeGetDbStr(pDb->name);
     STR_WITH_MAXSIZE_TO_VARSTR(pWrite, name, TSDB_DB_NAME_LEN);
     cols++;
 
@@ -706,31 +707,31 @@ static int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *
     cols++;
 
     numOfRows++;
-    mgmtDecDbRef(pDb);
+    mnodeDecDbRef(pDb);
   }
 
   pShow->numOfReads += numOfRows;
-  mgmtDecUserRef(pUser);
+  mnodeDecUserRef(pUser);
   return numOfRows;
 }
 
-void mgmtAddSuperTableIntoDb(SDbObj *pDb) {
+void mnodeAddSuperTableIntoDb(SDbObj *pDb) {
   atomic_add_fetch_32(&pDb->numOfSuperTables, 1);
 }
 
-void mgmtRemoveSuperTableFromDb(SDbObj *pDb) {
+void mnodeRemoveSuperTableFromDb(SDbObj *pDb) {
   atomic_add_fetch_32(&pDb->numOfSuperTables, -1);
 }
 
-void mgmtAddTableIntoDb(SDbObj *pDb) {
+void mnodeAddTableIntoDb(SDbObj *pDb) {
   atomic_add_fetch_32(&pDb->numOfTables, 1);
 }
 
-void mgmtRemoveTableFromDb(SDbObj *pDb) {
+void mnodeRemoveTableFromDb(SDbObj *pDb) {
   atomic_add_fetch_32(&pDb->numOfTables, -1);
 }
 
-static int32_t mgmtSetDbDropping(SDbObj *pDb) {
+static int32_t mnodeSetDbDropping(SDbObj *pDb) {
   if (pDb->status) return TSDB_CODE_SUCCESS;
 
   pDb->status = true;
@@ -748,9 +749,8 @@ static int32_t mgmtSetDbDropping(SDbObj *pDb) {
   return code;
 }
 
-static void mgmtProcessCreateDbMsg(SQueuedMsg *pMsg) {
+static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg) {
-  SCMCreateDbMsg *pCreate = pMsg->pCont;
+  SCMCreateDbMsg *pCreate  = pMsg->rpcMsg.pCont;  
-  
   pCreate->maxTables       = htonl(pCreate->maxTables);
   pCreate->cacheBlockSize  = htonl(pCreate->cacheBlockSize);
   pCreate->totalBlocks     = htonl(pCreate->totalBlocks);
@@ -768,7 +768,7 @@ static void mgmtProcessCreateDbMsg(SQueuedMsg *pMsg) {
   } else if (!pMsg->pUser->writeAuth) {
     code = TSDB_CODE_NO_RIGHTS;
   } else {
-    code = mgmtCreateDb(pMsg->pUser->pAcct, pCreate);
+    code = mnodeCreateDb(pMsg->pUser->pAcct, pCreate);
     if (code == TSDB_CODE_SUCCESS) {
       mLPrint("db:%s, is created by %s", pCreate->db, pMsg->pUser->user);
     } else {
@@ -776,10 +776,10 @@ static void mgmtProcessCreateDbMsg(SQueuedMsg *pMsg) {
     }
   }
 
-  mgmtSendSimpleResp(pMsg->thandle, code);
+  return code;
 }
 
-static SDbCfg mgmtGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) {
+static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) {
   SDbCfg  newCfg = pDb->cfg;
   int32_t maxTables      = htonl(pAlter->maxTables);
   int32_t cacheBlockSize = htonl(pAlter->cacheBlockSize);
@@ -876,7 +876,7 @@ static SDbCfg mgmtGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) {
       terrno = TSDB_CODE_INVALID_OPTION;
     }
 
-    if (replications > mgmtGetDnodesNum()) {
+    if (replications > mnodeGetDnodesNum()) {
       mError("db:%s, no enough dnode to change replica:%d", pDb->name, replications);
       terrno = TSDB_CODE_NO_ENOUGH_DNODES;
     }
@@ -890,13 +890,13 @@ static SDbCfg mgmtGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) {
   return newCfg;
 }
 
-static int32_t mgmtAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) {
+static int32_t mnodeAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) {
-  SDbCfg newCfg = mgmtGetAlterDbOption(pDb, pAlter);
+  SDbCfg newCfg = mnodeGetAlterDbOption(pDb, pAlter);
   if (terrno != TSDB_CODE_SUCCESS) {
     return terrno;
   }
 
-  int32_t code = mgmtCheckDbCfg(&newCfg);
+  int32_t code = mnodeCheckDbCfg(&newCfg);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -921,10 +921,10 @@ static int32_t mgmtAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) {
   void *pIter = NULL;
   while (1) {
     SVgObj *pVgroup = NULL;
-    pIter = mgmtGetNextVgroup(pIter, &pVgroup);
+    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
     if (pVgroup == NULL) break;   
-    mgmtSendCreateVgroupMsg(pVgroup, NULL);
+    mnodeSendCreateVgroupMsg(pVgroup, NULL);
-    mgmtDecVgroupRef(pVgroup);
+    mnodeDecVgroupRef(pVgroup);
   }
   sdbFreeIter(pIter);
 
@@ -935,35 +935,27 @@ static int32_t mgmtAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) {
   return TSDB_CODE_SUCCESS;
 }
 
-static void mgmtProcessAlterDbMsg(SQueuedMsg *pMsg) {
+static int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg) {
-  SCMAlterDbMsg *pAlter = pMsg->pCont;
+  SCMAlterDbMsg *pAlter = pMsg->rpcMsg.pCont;
-  mTrace("db:%s, alter db msg is received from thandle:%p", pAlter->db, pMsg->thandle);
+  mTrace("db:%s, alter db msg is received from thandle:%p", pAlter->db, pMsg->rpcMsg.handle);
 
-  if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
+  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pAlter->db);
-    mError("db:%s, failed to alter, grant expired", pAlter->db);
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_GRANT_EXPIRED);
-    return;
-  }
-
-  if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDb(pAlter->db);
   if (pMsg->pDb == NULL) {
     mError("db:%s, failed to alter, invalid db", pAlter->db);
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_DB);
+    return TSDB_CODE_INVALID_DB;
-    return;
   }
 
-  int32_t code = mgmtAlterDb(pMsg->pDb, pAlter);
+  int32_t code = mnodeAlterDb(pMsg->pDb, pAlter);
   if (code != TSDB_CODE_SUCCESS) {
     mError("db:%s, failed to alter, invalid db option", pAlter->db);
-    mgmtSendSimpleResp(pMsg->thandle, code);
+    return code;
-    return;
   }
 
   mTrace("db:%s, all vgroups is altered", pMsg->pDb->name);
-  mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SUCCESS);
+  return TSDB_CODE_SUCCESS;
 }
 
-static void mgmtDropDb(SQueuedMsg *pMsg) {
+static int32_t mnodeDropDb(SMnodeMsg *pMsg) {
   SDbObj *pDb = pMsg->pDb;
   mPrint("db:%s, drop db from sdb", pDb->name);
 
@@ -977,64 +969,42 @@ static void mgmtDropDb(SQueuedMsg *pMsg) {
     code = TSDB_CODE_SDB_ERROR;
   }
 
-  mgmtSendSimpleResp(pMsg->thandle, code);
+  return code;
 }
 
-static void mgmtProcessDropDbMsg(SQueuedMsg *pMsg) {
+static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg) {
-  SCMDropDbMsg *pDrop = pMsg->pCont;
+  SCMDropDbMsg *pDrop = pMsg->rpcMsg.pCont;
-  mTrace("db:%s, drop db msg is received from thandle:%p", pDrop->db, pMsg->thandle);
+  mTrace("db:%s, drop db msg is received from thandle:%p", pDrop->db, pMsg->rpcMsg.handle);
 
-  if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
+  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pDrop->db);
-    mError("db:%s, failed to drop, grant expired", pDrop->db);
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_GRANT_EXPIRED);
-    return;
-  }
-
-  if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDb(pDrop->db);
   if (pMsg->pDb == NULL) {
     if (pDrop->ignoreNotExists) {
       mTrace("db:%s, db is not exist, think drop success", pDrop->db);
-      mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SUCCESS);
+      return TSDB_CODE_SUCCESS;
-      return;
     } else {
       mError("db:%s, failed to drop, invalid db", pDrop->db);
-      mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_DB);
+      return TSDB_CODE_INVALID_DB;
-      return;
     }
   }
 
-  if (mgmtCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) {
+  if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) {
     mError("db:%s, can't drop monitor database", pDrop->db);
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_MONITOR_DB_FORBIDDEN);
+    return TSDB_CODE_MONITOR_DB_FORBIDDEN;
-    return;
   }
 
-  int32_t code = mgmtSetDbDropping(pMsg->pDb);
+  int32_t code = mnodeSetDbDropping(pMsg->pDb);
   if (code != TSDB_CODE_SUCCESS) {
     mError("db:%s, failed to drop, reason:%s", pDrop->db, tstrerror(code));
-    mgmtSendSimpleResp(pMsg->thandle, code);
+    return code;
-    return;
   }
 
-#if 1
+  mnodeSendDropAllDbVgroupsMsg(pMsg->pDb);
-  mgmtDropAllDbVgroups(pMsg->pDb, true);
-#else
-  SVgObj *pVgroup = pMsg->pDb->pHead;
-  if (pVgroup != NULL) {
-    mPrint("vgId:%d, will be dropped", pVgroup->vgId);
-    SQueuedMsg *newMsg = mgmtCloneQueuedMsg(pMsg);
-    newMsg->ahandle = pVgroup;
-    newMsg->expected = pVgroup->numOfVnodes;
-    mgmtDropVgroup(pVgroup, newMsg);
-    return;
-  }
-#endif  
 
   mTrace("db:%s, all vgroups is dropped", pMsg->pDb->name);
-  mgmtDropDb(pMsg);
+  return mnodeDropDb(pMsg);
 }
 
-void  mgmtDropAllDbs(SAcctObj *pAcct)  {
+void  mnodeDropAllDbs(SAcctObj *pAcct)  {
   int32_t numOfDbs = 0;
   SDbObj *pDb = NULL;
   void *  pIter = NULL;
@@ -1042,7 +1012,7 @@ void  mgmtDropAllDbs(SAcctObj *pAcct)  {
   mPrint("acct:%s, all dbs will be dropped from sdb", pAcct->user);
 
   while (1) {
-    pIter = mgmtGetNextDb(pIter, &pDb);
+    pIter = mnodeGetNextDb(pIter, &pDb);
     if (pDb == NULL) break;
 
     if (pDb->pAcct == pAcct) {
@@ -1056,7 +1026,7 @@ void  mgmtDropAllDbs(SAcctObj *pAcct)  {
       sdbDeleteRow(&oper);
       numOfDbs++;
     }
-    mgmtDecDbRef(pDb);
+    mnodeDecDbRef(pDb);
   }
 
   sdbFreeIter(pIter);

src/mnode/src/mnodeDnode.c

@@ -25,15 +25,18 @@
 #include "tbalance.h"
 #include "tsync.h"
 #include "tdataformat.h"
+#include "mnode.h"
 #include "dnode.h"
-#include "mgmtDef.h"
+#include "mnodeDef.h"
-#include "mgmtInt.h"
+#include "mnodeInt.h"
-#include "mgmtDnode.h"
+#include "mnodeDnode.h"
-#include "mgmtMnode.h"
+#include "mnodeMnode.h"
-#include "mgmtSdb.h"
+#include "mnodeSdb.h"
-#include "mgmtShell.h"
+#include "mnodeShow.h"
-#include "mgmtUser.h"
+#include "mnodeUser.h"
-#include "mgmtVgroup.h"
+#include "mnodeVgroup.h"
+#include "mnodeWrite.h"
+#include "mnodePeer.h"
 
 int32_t tsAccessSquence = 0;
 static void   *tsDnodeSdb = NULL;
@@ -41,27 +44,28 @@ static int32_t tsDnodeUpdateSize = 0;
 extern void *  tsMnodeSdb;
 extern void *  tsVgroupSdb;
 
-static int32_t mgmtCreateDnode(char *ep);
+static int32_t mnodeCreateDnode(char *ep);
-static void    mgmtProcessCreateDnodeMsg(SQueuedMsg *pMsg);
+static int32_t mnodeProcessCreateDnodeMsg(SMnodeMsg *pMsg);
-static void    mgmtProcessDropDnodeMsg(SQueuedMsg *pMsg);
+static int32_t mnodeProcessDropDnodeMsg(SMnodeMsg *pMsg);
-static void    mgmtProcessCfgDnodeMsg(SQueuedMsg *pMsg);
+static int32_t mnodeProcessCfgDnodeMsg(SMnodeMsg *pMsg);
-static void    mgmtProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) ;
+static void    mnodeProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) ;
-static void    mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg);
+static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *rpcMsg);
-static int32_t mgmtGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mnodeGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn);
+static int32_t mnodeRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mgmtGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mnodeGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
+static int32_t mnodeRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mgmtGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mnodeGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
+static int32_t mnodeRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mgmtGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mnodeGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
+static int32_t mnodeRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
+static char*   mnodeGetDnodeAlternativeRoleStr(int32_t alternativeRole);
 
-static int32_t mgmtDnodeActionDestroy(SSdbOper *pOper) {
+static int32_t mnodeDnodeActionDestroy(SSdbOper *pOper) {
   tfree(pOper->pObj);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDnodeActionInsert(SSdbOper *pOper) {
+static int32_t mnodeDnodeActionInsert(SSdbOper *pOper) {
   SDnodeObj *pDnode = pOper->pObj;
   if (pDnode->status != TAOS_DN_STATUS_DROPPING) {
     pDnode->status = TAOS_DN_STATUS_OFFLINE;
@@ -70,38 +74,38 @@ static int32_t mgmtDnodeActionInsert(SSdbOper *pOper) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDnodeActionDelete(SSdbOper *pOper) {
+static int32_t mnodeDnodeActionDelete(SSdbOper *pOper) {
   SDnodeObj *pDnode = pOper->pObj;
  
 #ifndef _SYNC 
-  mgmtDropAllDnodeVgroups(pDnode);
+  mnodeDropAllDnodeVgroups(pDnode);
 #endif  
-  mgmtDropMnodeLocal(pDnode->dnodeId);
+  mnodeDropMnodeLocal(pDnode->dnodeId);
   balanceNotify();
 
   mTrace("dnode:%d, all vgroups is dropped from sdb", pDnode->dnodeId);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDnodeActionUpdate(SSdbOper *pOper) {
+static int32_t mnodeDnodeActionUpdate(SSdbOper *pOper) {
   SDnodeObj *pDnode = pOper->pObj;
-  SDnodeObj *pSaved = mgmtGetDnode(pDnode->dnodeId);
+  SDnodeObj *pSaved = mnodeGetDnode(pDnode->dnodeId);
   if (pDnode != pSaved) {
     memcpy(pSaved, pDnode, pOper->rowSize);
     free(pDnode);
   }
-  mgmtDecDnodeRef(pSaved);
+  mnodeDecDnodeRef(pSaved);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDnodeActionEncode(SSdbOper *pOper) {
+static int32_t mnodeDnodeActionEncode(SSdbOper *pOper) {
   SDnodeObj *pDnode = pOper->pObj;
   memcpy(pOper->rowData, pDnode, tsDnodeUpdateSize);
   pOper->rowSize = tsDnodeUpdateSize;
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDnodeActionDecode(SSdbOper *pOper) {
+static int32_t mnodeDnodeActionDecode(SSdbOper *pOper) {
   SDnodeObj *pDnode = (SDnodeObj *) calloc(1, sizeof(SDnodeObj));
   if (pDnode == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY;
 
@@ -110,19 +114,19 @@ static int32_t mgmtDnodeActionDecode(SSdbOper *pOper) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtDnodeActionRestored() {
+static int32_t mnodeDnodeActionRestored() {
   int32_t numOfRows = sdbGetNumOfRows(tsDnodeSdb);
   if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
-    mgmtCreateDnode(tsLocalEp);
+    mnodeCreateDnode(tsLocalEp);
-    SDnodeObj *pDnode = mgmtGetDnodeByEp(tsLocalEp);
+    SDnodeObj *pDnode = mnodeGetDnodeByEp(tsLocalEp);
-    mgmtAddMnode(pDnode->dnodeId);
+    mnodeAddMnode(pDnode->dnodeId);
-    mgmtDecDnodeRef(pDnode);
+    mnodeDecDnodeRef(pDnode);
   }
 
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t mgmtInitDnodes() {
+int32_t mnodeInitDnodes() {
   SDnodeObj tObj;
   tsDnodeUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
 
@@ -133,13 +137,13 @@ int32_t mgmtInitDnodes() {
     .maxRowSize   = tsDnodeUpdateSize,
     .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
     .keyType      = SDB_KEY_AUTO,
-    .insertFp     = mgmtDnodeActionInsert,
+    .insertFp     = mnodeDnodeActionInsert,
-    .deleteFp     = mgmtDnodeActionDelete,
+    .deleteFp     = mnodeDnodeActionDelete,
-    .updateFp     = mgmtDnodeActionUpdate,
+    .updateFp     = mnodeDnodeActionUpdate,
-    .encodeFp     = mgmtDnodeActionEncode,
+    .encodeFp     = mnodeDnodeActionEncode,
-    .decodeFp     = mgmtDnodeActionDecode,
+    .decodeFp     = mnodeDnodeActionDecode,
-    .destroyFp    = mgmtDnodeActionDestroy,
+    .destroyFp    = mnodeDnodeActionDestroy,
-    .restoredFp   = mgmtDnodeActionRestored
+    .restoredFp   = mnodeDnodeActionRestored
   };
 
   tsDnodeSdb = sdbOpenTable(&tableDesc);
@@ -148,46 +152,46 @@ int32_t mgmtInitDnodes() {
     return -1;
   }
 
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DNODE, mgmtProcessCreateDnodeMsg);
+  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DNODE, mnodeProcessCreateDnodeMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_DROP_DNODE, mgmtProcessDropDnodeMsg); 
+  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_DNODE, mnodeProcessDropDnodeMsg); 
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CONFIG_DNODE, mgmtProcessCfgDnodeMsg);
+  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CONFIG_DNODE, mnodeProcessCfgDnodeMsg);
-  dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP, mgmtProcessCfgDnodeMsgRsp);
+  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP, mnodeProcessCfgDnodeMsgRsp);
-  dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_STATUS, mgmtProcessDnodeStatusMsg);
+  mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_STATUS, mnodeProcessDnodeStatusMsg);
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_MODULE, mgmtGetModuleMeta);
+  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_MODULE, mnodeGetModuleMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_MODULE, mgmtRetrieveModules);
+  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_MODULE, mnodeRetrieveModules);
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_CONFIGS, mgmtGetConfigMeta);
+  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONFIGS, mnodeGetConfigMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_CONFIGS, mgmtRetrieveConfigs);
+  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONFIGS, mnodeRetrieveConfigs);
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_VNODES, mgmtGetVnodeMeta);
+  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VNODES, mnodeGetVnodeMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_VNODES, mgmtRetrieveVnodes);
+  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VNODES, mnodeRetrieveVnodes);
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_DNODE, mgmtGetDnodeMeta);
+  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DNODE, mnodeGetDnodeMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_DNODE, mgmtRetrieveDnodes);
+  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DNODE, mnodeRetrieveDnodes);
  
   mTrace("table:dnodes table is created");
   return 0;
 }
 
-void mgmtCleanupDnodes() {
+void mnodeCleanupDnodes() {
   sdbCloseTable(tsDnodeSdb);
 }
 
-void *mgmtGetNextDnode(void *pIter, SDnodeObj **pDnode) { 
+void *mnodeGetNextDnode(void *pIter, SDnodeObj **pDnode) { 
   return sdbFetchRow(tsDnodeSdb, pIter, (void **)pDnode); 
 }
 
-int32_t mgmtGetDnodesNum() {
+int32_t mnodeGetDnodesNum() {
   return sdbGetNumOfRows(tsDnodeSdb);
 }
 
-int32_t mgmtGetOnlinDnodesNum(char *ep) {
+int32_t mnodeGetOnlinDnodesNum(char *ep) {
   SDnodeObj *pDnode = NULL;
   void *     pIter = NULL;
   int32_t    onlineDnodes = 0;
 
   while (1) {
-    pIter = mgmtGetNextDnode(pIter, &pDnode);
+    pIter = mnodeGetNextDnode(pIter, &pDnode);
     if (pDnode == NULL) break;
     if (pDnode->status != TAOS_DN_STATUS_OFFLINE) onlineDnodes++;
-    mgmtDecDnodeRef(pDnode);
+    mnodeDecDnodeRef(pDnode);
   }
 
   sdbFreeIter(pIter);
@@ -195,22 +199,22 @@ int32_t mgmtGetOnlinDnodesNum(char *ep) {
   return onlineDnodes;
 }
 
-void *mgmtGetDnode(int32_t dnodeId) {
+void *mnodeGetDnode(int32_t dnodeId) {
   return sdbGetRow(tsDnodeSdb, &dnodeId);
 }
 
-void *mgmtGetDnodeByEp(char *ep) {
+void *mnodeGetDnodeByEp(char *ep) {
   SDnodeObj *pDnode = NULL;
   void *     pIter = NULL;
 
   while (1) {
-    pIter = mgmtGetNextDnode(pIter, &pDnode);
+    pIter = mnodeGetNextDnode(pIter, &pDnode);
     if (pDnode == NULL) break;
     if (strcmp(ep, pDnode->dnodeEp) == 0) {
       sdbFreeIter(pIter);
       return pDnode;
     }
-    mgmtDecDnodeRef(pDnode);
+    mnodeDecDnodeRef(pDnode);
   }
 
   sdbFreeIter(pIter);
@@ -218,15 +222,15 @@ void *mgmtGetDnodeByEp(char *ep) {
   return NULL;
 }
 
-void mgmtIncDnodeRef(SDnodeObj *pDnode) {
+void mnodeIncDnodeRef(SDnodeObj *pDnode) {
   sdbIncRef(tsDnodeSdb, pDnode);
 }
 
-void mgmtDecDnodeRef(SDnodeObj *pDnode) {
+void mnodeDecDnodeRef(SDnodeObj *pDnode) {
   sdbDecRef(tsDnodeSdb, pDnode);
 }
 
-void mgmtUpdateDnode(SDnodeObj *pDnode) {
+void mnodeUpdateDnode(SDnodeObj *pDnode) {
   SSdbOper oper = {
     .type = SDB_OPER_GLOBAL,
     .table = tsDnodeSdb,
@@ -236,10 +240,8 @@ void mgmtUpdateDnode(SDnodeObj *pDnode) {
   sdbUpdateRow(&oper);
 }
 
-void mgmtProcessCfgDnodeMsg(SQueuedMsg *pMsg) {
+static int32_t mnodeProcessCfgDnodeMsg(SMnodeMsg *pMsg) {
-  SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
+  SCMCfgDnodeMsg *pCmCfgDnode = pMsg->rpcMsg.pCont;
-  
-  SCMCfgDnodeMsg *pCmCfgDnode = pMsg->pCont;
   if (pCmCfgDnode->ep[0] == 0) {
     strcpy(pCmCfgDnode->ep, tsLocalEp);
   } else {
@@ -247,12 +249,14 @@ void mgmtProcessCfgDnodeMsg(SQueuedMsg *pMsg) {
   }
 
   if (strcmp(pMsg->pUser->user, "root") != 0) {
-    rpcRsp.code = TSDB_CODE_NO_RIGHTS;
+    return TSDB_CODE_NO_RIGHTS;
-  } else {
+  }
-    SRpcIpSet ipSet = mgmtGetIpSetFromIp(pCmCfgDnode->ep);
+
+  SRpcIpSet ipSet = mnodeGetIpSetFromIp(pCmCfgDnode->ep);
   SMDCfgDnodeMsg *pMdCfgDnode = rpcMallocCont(sizeof(SMDCfgDnodeMsg));
   strcpy(pMdCfgDnode->ep, pCmCfgDnode->ep);
   strcpy(pMdCfgDnode->config, pCmCfgDnode->config);
+
   SRpcMsg rpcMdCfgDnodeMsg = {
     .handle = 0,
     .code = 0,
@@ -261,22 +265,18 @@ void mgmtProcessCfgDnodeMsg(SQueuedMsg *pMsg) {
     .contLen = sizeof(SMDCfgDnodeMsg)
   };
   dnodeSendMsgToDnode(&ipSet, &rpcMdCfgDnodeMsg);
-    rpcRsp.code = TSDB_CODE_SUCCESS;
-  }
 
-  if (rpcRsp.code == TSDB_CODE_SUCCESS) {
   mPrint("dnode:%s, is configured by %s", pCmCfgDnode->ep, pMsg->pUser->user);
+
+  return TSDB_CODE_SUCCESS;
 }
 
-  rpcSendResponse(&rpcRsp);
+static void mnodeProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) {
-}
-
-static void mgmtProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) {
   mPrint("cfg dnode rsp is received");
 }
 
-void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) {
+static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg) {
-  SDMStatusMsg *pStatus = rpcMsg->pCont;
+  SDMStatusMsg *pStatus = pMsg->rpcMsg.pCont;
   pStatus->dnodeId      = htonl(pStatus->dnodeId);
   pStatus->moduleStatus = htonl(pStatus->moduleStatus);
   pStatus->lastReboot   = htonl(pStatus->lastReboot);
@@ -286,24 +286,21 @@ void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) {
   uint32_t version = htonl(pStatus->version);
   if (version != tsVersion) {
     mError("status msg version:%d not equal with mnode:%d", version, tsVersion);
-    mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_INVALID_MSG_VERSION);
+    return TSDB_CODE_INVALID_MSG_VERSION;
-    return ;
   }
 
   SDnodeObj *pDnode = NULL;
   if (pStatus->dnodeId == 0) {
-    pDnode = mgmtGetDnodeByEp(pStatus->dnodeEp);
+    pDnode = mnodeGetDnodeByEp(pStatus->dnodeEp);
     if (pDnode == NULL) {
       mTrace("dnode %s not created", pStatus->dnodeEp);
-      mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_DNODE_NOT_EXIST);
+      return TSDB_CODE_DNODE_NOT_EXIST;
-      return;
     }
   } else {
-    pDnode = mgmtGetDnode(pStatus->dnodeId);
+    pDnode = mnodeGetDnode(pStatus->dnodeId);
     if (pDnode == NULL) {
       mError("dnode id:%d, %s not exist", pStatus->dnodeId, pStatus->dnodeEp);
-      mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_DNODE_NOT_EXIST);
+      return TSDB_CODE_DNODE_NOT_EXIST;
-      return;
     }
   }
 
@@ -327,34 +324,33 @@ void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) {
     pVload->vgId = htonl(pVload->vgId);
     pVload->cfgVersion = htonl(pVload->cfgVersion);
 
-    SVgObj *pVgroup = mgmtGetVgroup(pVload->vgId);
+    SVgObj *pVgroup = mnodeGetVgroup(pVload->vgId);
     if (pVgroup == NULL) {
-      SRpcIpSet ipSet = mgmtGetIpSetFromIp(pDnode->dnodeEp);
+      SRpcIpSet ipSet = mnodeGetIpSetFromIp(pDnode->dnodeEp);
       mPrint("dnode:%d, vgId:%d not exist in mnode, drop it", pDnode->dnodeId, pVload->vgId);
-      mgmtSendDropVnodeMsg(pVload->vgId, &ipSet, NULL);
+      mnodeSendDropVnodeMsg(pVload->vgId, &ipSet, NULL);
     } else {
-      mgmtUpdateVgroupStatus(pVgroup, pDnode, pVload);
+      mnodeUpdateVgroupStatus(pVgroup, pDnode, pVload);
-      mgmtDecVgroupRef(pVgroup);
+      mnodeDecVgroupRef(pVgroup);
     }
   }
 
   if (pDnode->status == TAOS_DN_STATUS_OFFLINE) {
     mTrace("dnode:%d, from offline to online", pDnode->dnodeId);
     pDnode->status = TAOS_DN_STATUS_READY;
-    balanceUpdateMgmt();
+    balanceUpdateMnode();
     balanceNotify();
   }
 
-  mgmtDecDnodeRef(pDnode);
+  mnodeDecDnodeRef(pDnode);
 
   int32_t contLen = sizeof(SDMStatusRsp) + TSDB_MAX_VNODES * sizeof(SDMVgroupAccess);
   SDMStatusRsp *pRsp = rpcMallocCont(contLen);
   if (pRsp == NULL) {
-    mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_SERV_OUT_OF_MEMORY);
+    return TSDB_CODE_SERV_OUT_OF_MEMORY;
-    return;
   }
 
-  mgmtGetMnodeInfos(&pRsp->mnodes);
+  mnodeGetMnodeInfos(&pRsp->mnodes);
 
   pRsp->dnodeCfg.dnodeId = htonl(pDnode->dnodeId);
   pRsp->dnodeCfg.moduleStatus = htonl((int32_t)pDnode->isMgmt);
@@ -364,25 +360,21 @@ void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) {
 
   //TODO: set vnode access
   
-  SRpcMsg rpcRsp = {
+  pMsg->rpcRsp.len = contLen;
-    .handle  = rpcMsg->handle,
+  pMsg->rpcRsp.rsp =  pRsp;
-    .code    = TSDB_CODE_SUCCESS,
-    .pCont   = pRsp,
-    .contLen = contLen
-  };
 
-  rpcSendResponse(&rpcRsp);
+  return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtCreateDnode(char *ep) {
+static int32_t mnodeCreateDnode(char *ep) {
   int32_t grantCode = grantCheck(TSDB_GRANT_DNODE);
   if (grantCode != TSDB_CODE_SUCCESS) {
     return grantCode;
   }
 
-  SDnodeObj *pDnode = mgmtGetDnodeByEp(ep);
+  SDnodeObj *pDnode = mnodeGetDnodeByEp(ep);
   if (pDnode != NULL) {
-    mgmtDecDnodeRef(pDnode);
+    mnodeDecDnodeRef(pDnode);
     mError("dnode:%d is alredy exist, %s:%d", pDnode->dnodeId, pDnode->dnodeFqdn, pDnode->dnodePort);
     return TSDB_CODE_DNODE_ALREADY_EXIST;
   }
@@ -413,7 +405,7 @@ static int32_t mgmtCreateDnode(char *ep) {
   return code;
 }
 
-int32_t mgmtDropDnode(SDnodeObj *pDnode) {
+int32_t mnodeDropDnode(SDnodeObj *pDnode) {
   SSdbOper oper = {
     .type = SDB_OPER_GLOBAL,
     .table = tsDnodeSdb,
@@ -429,15 +421,14 @@ int32_t mgmtDropDnode(SDnodeObj *pDnode) {
   return code;
 }
 
-static int32_t mgmtDropDnodeByEp(char *ep) {
+static int32_t mnodeDropDnodeByEp(char *ep) {
-  
+  SDnodeObj *pDnode = mnodeGetDnodeByEp(ep);
-  SDnodeObj *pDnode = mgmtGetDnodeByEp(ep);
   if (pDnode == NULL) {
     mError("dnode:%s, is not exist", ep);
     return TSDB_CODE_DNODE_NOT_EXIST;
   }
 
-  mgmtDecDnodeRef(pDnode);
+  mnodeDecDnodeRef(pDnode);
   if (strcmp(pDnode->dnodeEp, dnodeGetMnodeMasterEp()) == 0) {
     mError("dnode:%d, can't drop dnode:%s which is master", pDnode->dnodeId, ep);
     return TSDB_CODE_NO_REMOVE_MASTER;
@@ -445,58 +436,56 @@ static int32_t mgmtDropDnodeByEp(char *ep) {
 
   mPrint("dnode:%d, start to drop it", pDnode->dnodeId);
 #ifndef _SYNC
-  return mgmtDropDnode(pDnode);
+  return mnodeDropDnode(pDnode);
 #else
   return balanceDropDnode(pDnode);
 #endif
 }
 
-static void mgmtProcessCreateDnodeMsg(SQueuedMsg *pMsg) {
+static int32_t mnodeProcessCreateDnodeMsg(SMnodeMsg *pMsg) {
-  SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
+  SCMCreateDnodeMsg *pCreate = pMsg->rpcMsg.pCont;
-  
-  SCMCreateDnodeMsg *pCreate = pMsg->pCont;
 
   if (strcmp(pMsg->pUser->user, "root") != 0) {
-    rpcRsp.code = TSDB_CODE_NO_RIGHTS;
+    return TSDB_CODE_NO_RIGHTS;
   } else {
-    rpcRsp.code = mgmtCreateDnode(pCreate->ep);
+    int32_t code = mnodeCreateDnode(pCreate->ep);
-    if (rpcRsp.code == TSDB_CODE_SUCCESS) {
+
-      SDnodeObj *pDnode = mgmtGetDnodeByEp(pCreate->ep);
+    if (code == TSDB_CODE_SUCCESS) {
+      SDnodeObj *pDnode = mnodeGetDnodeByEp(pCreate->ep);
       mLPrint("dnode:%d, %s is created by %s", pDnode->dnodeId, pCreate->ep, pMsg->pUser->user);
-      mgmtDecDnodeRef(pDnode);
+      mnodeDecDnodeRef(pDnode);
     } else {
-      mError("failed to create dnode:%s, reason:%s", pCreate->ep, tstrerror(rpcRsp.code));
+      mError("failed to create dnode:%s, reason:%s", pCreate->ep, tstrerror(code));
-    }
-  }
-  rpcSendResponse(&rpcRsp);
     }
 
+    return code;
+  }
+}
 
-static void mgmtProcessDropDnodeMsg(SQueuedMsg *pMsg) {
+static int32_t mnodeProcessDropDnodeMsg(SMnodeMsg *pMsg) {
-  SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
+  SCMDropDnodeMsg *pDrop = pMsg->rpcMsg.pCont;
-  
-  SCMDropDnodeMsg *pDrop = pMsg->pCont;
 
   if (strcmp(pMsg->pUser->user, "root") != 0) {
-    rpcRsp.code = TSDB_CODE_NO_RIGHTS;
+    return TSDB_CODE_NO_RIGHTS;
   } else {
-    rpcRsp.code = mgmtDropDnodeByEp(pDrop->ep);
+    int32_t code = mnodeDropDnodeByEp(pDrop->ep);
-    if (rpcRsp.code == TSDB_CODE_SUCCESS) {
+
+    if (code == TSDB_CODE_SUCCESS) {
       mLPrint("dnode:%s is dropped by %s", pDrop->ep, pMsg->pUser->user);
     } else {
-      mError("failed to drop dnode:%s, reason:%s", pDrop->ep, tstrerror(rpcRsp.code));
+      mError("failed to drop dnode:%s, reason:%s", pDrop->ep, tstrerror(code));
+    }
+
+    return code;
   }
 }
 
-  rpcSendResponse(&rpcRsp);
+static int32_t mnodeGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-}
+  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-
-static int32_t mgmtGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SUserObj *pUser = mgmtGetUserFromConn(pConn);
   if (pUser == NULL) return 0;
 
   if (strcmp(pUser->pAcct->user, "root") != 0) {
-    mgmtDecUserRef(pUser);
+    mnodeDecUserRef(pUser);
     return TSDB_CODE_NO_RIGHTS;
   }
 
@@ -533,6 +522,12 @@ static int32_t mgmtGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCo
   pSchema[cols].bytes = htons(pShow->bytes[cols]);
   cols++;
 
+  pShow->bytes[cols] = 6 + VARSTR_HEADER_SIZE;
+  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+  strcpy(pSchema[cols].name, "alternativeRole");
+  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  cols++;
+
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
   strcpy(pSchema[cols].name, "create_time");
@@ -547,23 +542,23 @@ static int32_t mgmtGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCo
     pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
   }
 
-  pShow->numOfRows = mgmtGetDnodesNum();
+  pShow->numOfRows = mnodeGetDnodesNum();
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
   pShow->pIter = NULL;
 
-  mgmtDecUserRef(pUser);
+  mnodeDecUserRef(pUser);
 
   return 0;
 }
 
-static int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+static int32_t mnodeRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t    numOfRows = 0;
   int32_t    cols      = 0;
   SDnodeObj *pDnode   = NULL;
   char      *pWrite;
 
   while (numOfRows < rows) {
-    pShow->pIter = mgmtGetNextDnode(pShow->pIter, &pDnode);
+    pShow->pIter = mnodeGetNextDnode(pShow->pIter, &pDnode);
     if (pDnode == NULL) break;
 
     cols = 0;
@@ -585,37 +580,41 @@ static int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, voi
     cols++;
     
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;  
-    
+    char* status = mnodeGetDnodeStatusStr(pDnode->status);
-    char* status = mgmtGetDnodeStatusStr(pDnode->status);
     STR_TO_VARSTR(pWrite, status);
     cols++;
 
+    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;  
+    char* role = mnodeGetDnodeAlternativeRoleStr(pDnode->alternativeRole);
+    STR_TO_VARSTR(pWrite, role);
+    cols++;
+
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
     *(int64_t *)pWrite = pDnode->createdTime;
     cols++;
 
  
     numOfRows++;
-    mgmtDecDnodeRef(pDnode);
+    mnodeDecDnodeRef(pDnode);
   }
 
   pShow->numOfReads += numOfRows;
   return numOfRows;
 }
 
-static bool mgmtCheckModuleInDnode(SDnodeObj *pDnode, int32_t moduleType) {
+static bool mnodeCheckModuleInDnode(SDnodeObj *pDnode, int32_t moduleType) {
   uint32_t status = pDnode->moduleStatus & (1 << moduleType);
   return status > 0;
 }
 
-static int32_t mgmtGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mnodeGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
-  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  SUserObj *pUser = mnodeGetUserFromConn(pConn);
   if (pUser == NULL) return 0;
 
   if (strcmp(pUser->user, "root") != 0)  {
-    mgmtDecUserRef(pUser);
+    mnodeDecUserRef(pUser);
     return TSDB_CODE_NO_RIGHTS;
   }
 
@@ -653,21 +652,21 @@ static int32_t mgmtGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pC
     pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
   }
 
-  pShow->numOfRows = mgmtGetDnodesNum() * TSDB_MOD_MAX;
+  pShow->numOfRows = mnodeGetDnodesNum() * TSDB_MOD_MAX;
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
   pShow->pIter = NULL;
-  mgmtDecUserRef(pUser);
+  mnodeDecUserRef(pUser);
 
   return 0;
 }
 
-int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+int32_t mnodeRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t numOfRows = 0;
   char *  pWrite;
 
   while (numOfRows < rows) {
     SDnodeObj *pDnode = NULL;
-    pShow->pIter = mgmtGetNextDnode(pShow->pIter, (SDnodeObj **)&pDnode);
+    pShow->pIter = mnodeGetNextDnode(pShow->pIter, (SDnodeObj **)&pDnode);
     if (pDnode == NULL) break;
 
     for (int32_t moduleType = 0; moduleType < TSDB_MOD_MAX; ++moduleType) {
@@ -683,8 +682,8 @@ int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pCo
 
       pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
       switch (moduleType) {
-        case TSDB_MOD_MGMT:
+        case TSDB_MOD_MNODE:
-          strcpy(pWrite, "mgmt");
+          strcpy(pWrite, "mnode");
           break;
         case TSDB_MOD_HTTP:
           strcpy(pWrite, "http");
@@ -698,34 +697,34 @@ int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pCo
       cols++;
 
       pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      bool enable = mgmtCheckModuleInDnode(pDnode, moduleType);
+      bool enable = mnodeCheckModuleInDnode(pDnode, moduleType);
       strcpy(pWrite, enable ? "enable" : "disable");
       cols++;
 
       numOfRows++;
     }
 
-    mgmtDecDnodeRef(pDnode);
+    mnodeDecDnodeRef(pDnode);
   }
 
   pShow->numOfReads += numOfRows;
   return numOfRows;
 }
 
-static bool mgmtCheckConfigShow(SGlobalCfg *cfg) {
+static bool mnodeCheckConfigShow(SGlobalCfg *cfg) {
   if (!(cfg->cfgType & TSDB_CFG_CTYPE_B_SHOW))
     return false;
   return true;
 }
 
-static int32_t mgmtGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mnodeGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
-  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  SUserObj *pUser = mnodeGetUserFromConn(pConn);
   if (pUser == NULL) return 0;
 
   if (strcmp(pUser->user, "root") != 0)  {
-    mgmtDecUserRef(pUser);
+    mnodeDecUserRef(pUser);
     return TSDB_CODE_NO_RIGHTS;
   }
 
@@ -752,23 +751,23 @@ static int32_t mgmtGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pC
   pShow->numOfRows = 0;
   for (int32_t i = tsGlobalConfigNum - 1; i >= 0; --i) {
     SGlobalCfg *cfg = tsGlobalConfig + i;
-    if (!mgmtCheckConfigShow(cfg)) continue;
+    if (!mnodeCheckConfigShow(cfg)) continue;
     pShow->numOfRows++;
   }
 
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
   pShow->pIter = NULL;
-  mgmtDecUserRef(pUser);
+  mnodeDecUserRef(pUser);
 
   return 0;
 }
 
-static int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+static int32_t mnodeRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t numOfRows = 0;
 
   for (int32_t i = tsGlobalConfigNum - 1; i >= 0 && numOfRows < rows; --i) {
     SGlobalCfg *cfg = tsGlobalConfig + i;
-    if (!mgmtCheckConfigShow(cfg)) continue;
+    if (!mnodeCheckConfigShow(cfg)) continue;
 
     char *pWrite;
     int32_t   cols = 0;
@@ -806,13 +805,13 @@ static int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, vo
   return numOfRows;
 }
 
-static int32_t mgmtGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mnodeGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
-  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  SUserObj *pUser = mnodeGetUserFromConn(pConn);
   if (pUser == NULL) return 0;
   
   if (strcmp(pUser->user, "root") != 0)  {
-    mgmtDecUserRef(pUser);
+    mnodeDecUserRef(pUser);
     return TSDB_CODE_NO_RIGHTS;
   }
 
@@ -838,25 +837,25 @@ static int32_t mgmtGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCo
 
   SDnodeObj *pDnode = NULL;
   if (pShow->payloadLen > 0 ) {
-    pDnode = mgmtGetDnodeByEp(pShow->payload);
+    pDnode = mnodeGetDnodeByEp(pShow->payload);
   } else {
-    void *pIter = mgmtGetNextDnode(NULL, (SDnodeObj **)&pDnode);
+    void *pIter = mnodeGetNextDnode(NULL, (SDnodeObj **)&pDnode);
     sdbFreeIter(pIter);
   }
 
   if (pDnode != NULL) {
     pShow->numOfRows += pDnode->openVnodes;
-    mgmtDecDnodeRef(pDnode);
+    mnodeDecDnodeRef(pDnode);
   }
 
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
   pShow->pIter = pDnode;
-  mgmtDecUserRef(pUser);
+  mnodeDecUserRef(pUser);
 
   return 0;
 }
 
-static int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+static int32_t mnodeRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t    numOfRows = 0;
   SDnodeObj *pDnode = NULL;
   char *     pWrite;
@@ -869,7 +868,7 @@ static int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, voi
     void *pIter = NULL;
     SVgObj *pVgroup;
     while (1) {
-      pIter = mgmtGetNextVgroup(pIter, &pVgroup);
+      pIter = mnodeGetNextVgroup(pIter, &pVgroup);
       if (pVgroup == NULL) break;
 
       for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
@@ -882,12 +881,12 @@ static int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, voi
           cols++;
 
           pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-          strcpy(pWrite, mgmtGetMnodeRoleStr(pVgid->role));
+          strcpy(pWrite, mnodeGetMnodeRoleStr(pVgid->role));
           cols++;
         }
       }
 
-      mgmtDecVgroupRef(pVgroup);
+      mnodeDecVgroupRef(pVgroup);
     }
     sdbFreeIter(pIter);
   } else {
@@ -898,7 +897,7 @@ static int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, voi
   return numOfRows;
 }
 
-char* mgmtGetDnodeStatusStr(int32_t dnodeStatus) {
+char* mnodeGetDnodeStatusStr(int32_t dnodeStatus) {
   switch (dnodeStatus) {
     case TAOS_DN_STATUS_OFFLINE:   return "offline";
     case TAOS_DN_STATUS_DROPPING:  return "dropping";
@@ -907,3 +906,13 @@ char* mgmtGetDnodeStatusStr(int32_t dnodeStatus) {
     default:                       return "undefined";
   }
 }
+
+static char* mnodeGetDnodeAlternativeRoleStr(int32_t alternativeRole) {
+  switch (alternativeRole) {
+    case TAOS_DN_ALTERNATIVE_ROLE_ANY: return "any";
+    case TAOS_DN_ALTERNATIVE_ROLE_MNODE: return "mnode";
+    case TAOS_DN_ALTERNATIVE_ROLE_VNODE: return "vnode";
+    default:return "any";
+  }
+}
+

src/mnode/src/mnodeGrant.c

@@ -18,7 +18,7 @@
 #include "os.h"
 #include "taoserror.h"
 #include "tgrant.h"
-#include "mgmtInt.h"
+#include "mnodeInt.h"
 
 int32_t grantInit() { return TSDB_CODE_SUCCESS; }
 void    grantCleanUp() {}

src/mnode/src/mnodeInt.c

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "taosmsg.h"
+#include "taoserror.h"
+#include "trpc.h"
+#include "tcache.h"
+#include "mnode.h"
+#include "dnode.h"
+#include "mnodeDef.h"
+#include "mnodeInt.h"
+#include "mnodeAcct.h"
+#include "mnodeDb.h"
+#include "mnodeDnode.h"
+#include "mnodeMnode.h"
+#include "mnodeProfile.h"
+#include "mnodeSdb.h"
+#include "mnodeShow.h"
+#include "mnodeTable.h"
+#include "mnodeUser.h"
+#include "mnodeVgroup.h"
+
+void mnodeCreateMsg(SMnodeMsg *pMsg, SRpcMsg *rpcMsg) {
+  pMsg->rpcMsg = *rpcMsg;
+}
+
+int32_t mnodeInitMsg(SMnodeMsg *pMsg) {
+  pMsg->pUser = mnodeGetUserFromConn(pMsg->rpcMsg.handle);
+  if (pMsg->pUser == NULL) {
+    return TSDB_CODE_INVALID_USER;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+void mnodeCleanupMsg(SMnodeMsg *pMsg) {
+  if (pMsg != NULL) {
+    if (pMsg->rpcMsg.pCont) rpcFreeCont(pMsg->rpcMsg.pCont);
+    if (pMsg->pUser) mnodeDecUserRef(pMsg->pUser);
+    if (pMsg->pDb) mnodeDecDbRef(pMsg->pDb);
+    if (pMsg->pVgroup) mnodeDecVgroupRef(pMsg->pVgroup);
+    if (pMsg->pTable) mnodeDecTableRef(pMsg->pTable);
+    if (pMsg->pAcct) mnodeDecAcctRef(pMsg->pAcct);
+    if (pMsg->pDnode) mnodeDecDnodeRef(pMsg->pDnode);
+  }
+}

src/mnode/src/mnodeMain.c

@@ -22,65 +22,72 @@
 #include "ttimer.h"
 #include "tglobal.h"
 #include "dnode.h"
-#include "mgmtDef.h"
+#include "mnodeDef.h"
-#include "mgmtInt.h"
+#include "mnodeInt.h"
-#include "mgmtServer.h"
+#include "mnodeAcct.h"
-#include "mgmtAcct.h"
+#include "mnodeDnode.h"
-#include "mgmtDnode.h"
+#include "mnodeMnode.h"
-#include "mgmtMnode.h"
+#include "mnodeDb.h"
-#include "mgmtDb.h"
+#include "mnodeSdb.h"
-#include "mgmtSdb.h"
+#include "mnodeVgroup.h"
-#include "mgmtVgroup.h"
+#include "mnodeUser.h"
-#include "mgmtUser.h"
+#include "mnodeTable.h"
-#include "mgmtTable.h"
+#include "mnodeShow.h"
-#include "mgmtShell.h"
 
-extern void *tsMgmtTmr;
+void *tsMnodeTmr;
 static bool tsMgmtIsRunning = false;
 
-int32_t mgmtStartSystem() {
+static void mnodeInitTimer();
+static void mnodeCleanupTimer();
+static bool mnodeNeedStart() ;
+
+int32_t mnodeStartSystem() {
   if (tsMgmtIsRunning) {
-    mPrint("TDengine mgmt module already started...");
+    mPrint("mnode module already started...");
     return 0;
   }
 
-  mPrint("starting to initialize TDengine mgmt ...");
+  mPrint("starting to initialize mnode ...");
   struct stat dirstat;
   if (stat(tsMnodeDir, &dirstat) < 0) {
     mkdir(tsMnodeDir, 0755);
   }
 
-  if (mgmtInitAccts() < 0) {
+  dnodeAllocateMnodeWqueue();
+  dnodeAllocateMnodeRqueue();
+  dnodeAllocateMnodePqueue();
+
+  if (mnodeInitAccts() < 0) {
     mError("failed to init accts");
     return -1;
   }
 
-  if (mgmtInitUsers() < 0) {
+  if (mnodeInitUsers() < 0) {
     mError("failed to init users");
     return -1;
   }
 
-  if (mgmtInitDnodes() < 0) {
+  if (mnodeInitDnodes() < 0) {
     mError("failed to init dnodes");
     return -1;
   }
 
-  if (mgmtInitDbs() < 0) {
+  if (mnodeInitDbs() < 0) {
     mError("failed to init dbs");
     return -1;
   }
 
-  if (mgmtInitVgroups() < 0) {
+  if (mnodeInitVgroups() < 0) {
     mError("failed to init vgroups");
     return -1;
   }
 
-  if (mgmtInitTables() < 0) {
+  if (mnodeInitTables() < 0) {
     mError("failed to init tables");
     return -1;
   }
 
-  if (mgmtInitMnodes() < 0) {
+  if (mnodeInitMnodes() < 0) {
     mError("failed to init mnodes");
     return -1;
   }
@@ -99,63 +106,83 @@ int32_t mgmtStartSystem() {
     return -1;
   }
 
-  if (mgmtInitServer() < 0) {
+  if (mnodeInitShow() < 0) {
+    mError("failed to init show");
     return -1;
   }
 
   grantReset(TSDB_GRANT_ALL, 0);
   tsMgmtIsRunning = true;
 
-  mPrint("TDengine mgmt is initialized successfully");
+  mPrint("mnode is initialized successfully");
 
   return 0;
 }
 
-int32_t mgmtInitSystem() {
+int32_t mnodeInitSystem() {
-  if (mgmtInitShell() != 0) {
+  mnodeInitTimer();
-    mError("failed to init shell");
+  if (!mnodeNeedStart()) return 0;
-    return -1;
+  return mnodeStartSystem();
 }
 
+void mnodeCleanupSystem() {
+  mPrint("starting to clean up mnode");
+  tsMgmtIsRunning = false;
+
+  dnodeFreeMnodeWqueue();
+  dnodeFreeMnodeRqueue();
+  dnodeFreeMnodePqueue();
+  mnodeCleanupTimer();
+  mnodeCleanUpShow();
+  grantCleanUp();
+  balanceCleanUp();
+  sdbCleanUp();
+  mnodeCleanupMnodes();
+  mnodeCleanupTables();
+  mnodeCleanupVgroups();
+  mnodeCleanupDbs();
+  mnodeCleanupDnodes();
+  mnodeCleanupUsers();
+  mnodeCleanupAccts();
+  mPrint("mnode is cleaned up");
+}
+
+void mnodeStopSystem() {
+  if (sdbIsMaster()) {
+    mTrace("it is a master mnode, it could not be stopped");
+    return;
+  }
+  
+  mnodeCleanupSystem();
+  mPrint("mnode file is removed");
+  remove(tsMnodeDir);
+}
+
+static void mnodeInitTimer() {
+  if (tsMnodeTmr == NULL) {
+    tsMnodeTmr = taosTmrInit(tsMaxShellConns, 200, 3600000, "MND");
+  }
+}
+
+static void mnodeCleanupTimer() {
+  if (tsMnodeTmr != NULL) {
+    taosTmrCleanUp(tsMnodeTmr);
+    tsMnodeTmr = NULL;
+  }
+}
+
+static bool mnodeNeedStart() {
   struct stat dirstat;
   bool fileExist = (stat(tsMnodeDir, &dirstat) == 0);
   bool asMaster = (strcmp(tsFirst, tsLocalEp) == 0);
 
   if (asMaster || fileExist) {
-    if (mgmtStartSystem() != 0) {
+    return true;
-      return -1;
-    }
   }
 
-  return 0;
+  return false;
 }
 
-void mgmtCleanUpSystem() {
+bool mnodeIsRunning() {
-  mPrint("starting to clean up mgmt");
+  return tsMgmtIsRunning;
-  tsMgmtIsRunning = false;
-  mgmtCleanUpShell();
-  mgmtCleanupServer();
-  grantCleanUp();
-  balanceCleanUp();
-  sdbCleanUp();
-  mgmtCleanupMnodes();
-  mgmtCleanUpTables();
-  mgmtCleanUpVgroups();
-  mgmtCleanUpDbs();
-  mgmtCleanupDnodes();
-  mgmtCleanUpUsers();
-  mgmtCleanUpAccts();
-  mPrint("mgmt is cleaned up");
-}
-
-void mgmtStopSystem() {
-  if (sdbIsMaster()) {
-    mTrace("it is a master mgmt node, it could not be stopped");
-    return;
-  }
-
-  mgmtCleanUpSystem();
-
-  mPrint("mgmt file is removed");
-  remove(tsMnodeDir);
 }

src/mnode/src/mnodeMnode.c

@@ -23,85 +23,85 @@
 #include "ttime.h"
 #include "tsocket.h"
 #include "tdataformat.h"
-#include "mgmtDef.h"
+#include "mnodeDef.h"
-#include "mgmtInt.h"
+#include "mnodeInt.h"
-#include "mgmtMnode.h"
+#include "mnodeMnode.h"
-#include "mgmtDnode.h"
+#include "mnodeDnode.h"
-#include "mgmtSdb.h"
+#include "mnodeSdb.h"
-#include "mgmtShell.h"
+#include "mnodeShow.h"
-#include "mgmtUser.h"
+#include "mnodeUser.h"
 
 static void *        tsMnodeSdb = NULL;
 static int32_t       tsMnodeUpdateSize = 0;
-static int32_t mgmtGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
+static SRpcIpSet     tsMnodeIpSetForShell;
-static int32_t mgmtRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
+static SRpcIpSet     tsMnodeIpSetForPeer;
-
-static SRpcIpSet tsMnodeRpcIpSet;
 static SDMMnodeInfos tsMnodeInfos;
+static int32_t mnodeGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mnodeRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
 #if defined(LINUX)
   static pthread_rwlock_t         tsMnodeLock;
-  #define mgmtMnodeWrLock()      pthread_rwlock_wrlock(&tsMnodeLock)
+  #define mnodeMnodeWrLock()      pthread_rwlock_wrlock(&tsMnodeLock)
-  #define mgmtMnodeRdLock()      pthread_rwlock_rdlock(&tsMnodeLock)
+  #define mnodeMnodeRdLock()      pthread_rwlock_rdlock(&tsMnodeLock)
-  #define mgmtMnodeUnLock()      pthread_rwlock_unlock(&tsMnodeLock)
+  #define mnodeMnodeUnLock()      pthread_rwlock_unlock(&tsMnodeLock)
-  #define mgmtMnodeInitLock()    pthread_rwlock_init(&tsMnodeLock, NULL)
+  #define mnodeMnodeInitLock()    pthread_rwlock_init(&tsMnodeLock, NULL)
-  #define mgmtMnodeDestroyLock() pthread_rwlock_destroy(&tsMnodeLock)
+  #define mnodeMnodeDestroyLock() pthread_rwlock_destroy(&tsMnodeLock)
 #else
   static pthread_mutex_t          tsMnodeLock;
-  #define mgmtMnodeWrLock()      pthread_mutex_lock(&tsMnodeLock)
+  #define mnodeMnodeWrLock()      pthread_mutex_lock(&tsMnodeLock)
-  #define mgmtMnodeRdLock()      pthread_mutex_lock(&tsMnodeLock)
+  #define mnodeMnodeRdLock()      pthread_mutex_lock(&tsMnodeLock)
-  #define mgmtMnodeUnLock()      pthread_mutex_unlock(&tsMnodeLock)
+  #define mnodeMnodeUnLock()      pthread_mutex_unlock(&tsMnodeLock)
-  #define mgmtMnodeInitLock()    pthread_mutex_init(&tsMnodeLock, NULL)
+  #define mnodeMnodeInitLock()    pthread_mutex_init(&tsMnodeLock, NULL)
-  #define mgmtMnodeDestroyLock() pthread_mutex_destroy(&tsMnodeLock)
+  #define mnodeMnodeDestroyLock() pthread_mutex_destroy(&tsMnodeLock)
 #endif
 
-static int32_t mgmtMnodeActionDestroy(SSdbOper *pOper) {
+static int32_t mnodeMnodeActionDestroy(SSdbOper *pOper) {
   tfree(pOper->pObj);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtMnodeActionInsert(SSdbOper *pOper) {
+static int32_t mnodeMnodeActionInsert(SSdbOper *pOper) {
   SMnodeObj *pMnode = pOper->pObj;
-  SDnodeObj *pDnode = mgmtGetDnode(pMnode->mnodeId);
+  SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
   if (pDnode == NULL) return TSDB_CODE_DNODE_NOT_EXIST;
 
   pDnode->isMgmt = true;
-  mgmtDecDnodeRef(pDnode);
+  mnodeDecDnodeRef(pDnode);
   
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtMnodeActionDelete(SSdbOper *pOper) {
+static int32_t mnodeMnodeActionDelete(SSdbOper *pOper) {
   SMnodeObj *pMnode = pOper->pObj;
 
-  SDnodeObj *pDnode = mgmtGetDnode(pMnode->mnodeId);
+  SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
   if (pDnode == NULL) return TSDB_CODE_DNODE_NOT_EXIST;
   pDnode->isMgmt = false;
-  mgmtDecDnodeRef(pDnode);
+  mnodeDecDnodeRef(pDnode);
 
   mTrace("mnode:%d, is dropped from sdb", pMnode->mnodeId);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtMnodeActionUpdate(SSdbOper *pOper) {
+static int32_t mnodeMnodeActionUpdate(SSdbOper *pOper) {
   SMnodeObj *pMnode = pOper->pObj;
-  SMnodeObj *pSaved = mgmtGetMnode(pMnode->mnodeId);
+  SMnodeObj *pSaved = mnodeGetMnode(pMnode->mnodeId);
   if (pMnode != pSaved) {
     memcpy(pSaved, pMnode, pOper->rowSize);
     free(pMnode);
   }
-  mgmtDecMnodeRef(pSaved);
+  mnodeDecMnodeRef(pSaved);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtMnodeActionEncode(SSdbOper *pOper) {
+static int32_t mnodeMnodeActionEncode(SSdbOper *pOper) {
   SMnodeObj *pMnode = pOper->pObj;
   memcpy(pOper->rowData, pMnode, tsMnodeUpdateSize);
   pOper->rowSize = tsMnodeUpdateSize;
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtMnodeActionDecode(SSdbOper *pOper) {
+static int32_t mnodeMnodeActionDecode(SSdbOper *pOper) {
   SMnodeObj *pMnode = calloc(1, sizeof(SMnodeObj));
   if (pMnode == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY;
 
@@ -110,24 +110,24 @@ static int32_t mgmtMnodeActionDecode(SSdbOper *pOper) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtMnodeActionRestored() {
+static int32_t mnodeMnodeActionRestored() {
-  if (mgmtGetMnodesNum() == 1) {
+  if (mnodeGetMnodesNum() == 1) {
     SMnodeObj *pMnode = NULL;
-    void *pIter = mgmtGetNextMnode(NULL, &pMnode);
+    void *pIter = mnodeGetNextMnode(NULL, &pMnode);
     if (pMnode != NULL) {
       pMnode->role = TAOS_SYNC_ROLE_MASTER;
-      mgmtDecMnodeRef(pMnode);
+      mnodeDecMnodeRef(pMnode);
     }
     sdbFreeIter(pIter);
   }
 
-  mgmtUpdateMnodeIpSet();
+  mnodeUpdateMnodeIpSet();
 
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t mgmtInitMnodes() {
+int32_t mnodeInitMnodes() {
-  mgmtMnodeInitLock();
+  mnodeMnodeInitLock();
 
   SMnodeObj tObj;
   tsMnodeUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
@@ -139,13 +139,13 @@ int32_t mgmtInitMnodes() {
     .maxRowSize   = tsMnodeUpdateSize,
     .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
     .keyType      = SDB_KEY_INT,
-    .insertFp     = mgmtMnodeActionInsert,
+    .insertFp     = mnodeMnodeActionInsert,
-    .deleteFp     = mgmtMnodeActionDelete,
+    .deleteFp     = mnodeMnodeActionDelete,
-    .updateFp     = mgmtMnodeActionUpdate,
+    .updateFp     = mnodeMnodeActionUpdate,
-    .encodeFp     = mgmtMnodeActionEncode,
+    .encodeFp     = mnodeMnodeActionEncode,
-    .decodeFp     = mgmtMnodeActionDecode,
+    .decodeFp     = mnodeMnodeActionDecode,
-    .destroyFp    = mgmtMnodeActionDestroy,
+    .destroyFp    = mnodeMnodeActionDestroy,
-    .restoredFp   = mgmtMnodeActionRestored
+    .restoredFp   = mnodeMnodeActionRestored
   };
 
   tsMnodeSdb = sdbOpenTable(&tableDesc);
@@ -154,39 +154,39 @@ int32_t mgmtInitMnodes() {
     return -1;
   }
 
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_MNODE, mgmtGetMnodeMeta);
+  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_MNODE, mnodeGetMnodeMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_MNODE, mgmtRetrieveMnodes);
+  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_MNODE, mnodeRetrieveMnodes);
 
   mTrace("table:mnodes table is created");
   return TSDB_CODE_SUCCESS;
 }
 
-void mgmtCleanupMnodes() {
+void mnodeCleanupMnodes() {
   sdbCloseTable(tsMnodeSdb);
-  mgmtMnodeDestroyLock();
+  mnodeMnodeDestroyLock();
 }
 
-int32_t mgmtGetMnodesNum() { 
+int32_t mnodeGetMnodesNum() { 
   return sdbGetNumOfRows(tsMnodeSdb); 
 }
 
-void *mgmtGetMnode(int32_t mnodeId) {
+void *mnodeGetMnode(int32_t mnodeId) {
   return sdbGetRow(tsMnodeSdb, &mnodeId);
 }
 
-void mgmtIncMnodeRef(SMnodeObj *pMnode) {
+void mnodeIncMnodeRef(SMnodeObj *pMnode) {
   sdbIncRef(tsMnodeSdb, pMnode);
 }
 
-void mgmtDecMnodeRef(SMnodeObj *pMnode) {
+void mnodeDecMnodeRef(SMnodeObj *pMnode) {
   sdbDecRef(tsMnodeSdb, pMnode);
 }
 
-void *mgmtGetNextMnode(void *pIter, SMnodeObj **pMnode) { 
+void *mnodeGetNextMnode(void *pIter, SMnodeObj **pMnode) { 
   return sdbFetchRow(tsMnodeSdb, pIter, (void **)pMnode); 
 }
 
-char *mgmtGetMnodeRoleStr(int32_t role) {
+char *mnodeGetMnodeRoleStr(int32_t role) {
   switch (role) {
     case TAOS_SYNC_ROLE_OFFLINE:
       return "offline";
@@ -201,68 +201,77 @@ char *mgmtGetMnodeRoleStr(int32_t role) {
   }
 }
 
-void mgmtUpdateMnodeIpSet() {
+void mnodeUpdateMnodeIpSet() {
-  SRpcIpSet *ipSet = &tsMnodeRpcIpSet;
+  mPrint("update mnodes ipset, numOfIps:%d ", mnodeGetMnodesNum());
-  SDMMnodeInfos *mnodes = &tsMnodeInfos;
 
-  mPrint("update mnodes ipset, numOfIps:%d ", mgmtGetMnodesNum());
+  mnodeMnodeWrLock();
 
-  mgmtMnodeWrLock();
+  memset(&tsMnodeIpSetForShell, 0, sizeof(SRpcIpSet));
-
+  memset(&tsMnodeIpSetForPeer, 0, sizeof(SRpcIpSet));
-  memset(ipSet, 0, sizeof(tsMnodeRpcIpSet));
+  memset(&tsMnodeInfos, 0, sizeof(SDMMnodeInfos));
-  memset(mnodes, 0, sizeof(SDMMnodeInfos));
 
   int32_t index = 0;
   void *  pIter = NULL;
   while (1) {
     SMnodeObj *pMnode = NULL;
-    pIter = mgmtGetNextMnode(pIter, &pMnode);
+    pIter = mnodeGetNextMnode(pIter, &pMnode);
     if (pMnode == NULL) break;
 
-    SDnodeObj *pDnode = mgmtGetDnode(pMnode->mnodeId);
+    SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
     if (pDnode != NULL) {
-      strcpy(ipSet->fqdn[ipSet->numOfIps], pDnode->dnodeFqdn);
+      strcpy(tsMnodeIpSetForShell.fqdn[index], pDnode->dnodeFqdn);
-      ipSet->port[ipSet->numOfIps] = htons(pDnode->dnodePort);
+      tsMnodeIpSetForShell.port[index] = htons(pDnode->dnodePort);
+      mTrace("mnode:%d, for shell fqdn:%s %d", pDnode->dnodeId, tsMnodeIpSetForShell.fqdn[index], htons(tsMnodeIpSetForShell.port[index]));      
 
-      mnodes->nodeInfos[index].nodeId = htonl(pMnode->mnodeId);
+      strcpy(tsMnodeIpSetForPeer.fqdn[index], pDnode->dnodeFqdn);
-      strcpy(mnodes->nodeInfos[index].nodeEp, pDnode->dnodeEp);
+      tsMnodeIpSetForPeer.port[index] = htons(pDnode->dnodePort + TSDB_PORT_DNODEDNODE);
+      mTrace("mnode:%d, for peer fqdn:%s %d", pDnode->dnodeId, tsMnodeIpSetForPeer.fqdn[index], htons(tsMnodeIpSetForPeer.port[index]));
+
+      tsMnodeInfos.nodeInfos[index].nodeId = htonl(pMnode->mnodeId);
+      strcpy(tsMnodeInfos.nodeInfos[index].nodeEp, pDnode->dnodeEp);
 
       if (pMnode->role == TAOS_SYNC_ROLE_MASTER) {
-        ipSet->inUse = ipSet->numOfIps;
+        tsMnodeIpSetForShell.inUse = index;
-        mnodes->inUse = index;
+        tsMnodeIpSetForPeer.inUse = index;
+        tsMnodeInfos.inUse = index;
       }
 
-      mPrint("mnode:%d, ep:%s %s", index, pDnode->dnodeEp,
+      mPrint("mnode:%d, ep:%s %s", pDnode->dnodeId, pDnode->dnodeEp, pMnode->role == TAOS_SYNC_ROLE_MASTER ? "master" : "");
-             pMnode->role == TAOS_SYNC_ROLE_MASTER ? "master" : "");
-
-      ipSet->numOfIps++;
       index++;
     }
 
-    mgmtDecDnodeRef(pDnode);
+    mnodeDecDnodeRef(pDnode);
-    mgmtDecMnodeRef(pMnode);
+    mnodeDecMnodeRef(pMnode);
   }
 
-  mnodes->nodeNum = index;
+  tsMnodeInfos.nodeNum = index;
+  tsMnodeIpSetForShell.numOfIps = index;
+  tsMnodeIpSetForPeer.numOfIps = index;
 
   sdbFreeIter(pIter);
 
-  mgmtMnodeUnLock();
+  mnodeMnodeUnLock();
 }
 
-void mgmtGetMnodeIpSet(SRpcIpSet *ipSet) {
+void mnodeGetMnodeIpSetForPeer(SRpcIpSet *ipSet) {
-  mgmtMnodeRdLock();
+  mnodeMnodeRdLock();
-  *ipSet = tsMnodeRpcIpSet;
+  *ipSet = tsMnodeIpSetForPeer;
-  mgmtMnodeUnLock();
+  mnodeMnodeUnLock();
 }
 
-void mgmtGetMnodeInfos(void *mnodeInfos) {
+void mnodeGetMnodeIpSetForShell(SRpcIpSet *ipSet) {
-  mgmtMnodeRdLock();
+  mnodeMnodeRdLock();
+  *ipSet = tsMnodeIpSetForShell;
+  mnodeMnodeUnLock();
+}
+
+void mnodeGetMnodeInfos(void *mnodeInfos) {
+  mnodeMnodeRdLock();
   *(SDMMnodeInfos *)mnodeInfos = tsMnodeInfos;
-  mgmtMnodeUnLock();
+  mnodeMnodeUnLock();
 }
 
-int32_t mgmtAddMnode(int32_t dnodeId) {
+int32_t mnodeAddMnode(int32_t dnodeId) {
   SMnodeObj *pMnode = calloc(1, sizeof(SMnodeObj));
   pMnode->mnodeId = dnodeId;
   pMnode->createdTime = taosGetTimestampMs();
@@ -279,24 +288,24 @@ int32_t mgmtAddMnode(int32_t dnodeId) {
     code = TSDB_CODE_SDB_ERROR;
   }
 
-  mgmtUpdateMnodeIpSet();
+  mnodeUpdateMnodeIpSet();
 
   return code;
 }
 
-void mgmtDropMnodeLocal(int32_t dnodeId) {
+void mnodeDropMnodeLocal(int32_t dnodeId) {
-  SMnodeObj *pMnode = mgmtGetMnode(dnodeId);
+  SMnodeObj *pMnode = mnodeGetMnode(dnodeId);
   if (pMnode != NULL) {
     SSdbOper oper = {.type = SDB_OPER_LOCAL, .table = tsMnodeSdb, .pObj = pMnode};
     sdbDeleteRow(&oper);
-    mgmtDecMnodeRef(pMnode);
+    mnodeDecMnodeRef(pMnode);
   }
 
-  mgmtUpdateMnodeIpSet();
+  mnodeUpdateMnodeIpSet();
 }
 
-int32_t mgmtDropMnode(int32_t dnodeId) {
+int32_t mnodeDropMnode(int32_t dnodeId) {
-  SMnodeObj *pMnode = mgmtGetMnode(dnodeId);
+  SMnodeObj *pMnode = mnodeGetMnode(dnodeId);
   if (pMnode == NULL) {
     return TSDB_CODE_DNODE_NOT_EXIST;
   }
@@ -314,18 +323,18 @@ int32_t mgmtDropMnode(int32_t dnodeId) {
 
   sdbDecRef(tsMnodeSdb, pMnode);
 
-  mgmtUpdateMnodeIpSet();
+  mnodeUpdateMnodeIpSet();
 
   return code;
 }
 
-static int32_t mgmtGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mnodeGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   sdbUpdateMnodeRoles();
-  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  SUserObj *pUser = mnodeGetUserFromConn(pConn);
   if (pUser == NULL) return 0;
 
   if (strcmp(pUser->pAcct->user, "root") != 0)  {
-    mgmtDecUserRef(pUser);
+    mnodeDecUserRef(pUser);
     return TSDB_CODE_NO_RIGHTS;
   }
 
@@ -364,22 +373,22 @@ static int32_t mgmtGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCo
     pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
   }
 
-  pShow->numOfRows = mgmtGetMnodesNum();
+  pShow->numOfRows = mnodeGetMnodesNum();
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
   pShow->pIter = NULL;
-  mgmtDecUserRef(pUser);
+  mnodeDecUserRef(pUser);
 
   return 0;
 }
 
-static int32_t mgmtRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+static int32_t mnodeRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t    numOfRows = 0;
   int32_t    cols      = 0;
   SMnodeObj *pMnode   = NULL;
   char      *pWrite;
 
   while (numOfRows < rows) {
-    pShow->pIter = mgmtGetNextMnode(pShow->pIter, &pMnode);
+    pShow->pIter = mnodeGetNextMnode(pShow->pIter, &pMnode);
     if (pMnode == NULL) break;
 
     cols = 0;
@@ -390,18 +399,18 @@ static int32_t mgmtRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, voi
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
     
-    SDnodeObj *pDnode = mgmtGetDnode(pMnode->mnodeId);
+    SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
     if (pDnode != NULL) {
       STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDnode->dnodeEp, pShow->bytes[cols] - VARSTR_HEADER_SIZE);
     } else {
       STR_WITH_MAXSIZE_TO_VARSTR(pWrite, "invalid ep", pShow->bytes[cols] - VARSTR_HEADER_SIZE);
     }
-    mgmtDecDnodeRef(pDnode);
+    mnodeDecDnodeRef(pDnode);
 
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    char* roles = mgmtGetMnodeRoleStr(pMnode->role);
+    char* roles = mnodeGetMnodeRoleStr(pMnode->role);
     STR_TO_VARSTR(pWrite, roles);
     cols++;
 
@@ -411,7 +420,7 @@ static int32_t mgmtRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, voi
     
     numOfRows++;
 
-    mgmtDecMnodeRef(pMnode);
+    mnodeDecMnodeRef(pMnode);
   }
 
   pShow->numOfReads += numOfRows;

src/mnode/src/mnodePeer.c

@@ -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/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "taoserror.h"
+#include "tsched.h"
+#include "tsystem.h"
+#include "tutil.h"
+#include "tgrant.h"
+#include "tbalance.h"
+#include "tglobal.h"
+#include "mnode.h"
+#include "dnode.h"
+#include "mnodeDef.h"
+#include "mnodeInt.h"
+#include "mnodeDb.h"
+#include "mnodeMnode.h"
+#include "mnodeProfile.h"
+#include "mnodeShow.h"
+#include "mnodeSdb.h"
+#include "mnodeTable.h"
+#include "mnodeVgroup.h"
+
+static int32_t (*tsMnodeProcessPeerMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *);
+static void (*tsMnodeProcessPeerRspFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *);
+
+void mnodeAddPeerMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg)) {
+  tsMnodeProcessPeerMsgFp[msgType] = fp;
+}
+
+void mnodeAddPeerRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)) {
+  tsMnodeProcessPeerRspFp[msgType] = fp;
+}
+
+int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg) {
+  if (pMsg->rpcMsg.pCont == NULL) {
+    mError("%p, msg:%s in mpeer queue, content is null", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
+    return TSDB_CODE_INVALID_MSG_LEN;
+  }
+
+  if (!sdbIsMaster()) {
+    SMnodeRsp *rpcRsp = &pMsg->rpcRsp;
+    SRpcIpSet *ipSet = rpcMallocCont(sizeof(SRpcIpSet));
+    mnodeGetMnodeIpSetForPeer(ipSet);
+    rpcRsp->rsp = ipSet;
+    rpcRsp->len = sizeof(SRpcIpSet);
+
+    mTrace("%p, msg:%s in mpeer queue, will be redireced inUse:%d", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], ipSet->inUse);
+    for (int32_t i = 0; i < ipSet->numOfIps; ++i) {
+      mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i]));
+    }
+
+    return TSDB_CODE_REDIRECT;
+  }
+
+  if (tsMnodeProcessPeerMsgFp[pMsg->rpcMsg.msgType] == NULL) {
+    mError("%p, msg:%s in mpeer queue, not processed", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
+    return TSDB_CODE_MSG_NOT_PROCESSED;
+  }
+
+  return (*tsMnodeProcessPeerMsgFp[pMsg->rpcMsg.msgType])(pMsg);
+}
+
+void mnodeProcessPeerRsp(SRpcMsg *pMsg) {
+  if (tsMnodeProcessPeerRspFp[pMsg->msgType]) {
+    (*tsMnodeProcessPeerRspFp[pMsg->msgType])(pMsg);
+  } else {
+    mError("%p, msg:%s is not processed", pMsg->ahandle, taosMsg[pMsg->msgType]);
+  }
+}

src/mnode/src/mnodeProfile.c

@@ -18,23 +18,25 @@
 #include "taosmsg.h"
 #include "taoserror.h"
 #include "tutil.h"
-#include "mgmtDef.h"
+#include "mnode.h"
-#include "mgmtInt.h"
+#include "mnodeDef.h"
-#include "mgmtAcct.h"
+#include "mnodeInt.h"
-#include "mgmtDnode.h"
+#include "mnodeAcct.h"
-#include "mgmtDb.h"
+#include "mnodeDnode.h"
-#include "mgmtMnode.h"
+#include "mnodeDb.h"
-#include "mgmtProfile.h"
+#include "mnodeMnode.h"
-#include "mgmtShell.h"
+#include "mnodeProfile.h"
-#include "mgmtTable.h"
+#include "mnodeShow.h"
-#include "mgmtUser.h"
+#include "mnodeTable.h"
-#include "mgmtVgroup.h"
+#include "mnodeUser.h"
+#include "mnodeVgroup.h"
+#include "mnodeWrite.h"
 
-int32_t mgmtSaveQueryStreamList(SCMHeartBeatMsg *pHBMsg);
+int32_t mnodeSaveQueryStreamList(SCMHeartBeatMsg *pHBMsg);
 
-int32_t mgmtKillQuery(char *qidstr, void *pConn);
+int32_t mnodeKillQuery(char *qidstr, void *pConn);
-int32_t mgmtKillStream(char *qidstr, void *pConn);
+int32_t mnodeKillStream(char *qidstr, void *pConn);
-int32_t mgmtKillConnection(char *qidstr, void *pConn);
+int32_t mnodeKillConnection(char *qidstr, void *pConn);
 
 typedef struct {
   char     user[TSDB_TABLE_ID_LEN + 1];
@@ -98,7 +100,7 @@ int32_t  mgmtSaveQueryStreamList(SCMHeartBeatMsg *pHBMsg) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t mgmtGetQueries(SShowObj *pShow, void *pConn) {
+int32_t mnodeGetQueries(SShowObj *pShow, void *pConn) {
 //  SAcctObj *  pAcct = pConn->pAcct;
 //  SQueryShow *pQueryShow;
 //
@@ -145,7 +147,7 @@ int32_t mgmtGetQueries(SShowObj *pShow, void *pConn) {
   return 0;
 }
 
-int32_t mgmtGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
+int32_t mnodeGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
   SSchema *pSchema = pMeta->schema;
@@ -190,11 +192,11 @@ int32_t mgmtGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   pShow->pIter = NULL;
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
 
-  mgmtGetQueries(pShow, pConn);
+  mnodeGetQueries(pShow, pConn);
   return 0;
 }
 
-int32_t mgmtKillQuery(char *qidstr, void *pConn) {
+int32_t mnodeKillQuery(char *qidstr, void *pConn) {
 //  char *temp, *chr, idstr[64];
 //  strcpy(idstr, qidstr);
 //
@@ -247,7 +249,7 @@ int32_t mgmtKillQuery(char *qidstr, void *pConn) {
   return TSDB_CODE_INVALID_QUERY_ID;
 }
 
-int32_t mgmtRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+int32_t mnodeRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t   numOfRows = 0;
   char *pWrite;
   int32_t   cols = 0;
@@ -297,7 +299,7 @@ int32_t mgmtRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pCo
   return numOfRows;
 }
 
-int32_t mgmtGetStreams(SShowObj *pShow, void *pConn) {
+int32_t mnodeGetStreams(SShowObj *pShow, void *pConn) {
 //  SAcctObj *   pAcct = pConn->pAcct;
 //  SStreamShow *pStreamShow;
 //
@@ -344,125 +346,8 @@ int32_t mgmtGetStreams(SShowObj *pShow, void *pConn) {
   return 0;
 }
 
-int32_t mgmtGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  int32_t      cols = 0;
-  SSchema *pSchema = pMeta->schema;
 
-  pShow->bytes[cols] = TSDB_USER_LEN;
+int32_t mnodeKillStream(char *qidstr, void *pConn) {
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "user");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_IPv4ADDR_LEN + 14;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "ip:port:id");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "created time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "exec time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "time(us)");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_SHOW_SQL_LEN;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "sql");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "cycles");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pMeta->numOfColumns = htons(cols);
-  pShow->numOfColumns = cols;
-
-  pShow->offset[0] = 0;
-  for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
-
-  pShow->numOfRows = 1000000;
-  pShow->pIter = NULL;
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  mgmtGetStreams(pShow, pConn);
-  return 0;
-}
-
-int32_t mgmtRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  int32_t   numOfRows = 0;
-  char *pWrite;
-  int32_t   cols = 0;
-
-  SStreamShow *pStreamShow = (SStreamShow *)pShow->pIter;
-
-  if (rows > pStreamShow->numOfStreams - pStreamShow->index) rows = pStreamShow->numOfStreams - pStreamShow->index;
-
-  while (numOfRows < rows) {
-    SStreamDesc *pNode = pStreamShow->sdesc + pStreamShow->index;
-    SCDesc *pCDesc = pStreamShow->cdesc[pStreamShow->index];
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    strcpy(pWrite, pCDesc->user);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    uint32_t ip = pCDesc->ip;
-    sprintf(pWrite, "%d.%d.%d.%d:%hu:%d", ip & 0xFF, (ip >> 8) & 0xFF, (ip >> 16) & 0xFF, ip >> 24, htons(pCDesc->port),
-            pNode->streamId);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pNode->ctime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pNode->stime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pNode->useconds;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    strcpy(pWrite, pNode->sql);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *)pWrite = pNode->num;
-    cols++;
-
-    numOfRows++;
-    pStreamShow->index++;
-  }
-
-  if (numOfRows == 0) {
-    tfree(pStreamShow->cdesc);
-    tfree(pStreamShow->connInfo);
-    tfree(pStreamShow);
-  }
-
-  pShow->numOfReads += numOfRows;
-  return numOfRows;
-}
-
-int32_t mgmtKillStream(char *qidstr, void *pConn) {
 //  char *temp, *chr, idstr[64];
 //  strcpy(idstr, qidstr);
 //
@@ -515,7 +400,7 @@ int32_t mgmtKillStream(char *qidstr, void *pConn) {
   return TSDB_CODE_INVALID_STREAM_ID;
 }
 
-int32_t mgmtKillConnection(char *qidstr, void *pConn) {
+int32_t mnodeKillConnection(char *qidstr, void *pConn) {
 //  void *pConn1 = NULL;
 //  char *    temp, *chr, idstr[64];
 //  strcpy(idstr, qidstr);
@@ -562,7 +447,7 @@ int32_t mgmtKillConnection(char *qidstr, void *pConn) {
 }
 
 
-int mgmtGetConns(SShowObj *pShow, void *pConn) {
+int mnodeGetConns(SShowObj *pShow, void *pConn) {
   //  SAcctObj * pAcct = pConn->pAcct;
   //  SConnShow *pConnShow;
   //
@@ -597,7 +482,7 @@ int mgmtGetConns(SShowObj *pShow, void *pConn) {
   return 0;
 }
 
-int32_t mgmtGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
+int32_t mnodeGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
   pShow->bytes[cols] = TSDB_TABLE_NAME_LEN;
@@ -630,11 +515,11 @@ int32_t mgmtGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   pShow->pIter = NULL;
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
 
-  mgmtGetConns(pShow, pConn);
+  mnodeGetConns(pShow, pConn);
   return 0;
 }
 
-int32_t mgmtRetrieveConns(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+int32_t mnodeRetrieveConns(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t   numOfRows = 0;
   char      *pWrite;
   int32_t   cols = 0;
@@ -672,91 +557,92 @@ int32_t mgmtRetrieveConns(SShowObj *pShow, char *data, int32_t rows, void *pConn
   return numOfRows;
 }
 
-void mgmtProcessKillQueryMsg(SQueuedMsg *pMsg) {
+int32_t mnodeProcessKillQueryMsg(SMnodeMsg *pMsg) {
-  SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
+  // SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
   
-  SUserObj *pUser = mgmtGetUserFromConn(pMsg->thandle);
+  // SUserObj *pUser = mnodeGetUserFromConn(pMsg->thandle);
-  if (pUser == NULL) {
+  // if (pUser == NULL) {
-    rpcRsp.code = TSDB_CODE_INVALID_USER;
+  //   rpcRsp.code = TSDB_CODE_INVALID_USER;
-    rpcSendResponse(&rpcRsp);
+  //   rpcSendResponse(&rpcRsp);
-    return;
+  //   return;
+  // }
+
+  // SCMKillQueryMsg *pKill = pMsg->pCont;
+  // int32_t code;
+
+  // if (!pUser->writeAuth) {
+  //   code = TSDB_CODE_NO_RIGHTS;
+  // } else {
+  //   code = mgmtKillQuery(pKill->queryId, pMsg->thandle);
+  // }
+
+  // rpcRsp.code = code;
+  // rpcSendResponse(&rpcRsp);
+  // mnodeDecUserRef(pUser);
+  return TSDB_CODE_SUCCESS;
 }
 
-  SCMKillQueryMsg *pKill = pMsg->pCont;
+int32_t mnodeProcessKillStreamMsg(SMnodeMsg *pMsg) {
-  int32_t code;
+  // SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
   
-  if (!pUser->writeAuth) {
+  // SUserObj *pUser = mnodeGetUserFromConn(pMsg->thandle);
-    code = TSDB_CODE_NO_RIGHTS;
+  // if (pUser == NULL) {
-  } else {
+  //   rpcRsp.code = TSDB_CODE_INVALID_USER;
-    code = mgmtKillQuery(pKill->queryId, pMsg->thandle);
+  //   rpcSendResponse(&rpcRsp);
+  //   return;
+  // }
+
+  // SCMKillStreamMsg *pKill = pMsg->pCont;
+  // int32_t code;
+
+  // if (!pUser->writeAuth) {
+  //   code = TSDB_CODE_NO_RIGHTS;
+  // } else {
+  //   code = mgmtKillStream(pKill->queryId, pMsg->thandle);
+  // }
+
+  // rpcRsp.code = code;
+  // rpcSendResponse(&rpcRsp);
+  // mnodeDecUserRef(pUser);
+  return TSDB_CODE_SUCCESS;
 }
 
-  rpcRsp.code = code;
+int32_t mnodeProcessKillConnectionMsg(SMnodeMsg *pMsg) {
-  rpcSendResponse(&rpcRsp);
+  // SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
-  mgmtDecUserRef(pUser);
+  
+  // SUserObj *pUser = mnodeGetUserFromConn(pMsg->thandle);
+  // if (pUser == NULL) {
+  //   rpcRsp.code = TSDB_CODE_INVALID_USER;
+  //   rpcSendResponse(&rpcRsp);
+  //   return;
+  // }
+
+  // SCMKillConnMsg *pKill = pMsg->pCont;
+  // int32_t code;
+
+  // if (!pUser->writeAuth) {
+  //   code = TSDB_CODE_NO_RIGHTS;
+  // } else {
+  //   code = mgmtKillConnection(pKill->queryId, pMsg->thandle);
+  // }
+
+  // rpcRsp.code = code;
+  // rpcSendResponse(&rpcRsp);
+  // mnodeDecUserRef(pUser);
+  return TSDB_CODE_SUCCESS;
 }
 
-void mgmtProcessKillStreamMsg(SQueuedMsg *pMsg) {
+int32_t mnodeInitProfile() {
-  SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
+  // mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mnodeGetQueryMeta);
+  // mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mnodeRetrieveQueries);
+  // mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mnodeGetConnsMeta);
+  // mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mnodeRetrieveConns);
 
-  SUserObj *pUser = mgmtGetUserFromConn(pMsg->thandle);
+  // mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mnodeProcessKillQueryMsg);
-  if (pUser == NULL) {
+  // mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mnodeProcessKillStreamMsg);
-    rpcRsp.code = TSDB_CODE_INVALID_USER;
+  // mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_CONN, mnodeProcessKillConnectionMsg);
-    rpcSendResponse(&rpcRsp);
-    return;
-  }
-
-  SCMKillStreamMsg *pKill = pMsg->pCont;
-  int32_t code;
-
-  if (!pUser->writeAuth) {
-    code = TSDB_CODE_NO_RIGHTS;
-  } else {
-    code = mgmtKillStream(pKill->queryId, pMsg->thandle);
-  }
-
-  rpcRsp.code = code;
-  rpcSendResponse(&rpcRsp);
-  mgmtDecUserRef(pUser);
-}
-
-void mgmtProcessKillConnectionMsg(SQueuedMsg *pMsg) {
-  SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
-  
-  SUserObj *pUser = mgmtGetUserFromConn(pMsg->thandle);
-  if (pUser == NULL) {
-    rpcRsp.code = TSDB_CODE_INVALID_USER;
-    rpcSendResponse(&rpcRsp);
-    return;
-  }
-
-  SCMKillConnMsg *pKill = pMsg->pCont;
-  int32_t code;
-
-  if (!pUser->writeAuth) {
-    code = TSDB_CODE_NO_RIGHTS;
-  } else {
-    code = mgmtKillConnection(pKill->queryId, pMsg->thandle);
-  }
-
-  rpcRsp.code = code;
-  rpcSendResponse(&rpcRsp);
-  mgmtDecUserRef(pUser);
-}
-
-int32_t mgmtInitProfile() {
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mgmtGetQueryMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mgmtRetrieveQueries);
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mgmtGetConnsMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mgmtRetrieveConns);
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_STREAMS, mgmtGetStreamMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMS, mgmtRetrieveStreams);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mgmtProcessKillQueryMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mgmtProcessKillStreamMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_CONN, mgmtProcessKillConnectionMsg);
 
   return 0;
 }
 
-void mgmtCleanUpProfile() {
+void mnodeCleanupProfile() {}
-}

src/mnode/src/mnodeRead.c

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "taosdef.h"
+#include "tsched.h"
+#include "tbalance.h"
+#include "tgrant.h"
+#include "ttimer.h"
+#include "tglobal.h"
+#include "mnode.h"
+#include "dnode.h"
+#include "mnodeDef.h"
+#include "mnodeInt.h"
+#include "mnodeAcct.h"
+#include "mnodeDnode.h"
+#include "mnodeMnode.h"
+#include "mnodeDb.h"
+#include "mnodeSdb.h"
+#include "mnodeVgroup.h"
+#include "mnodeUser.h"
+#include "mnodeTable.h"
+#include "mnodeShow.h"
+
+static int32_t (*tsMnodeProcessReadMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *);
+
+void mnodeAddReadMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *pMsg)) {
+  tsMnodeProcessReadMsgFp[msgType] = fp;
+}
+
+int32_t mnodeProcessRead(SMnodeMsg *pMsg) {
+  if (pMsg->rpcMsg.pCont == NULL) {
+    mError("%p, msg:%s in mread queue, content is null", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
+    return TSDB_CODE_INVALID_MSG_LEN;
+  }
+
+  if (!sdbIsMaster()) {
+    SMnodeRsp *rpcRsp = &pMsg->rpcRsp;
+    SRpcIpSet *ipSet = rpcMallocCont(sizeof(SRpcIpSet));
+    mnodeGetMnodeIpSetForShell(ipSet);
+    rpcRsp->rsp = ipSet;
+    rpcRsp->len = sizeof(SRpcIpSet);
+
+    mTrace("%p, msg:%s in mread queue, will be redireced, inUse:%d", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], ipSet->inUse);
+    for (int32_t i = 0; i < ipSet->numOfIps; ++i) {
+      mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i]));
+    }
+
+    return TSDB_CODE_REDIRECT;
+  }
+
+  if (tsMnodeProcessReadMsgFp[pMsg->rpcMsg.msgType] == NULL) {
+    mError("%p, msg:%s in mread queue, not processed", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
+    return TSDB_CODE_MSG_NOT_PROCESSED;
+  }
+
+  int32_t code = mnodeInitMsg(pMsg);
+  if (code != TSDB_CODE_SUCCESS) {
+    mError("%p, msg:%s in mread queue, not processed reason:%s", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], tstrerror(code));
+    return code;
+  }
+
+  return (*tsMnodeProcessReadMsgFp[pMsg->rpcMsg.msgType])(pMsg);
+}

src/mnode/src/mnodeSdb.c

@@ -17,7 +17,6 @@
 #include "os.h"
 #include "taoserror.h"
 #include "hash.h"
-#include "trpc.h"
 #include "tutil.h"
 #include "tbalance.h"
 #include "tqueue.h"
@@ -25,11 +24,11 @@
 #include "tsync.h"
 #include "tglobal.h"
 #include "dnode.h"
-#include "mgmtDef.h"
+#include "mnodeDef.h"
-#include "mgmtInt.h"
+#include "mnodeInt.h"
-#include "mgmtMnode.h"
+#include "mnodeMnode.h"
-#include "mgmtDnode.h"
+#include "mnodeDnode.h"
-#include "mgmtSdb.h"
+#include "mnodeSdb.h"
 
 typedef enum {
   SDB_ACTION_INSERT,
@@ -187,18 +186,18 @@ void sdbUpdateMnodeRoles() {
   SNodesRole roles = {0};
   syncGetNodesRole(tsSdbObj.sync, &roles);
 
-  sdbPrint("update mnodes:%d sync roles", tsSdbObj.cfg.replica);
+  sdbPrint("update mnodes sync roles, total:%d", tsSdbObj.cfg.replica);
   for (int32_t i = 0; i < tsSdbObj.cfg.replica; ++i) {
-    SMnodeObj *pMnode = mgmtGetMnode(roles.nodeId[i]);
+    SMnodeObj *pMnode = mnodeGetMnode(roles.nodeId[i]);
     if (pMnode != NULL) {
       pMnode->role = roles.role[i];
-      sdbPrint("mnode:%d, role:%s", pMnode->mnodeId, mgmtGetMnodeRoleStr(pMnode->role));
+      sdbPrint("mnode:%d, role:%s", pMnode->mnodeId, mnodeGetMnodeRoleStr(pMnode->role));
       if (pMnode->mnodeId == dnodeGetDnodeId()) tsSdbObj.role = pMnode->role;
-      mgmtDecMnodeRef(pMnode);
+      mnodeDecMnodeRef(pMnode);
     }
   }
 
-  mgmtUpdateMnodeIpSet();
+  mnodeUpdateMnodeIpSet();
 }
 
 static uint32_t sdbGetFileInfo(void *ahandle, char *name, uint32_t *index, int32_t *size, uint64_t *fversion) {
@@ -211,7 +210,7 @@ static int sdbGetWalInfo(void *ahandle, char *name, uint32_t *index) {
 }
 
 static void sdbNotifyRole(void *ahandle, int8_t role) {
-  sdbPrint("mnode role changed from %s to %s", mgmtGetMnodeRoleStr(tsSdbObj.role), mgmtGetMnodeRoleStr(role));
+  sdbPrint("mnode role changed from %s to %s", mnodeGetMnodeRoleStr(tsSdbObj.role), mnodeGetMnodeRoleStr(role));
 
   if (role == TAOS_SYNC_ROLE_MASTER && tsSdbObj.role != TAOS_SYNC_ROLE_MASTER) {
     balanceReset();
@@ -256,20 +255,20 @@ void sdbUpdateSync() {
     void *pIter = NULL;
     while (1) {
       SMnodeObj *pMnode = NULL;
-      pIter = mgmtGetNextMnode(pIter, &pMnode);
+      pIter = mnodeGetNextMnode(pIter, &pMnode);
       if (pMnode == NULL) break;
 
       syncCfg.nodeInfo[index].nodeId = pMnode->mnodeId;
 
-      SDnodeObj *pDnode = mgmtGetDnode(pMnode->mnodeId);
+      SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
       if (pDnode != NULL) {
         syncCfg.nodeInfo[index].nodePort = pDnode->dnodePort + TSDB_PORT_SYNC;
         strcpy(syncCfg.nodeInfo[index].nodeFqdn, pDnode->dnodeEp);
         index++;
       }
 
-      mgmtDecDnodeRef(pDnode);
+      mnodeDecDnodeRef(pDnode);
-      mgmtDecMnodeRef(pMnode);
+      mnodeDecMnodeRef(pMnode);
     }
     sdbFreeIter(pIter);
   }
@@ -324,7 +323,7 @@ int32_t sdbInit() {
   
   sdbRestoreTables();
 
-  if (mgmtGetMnodesNum() == 1) {
+  if (mnodeGetMnodesNum() == 1) {
     tsSdbObj.role = TAOS_SYNC_ROLE_MASTER;
   }
 
@@ -359,8 +358,8 @@ void sdbIncRef(void *handle, void *pObj) {
   SSdbTable *pTable = handle;
   int32_t *  pRefCount = (int32_t *)(pObj + pTable->refCountPos);
   atomic_add_fetch_32(pRefCount, 1);
-  if (0 && (pTable->tableId == SDB_TABLE_MNODE || pTable->tableId == SDB_TABLE_DNODE)) {
+  if (0 && (pTable->tableId == SDB_TABLE_CTABLE || pTable->tableId == SDB_TABLE_DB)) {
-    sdbTrace("add ref to table:%s record:%s:%d", pTable->tableName, sdbGetKeyStrFromObj(pTable, pObj), *pRefCount);
+    sdbTrace("add ref to table:%s record:%p:%s:%d", pTable->tableName, pObj, sdbGetKeyStrFromObj(pTable, pObj), *pRefCount);
   }
 }
 
@@ -370,13 +369,13 @@ void sdbDecRef(void *handle, void *pObj) {
   SSdbTable *pTable = handle;
   int32_t *  pRefCount = (int32_t *)(pObj + pTable->refCountPos);
   int32_t    refCount = atomic_sub_fetch_32(pRefCount, 1);
-  if (0 && (pTable->tableId == SDB_TABLE_MNODE || pTable->tableId == SDB_TABLE_DNODE)) {
+  if (0 && (pTable->tableId == SDB_TABLE_CTABLE || pTable->tableId == SDB_TABLE_DB)) {
-    sdbTrace("def ref of table:%s record:%s:%d", pTable->tableName, sdbGetKeyStrFromObj(pTable, pObj), *pRefCount);
+    sdbTrace("def ref of table:%s record:%p:%s:%d", pTable->tableName, pObj, sdbGetKeyStrFromObj(pTable, pObj), *pRefCount);
   }
 
   int8_t *updateEnd = pObj + pTable->refCountPos - 1;
   if (refCount <= 0 && *updateEnd) {
-    sdbTrace("table:%s, record:%s:%d is destroyed", pTable->tableName, sdbGetKeyStrFromObj(pTable, pObj), *pRefCount);
+    sdbTrace("table:%s, record:%p:%s:%d is destroyed", pTable->tableName, pObj, sdbGetKeyStrFromObj(pTable, pObj), *pRefCount);
     SSdbOper oper = {.pObj = pObj};
     (*pTable->destroyFp)(&oper);
   }

src/mnode/src/mnodeShow.c

@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "taosmsg.h"
+#include "taoserror.h"
+#include "tsched.h"
+#include "tutil.h"
+#include "ttimer.h"
+#include "tgrant.h"
+#include "tglobal.h"
+#include "tcache.h"
+#include "mnode.h"
+#include "dnode.h"
+#include "mnodeDef.h"
+#include "mnodeInt.h"
+#include "mnodeAcct.h"
+#include "mnodeDb.h"
+#include "mnodeDnode.h"
+#include "mnodeMnode.h"
+#include "mnodeProfile.h"
+#include "mnodeSdb.h"
+#include "mnodeShow.h"
+#include "mnodeTable.h"
+#include "mnodeUser.h"
+#include "mnodeVgroup.h"
+#include "mnodeWrite.h"
+#include "mnodeRead.h"
+
+static int32_t mnodeProcessShowMsg(SMnodeMsg *mnodeMsg);
+static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *mnodeMsg);
+static int32_t mnodeProcessHeartBeatMsg(SMnodeMsg *mnodeMsg);
+static int32_t mnodeProcessConnectMsg(SMnodeMsg *mnodeMsg);
+static int32_t mnodeProcessUseMsg(SMnodeMsg *mnodeMsg);
+
+static void  mnodeFreeShowObj(void *data);
+static bool  mnodeAccquireShowObj(SShowObj *pShow);
+static bool  mnodeCheckShowFinished(SShowObj *pShow);
+static void *mnodePutShowObj(SShowObj *pShow, int32_t size);
+static void  mnodeReleaseShowObj(void *pShow, bool forceRemove);
+
+extern void *tsMnodeTmr;
+static void *tsMnodeShowCache = NULL;
+static int32_t tsShowObjIndex = 0;
+static SShowMetaFp     tsMnodeShowMetaFp[TSDB_MGMT_TABLE_MAX]     = {0};
+static SShowRetrieveFp tsMnodeShowRetrieveFp[TSDB_MGMT_TABLE_MAX] = {0};
+
+int32_t mnodeInitShow() {
+  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_SHOW, mnodeProcessShowMsg);
+  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_RETRIEVE, mnodeProcessRetrieveMsg);
+  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_HEARTBEAT, mnodeProcessHeartBeatMsg);
+  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_CONNECT, mnodeProcessConnectMsg);
+  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_USE_DB, mnodeProcessUseMsg);
+  
+  tsMnodeShowCache = taosCacheInitWithCb(tsMnodeTmr, 10, mnodeFreeShowObj);
+  return 0;
+}
+
+void mnodeCleanUpShow() {
+  if (tsMnodeShowCache != NULL) {
+    mPrint("show cache is cleanup");
+    taosCacheCleanup(tsMnodeShowCache);
+    tsMnodeShowCache = NULL;
+  }
+}
+
+void mnodeAddShowMetaHandle(uint8_t showType, SShowMetaFp fp) {
+  tsMnodeShowMetaFp[showType] = fp;
+}
+
+void mnodeAddShowRetrieveHandle(uint8_t msgType, SShowRetrieveFp fp) {
+  tsMnodeShowRetrieveFp[msgType] = fp;
+}
+
+static char *mnodeGetShowType(int32_t showType) {
+  switch (showType) {
+    case TSDB_MGMT_TABLE_ACCT:    return "show accounts";
+    case TSDB_MGMT_TABLE_USER:    return "show users";
+    case TSDB_MGMT_TABLE_DB:      return "show databases";
+    case TSDB_MGMT_TABLE_TABLE:   return "show tables";
+    case TSDB_MGMT_TABLE_DNODE:   return "show dnodes";
+    case TSDB_MGMT_TABLE_MNODE:   return "show mnodes";
+    case TSDB_MGMT_TABLE_VGROUP:  return "show vgroups";
+    case TSDB_MGMT_TABLE_METRIC:  return "show stables";
+    case TSDB_MGMT_TABLE_MODULE:  return "show modules";
+    case TSDB_MGMT_TABLE_QUERIES: return "show queries";
+    case TSDB_MGMT_TABLE_STREAMS: return "show streams";
+    case TSDB_MGMT_TABLE_CONFIGS: return "show configs";
+    case TSDB_MGMT_TABLE_CONNS:   return "show connections";
+    case TSDB_MGMT_TABLE_SCORES:  return "show scores";
+    case TSDB_MGMT_TABLE_GRANTS:  return "show grants";
+    case TSDB_MGMT_TABLE_VNODES:  return "show vnodes";
+    default:                      return "undefined";
+  }
+}
+
+static int32_t mnodeProcessShowMsg(SMnodeMsg *pMsg) {
+  SCMShowMsg *pShowMsg = pMsg->rpcMsg.pCont;
+  if (pShowMsg->type >= TSDB_MGMT_TABLE_MAX) {
+    return TSDB_CODE_INVALID_MSG_TYPE;
+  }
+
+  if (!tsMnodeShowMetaFp[pShowMsg->type] || !tsMnodeShowRetrieveFp[pShowMsg->type]) {
+    mError("show type:%s is not support", mnodeGetShowType(pShowMsg->type));
+    return TSDB_CODE_OPS_NOT_SUPPORT;
+  }
+
+  int32_t showObjSize = sizeof(SShowObj) + htons(pShowMsg->payloadLen);
+  SShowObj *pShow = (SShowObj *) calloc(1, showObjSize);
+  pShow->type       = pShowMsg->type;
+  pShow->payloadLen = htons(pShowMsg->payloadLen);
+  strcpy(pShow->db, pShowMsg->db);
+  memcpy(pShow->payload, pShowMsg->payload, pShow->payloadLen);
+
+  pShow = mnodePutShowObj(pShow, showObjSize);
+  if (pShow == NULL) {    
+    return TSDB_CODE_SERV_OUT_OF_MEMORY;
+  }
+
+  int32_t size = sizeof(SCMShowRsp) + sizeof(SSchema) * TSDB_MAX_COLUMNS + TSDB_EXTRA_PAYLOAD_SIZE;
+  SCMShowRsp *pShowRsp = rpcMallocCont(size);
+  if (pShowRsp == NULL) {
+    mnodeReleaseShowObj(pShow, true);
+    return TSDB_CODE_SERV_OUT_OF_MEMORY;
+  }
+  pShowRsp->qhandle = htobe64((uint64_t) pShow);
+
+  mTrace("%p, show type:%s, start to get meta", pShow, mnodeGetShowType(pShowMsg->type));
+  int32_t code = (*tsMnodeShowMetaFp[pShowMsg->type])(&pShowRsp->tableMeta, pShow, pMsg->rpcMsg.handle);
+  if (code == 0) {
+    pMsg->rpcRsp.rsp = pShowRsp;
+    pMsg->rpcRsp.len = sizeof(SCMShowRsp) + sizeof(SSchema) * pShow->numOfColumns;
+    mnodeReleaseShowObj(pShow, false);
+    return TSDB_CODE_SUCCESS;
+  } else {
+    mError("%p, show type:%s, failed to get meta, reason:%s", pShow, mnodeGetShowType(pShowMsg->type), tstrerror(code));
+    rpcFreeCont(pShowRsp);
+    mnodeReleaseShowObj(pShow, true);
+    return code;
+  }
+}
+
+static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) {
+  int32_t rowsToRead = 0;
+  int32_t size = 0;
+  int32_t rowsRead = 0;
+  SRetrieveTableMsg *pRetrieve = pMsg->rpcMsg.pCont;
+  pRetrieve->qhandle = htobe64(pRetrieve->qhandle);
+
+  SShowObj *pShow = (SShowObj *)pRetrieve->qhandle;
+  mTrace("%p, show type:%s, retrieve data", pShow, mnodeGetShowType(pShow->type));
+
+  /*
+   * in case of server restart, apps may hold qhandle created by server before
+   * restart, which is actually invalid, therefore, signature check is required.
+   */
+  if (!mnodeAccquireShowObj(pShow)) {
+    mError("%p, show is invalid", pShow);
+    return TSDB_CODE_INVALID_QHANDLE;
+  }
+  
+  if (mnodeCheckShowFinished(pShow)) {
+    mTrace("%p, show is already read finished, numOfReads:%d numOfRows:%d", pShow, pShow->numOfReads, pShow->numOfRows);
+    pShow->numOfReads = pShow->numOfRows;
+  }
+
+  if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) {
+    rowsToRead = pShow->numOfRows - pShow->numOfReads;
+  }
+
+  /* return no more than 100 meters in one round trip */
+  if (rowsToRead > 100) rowsToRead = 100;
+
+  /*
+   * the actual number of table may be larger than the value of pShow->numOfRows, if a query is
+   * issued during a continuous create table operation. Therefore, rowToRead may be less than 0.
+   */
+  if (rowsToRead < 0) rowsToRead = 0;
+  size = pShow->rowSize * rowsToRead;
+
+  size += 100;
+  SRetrieveTableRsp *pRsp = rpcMallocCont(size);
+
+  // if free flag is set, client wants to clean the resources
+  if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE)
+    rowsRead = (*tsMnodeShowRetrieveFp[pShow->type])(pShow, pRsp->data, rowsToRead, pMsg->rpcMsg.handle);
+
+  if (rowsRead < 0) {
+    rpcFreeCont(pRsp);
+    mnodeReleaseShowObj(pShow, false);
+    assert(false);
+    return TSDB_CODE_ACTION_IN_PROGRESS;
+  }
+
+  pRsp->numOfRows = htonl(rowsRead);
+  pRsp->precision = htonl(TSDB_TIME_PRECISION_MILLI);  // millisecond time precision
+
+  pMsg->rpcRsp.rsp = pRsp;
+  pMsg->rpcRsp.len = size;
+
+  if (rowsToRead == 0 || rowsRead == rowsToRead) {
+    pRsp->completed = 1;
+    mnodeReleaseShowObj(pShow, true);
+  } else {
+    mnodeReleaseShowObj(pShow, false);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t mnodeProcessHeartBeatMsg(SMnodeMsg *pMsg) {
+  SCMHeartBeatRsp *pHBRsp = (SCMHeartBeatRsp *) rpcMallocCont(sizeof(SCMHeartBeatRsp));
+  if (pHBRsp == NULL) {
+    return TSDB_CODE_SERV_OUT_OF_MEMORY;
+  }
+
+  pHBRsp->onlineDnodes = htonl(mnodeGetOnlinDnodesNum());
+  pHBRsp->totalDnodes = htonl(mnodeGetDnodesNum());
+  mnodeGetMnodeIpSetForShell(&pHBRsp->ipList);
+  
+  /*
+   * TODO
+   * Dispose kill stream or kill query message
+   */
+  pHBRsp->queryId = 0;
+  pHBRsp->streamId = 0;
+  pHBRsp->killConnection = 0;
+
+  pMsg->rpcRsp.rsp = pHBRsp;
+  pMsg->rpcRsp.len = sizeof(SCMHeartBeatRsp);
+  
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t mnodeProcessConnectMsg(SMnodeMsg *pMsg) {
+  SCMConnectMsg *pConnectMsg = pMsg->rpcMsg.pCont;
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  SRpcConnInfo connInfo;
+  if (rpcGetConnInfo(pMsg->rpcMsg.handle, &connInfo) != 0) {
+    mError("thandle:%p is already released while process connect msg", pMsg->rpcMsg.handle);
+    code = TSDB_CODE_INVALID_MSG_CONTENT;
+    goto connect_over;
+  }
+
+  code = taosCheckVersion(pConnectMsg->clientVersion, version, 3);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto connect_over;
+  }
+
+  SUserObj *pUser = pMsg->pUser;
+  SAcctObj *pAcct = pUser->pAcct;
+
+  if (pConnectMsg->db[0]) {
+    char dbName[TSDB_TABLE_ID_LEN * 3] = {0};
+    sprintf(dbName, "%x%s%s", pAcct->acctId, TS_PATH_DELIMITER, pConnectMsg->db);
+    SDbObj *pDb = mnodeGetDb(dbName);
+    if (pDb == NULL) {
+      code = TSDB_CODE_INVALID_DB;
+      goto connect_over;
+    }
+    mnodeDecDbRef(pDb);
+  }
+
+  SCMConnectRsp *pConnectRsp = rpcMallocCont(sizeof(SCMConnectRsp));
+  if (pConnectRsp == NULL) {
+    code = TSDB_CODE_SERV_OUT_OF_MEMORY;
+    goto connect_over;
+  }
+
+  sprintf(pConnectRsp->acctId, "%x", pAcct->acctId);
+  strcpy(pConnectRsp->serverVersion, version);
+  pConnectRsp->writeAuth = pUser->writeAuth;
+  pConnectRsp->superAuth = pUser->superAuth;
+
+  mnodeGetMnodeIpSetForShell(&pConnectRsp->ipList);
+
+connect_over:
+  if (code != TSDB_CODE_SUCCESS) {
+    mLError("user:%s login from %s, result:%s", connInfo.user, taosIpStr(connInfo.clientIp), tstrerror(code));
+  } else {
+    mLPrint("user:%s login from %s, result:%s", connInfo.user, taosIpStr(connInfo.clientIp), tstrerror(code));
+    pMsg->rpcRsp.rsp = pConnectRsp;
+    pMsg->rpcRsp.len = sizeof(SCMConnectRsp);
+  }
+
+  return code;
+}
+
+static int32_t mnodeProcessUseMsg(SMnodeMsg *pMsg) {
+  SCMUseDbMsg *pUseDbMsg = pMsg->rpcMsg.pCont;
+
+  int32_t code = TSDB_CODE_SUCCESS;
+  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pUseDbMsg->db);
+  if (pMsg->pDb == NULL) {
+    code = TSDB_CODE_INVALID_DB;
+  }
+
+  return code;
+}
+
+static bool mnodeCheckShowFinished(SShowObj *pShow) {
+  if (pShow->pIter == NULL && pShow->numOfReads != 0) {
+    return true;
+  } 
+  return false;
+}
+
+static bool mnodeAccquireShowObj(SShowObj *pShow) {
+  char key[10];
+  sprintf(key, "%d", pShow->index);
+
+  SShowObj *pSaved = taosCacheAcquireByName(tsMnodeShowCache, key);
+  if (pSaved == pShow) {
+    mTrace("%p, show is accquired from cache", pShow);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+static void *mnodePutShowObj(SShowObj *pShow, int32_t size) {
+  if (tsMnodeShowCache != NULL) {
+    char key[10];
+    pShow->index = atomic_add_fetch_32(&tsShowObjIndex, 1);
+    sprintf(key, "%d", pShow->index);
+
+    SShowObj *newQhandle = taosCachePut(tsMnodeShowCache, key, pShow, size, 60);
+    free(pShow);
+
+    mTrace("%p, show is put into cache", newQhandle);
+    return newQhandle;
+  }
+
+  return NULL;
+}
+
+static void mnodeFreeShowObj(void *data) {
+  SShowObj *pShow = data;
+  sdbFreeIter(pShow->pIter);
+  mTrace("%p, show is destroyed", pShow);
+}
+
+static void mnodeReleaseShowObj(void *pShow, bool forceRemove) {
+  mTrace("%p, show is released, force:%s", pShow, forceRemove ? "true" : "false");
+  taosCacheRelease(tsMnodeShowCache, &pShow, forceRemove);
+}

src/mnode/src/mnodeUser.c

@@ -21,36 +21,39 @@
 #include "tglobal.h"
 #include "tgrant.h"
 #include "tdataformat.h"
+#include "mnode.h"
 #include "dnode.h"
-#include "mgmtDef.h"
+#include "mnodeDef.h"
-#include "mgmtInt.h"
+#include "mnodeInt.h"
-#include "mgmtAcct.h"
+#include "mnodeAcct.h"
-#include "mgmtMnode.h"
+#include "mnodeMnode.h"
-#include "mgmtSdb.h"
+#include "mnodeSdb.h"
-#include "mgmtShell.h"
+#include "mnodeShow.h"
-#include "mgmtUser.h"
+#include "mnodeUser.h"
+#include "mnodeWrite.h"
+#include "mnodePeer.h"
 
 static void *  tsUserSdb = NULL;
 static int32_t tsUserUpdateSize = 0;
-static int32_t mgmtGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mnodeGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn);
+static int32_t mnodeRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void    mgmtProcessCreateUserMsg(SQueuedMsg *pMsg);
+static int32_t mnodeProcessCreateUserMsg(SMnodeMsg *pMsg);
-static void    mgmtProcessAlterUserMsg(SQueuedMsg *pMsg);
+static int32_t mnodeProcessAlterUserMsg(SMnodeMsg *pMsg);
-static void    mgmtProcessDropUserMsg(SQueuedMsg *pMsg);
+static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg);
-static void    mgmtProcessAuthMsg(SRpcMsg *rpcMsg);
+static int32_t mnodeProcessAuthMsg(SMnodeMsg *pMsg);
 
-static int32_t mgmtUserActionDestroy(SSdbOper *pOper) {
+static int32_t mnodeUserActionDestroy(SSdbOper *pOper) {
   tfree(pOper->pObj);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtUserActionInsert(SSdbOper *pOper) {
+static int32_t mnodeUserActionInsert(SSdbOper *pOper) {
   SUserObj *pUser = pOper->pObj;
-  SAcctObj *pAcct = mgmtGetAcct(pUser->acct);
+  SAcctObj *pAcct = mnodeGetAcct(pUser->acct);
 
   if (pAcct != NULL) {
-    mgmtAddUserToAcct(pAcct, pUser);
+    mnodeAddUserToAcct(pAcct, pUser);
-    mgmtDecAcctRef(pAcct);
+    mnodeDecAcctRef(pAcct);
   } else {
     mError("user:%s, acct:%s info not exist in sdb", pUser->user, pUser->acct);
     return TSDB_CODE_INVALID_ACCT;
@@ -59,37 +62,37 @@ static int32_t mgmtUserActionInsert(SSdbOper *pOper) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtUserActionDelete(SSdbOper *pOper) {
+static int32_t mnodeUserActionDelete(SSdbOper *pOper) {
   SUserObj *pUser = pOper->pObj;
-  SAcctObj *pAcct = mgmtGetAcct(pUser->acct);
+  SAcctObj *pAcct = mnodeGetAcct(pUser->acct);
 
   if (pAcct != NULL) {
-    mgmtDropUserFromAcct(pAcct, pUser);
+    mnodeDropUserFromAcct(pAcct, pUser);
-    mgmtDecAcctRef(pAcct);
+    mnodeDecAcctRef(pAcct);
   }
 
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtUserActionUpdate(SSdbOper *pOper) {
+static int32_t mnodeUserActionUpdate(SSdbOper *pOper) {
   SUserObj *pUser = pOper->pObj;
-  SUserObj *pSaved = mgmtGetUser(pUser->user);
+  SUserObj *pSaved = mnodeGetUser(pUser->user);
   if (pUser != pSaved) {
     memcpy(pSaved, pUser, tsUserUpdateSize);
     free(pUser);
   }
-  mgmtDecUserRef(pSaved);
+  mnodeDecUserRef(pSaved);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtUserActionEncode(SSdbOper *pOper) {
+static int32_t mnodeUserActionEncode(SSdbOper *pOper) {
   SUserObj *pUser = pOper->pObj;
   memcpy(pOper->rowData, pUser, tsUserUpdateSize);
   pOper->rowSize = tsUserUpdateSize;
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtUserActionDecode(SSdbOper *pOper) {
+static int32_t mnodeUserActionDecode(SSdbOper *pOper) {
   SUserObj *pUser = (SUserObj *)calloc(1, sizeof(SUserObj));
   if (pUser == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY;
 
@@ -98,19 +101,19 @@ static int32_t mgmtUserActionDecode(SSdbOper *pOper) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtUserActionRestored() {
+static int32_t mnodeUserActionRestored() {
   if (dnodeIsFirstDeploy()) {
-    SAcctObj *pAcct = mgmtGetAcct("root");
+    SAcctObj *pAcct = mnodeGetAcct("root");
-    mgmtCreateUser(pAcct, "root", "taosdata");
+    mnodeCreateUser(pAcct, "root", "taosdata");
-    mgmtCreateUser(pAcct, "monitor", tsInternalPass);
+    mnodeCreateUser(pAcct, "monitor", tsInternalPass);
-    mgmtCreateUser(pAcct, "_root", tsInternalPass);
+    mnodeCreateUser(pAcct, "_root", tsInternalPass);
-    mgmtDecAcctRef(pAcct);
+    mnodeDecAcctRef(pAcct);
   }
 
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t mgmtInitUsers() {
+int32_t mnodeInitUsers() {
   SUserObj tObj;
   tsUserUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
 
@@ -121,13 +124,13 @@ int32_t mgmtInitUsers() {
     .maxRowSize   = tsUserUpdateSize,
     .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
     .keyType      = SDB_KEY_STRING,
-    .insertFp     = mgmtUserActionInsert,
+    .insertFp     = mnodeUserActionInsert,
-    .deleteFp     = mgmtUserActionDelete,
+    .deleteFp     = mnodeUserActionDelete,
-    .updateFp     = mgmtUserActionUpdate,
+    .updateFp     = mnodeUserActionUpdate,
-    .encodeFp     = mgmtUserActionEncode,
+    .encodeFp     = mnodeUserActionEncode,
-    .decodeFp     = mgmtUserActionDecode,
+    .decodeFp     = mnodeUserActionDecode,
-    .destroyFp    = mgmtUserActionDestroy,
+    .destroyFp    = mnodeUserActionDestroy,
-    .restoredFp   = mgmtUserActionRestored
+    .restoredFp   = mnodeUserActionRestored
   };
 
   tsUserSdb = sdbOpenTable(&tableDesc);
@@ -136,38 +139,38 @@ int32_t mgmtInitUsers() {
     return -1;
   }
 
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_USER, mgmtProcessCreateUserMsg);
+  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_USER, mnodeProcessCreateUserMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_ALTER_USER, mgmtProcessAlterUserMsg);
+  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_ALTER_USER, mnodeProcessAlterUserMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_DROP_USER, mgmtProcessDropUserMsg);
+  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_USER, mnodeProcessDropUserMsg);
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_USER, mgmtGetUserMeta);
+  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_USER, mnodeGetUserMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_USER, mgmtRetrieveUsers);
+  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_USER, mnodeRetrieveUsers);
-  dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_AUTH, mgmtProcessAuthMsg);
+  mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_AUTH, mnodeProcessAuthMsg);
    
   mTrace("table:%s, hash is created", tableDesc.tableName);
   return 0;
 }
 
-void mgmtCleanUpUsers() {
+void mnodeCleanupUsers() {
   sdbCloseTable(tsUserSdb);
 }
 
-SUserObj *mgmtGetUser(char *name) {
+SUserObj *mnodeGetUser(char *name) {
   return (SUserObj *)sdbGetRow(tsUserSdb, name);
 }
 
-void *mgmtGetNextUser(void *pIter, SUserObj **pUser) { 
+void *mnodeGetNextUser(void *pIter, SUserObj **pUser) { 
   return sdbFetchRow(tsUserSdb, pIter, (void **)pUser); 
 }
 
-void mgmtIncUserRef(SUserObj *pUser) { 
+void mnodeIncUserRef(SUserObj *pUser) { 
   return sdbIncRef(tsUserSdb, pUser); 
 }
 
-void mgmtDecUserRef(SUserObj *pUser) { 
+void mnodeDecUserRef(SUserObj *pUser) { 
   return sdbDecRef(tsUserSdb, pUser); 
 }
 
-static int32_t mgmtUpdateUser(SUserObj *pUser) {
+static int32_t mnodeUpdateUser(SUserObj *pUser) {
   SSdbOper oper = {
     .type = SDB_OPER_GLOBAL,
     .table = tsUserSdb,
@@ -182,7 +185,7 @@ static int32_t mgmtUpdateUser(SUserObj *pUser) {
   return code;
 }
 
-int32_t mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass) {
+int32_t mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass) {
   int32_t code = acctCheck(pAcct, ACCT_GRANT_USER);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
@@ -196,10 +199,10 @@ int32_t mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass) {
     return TSDB_CODE_INVALID_PASS_FORMAT;
   }
 
-  SUserObj *pUser = mgmtGetUser(name);
+  SUserObj *pUser = mnodeGetUser(name);
   if (pUser != NULL) {
     mTrace("user:%s, is already there", name);
-    mgmtDecUserRef(pUser);
+    mnodeDecUserRef(pUser);
     return TSDB_CODE_USER_ALREADY_EXIST;
   }
 
@@ -235,7 +238,7 @@ int32_t mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass) {
   return code;
 }
 
-static int32_t mgmtDropUser(SUserObj *pUser) {
+static int32_t mnodeDropUser(SUserObj *pUser) {
   SSdbOper oper = {
     .type = SDB_OPER_GLOBAL,
     .table = tsUserSdb,
@@ -250,8 +253,8 @@ static int32_t mgmtDropUser(SUserObj *pUser) {
   return code;
 }
 
-static int32_t mgmtGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mnodeGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SUserObj *pUser = mgmtGetUserFromConn(pConn);
+  SUserObj *pUser = mnodeGetUserFromConn(pConn);
   if (pUser == NULL) {
     return TSDB_CODE_NO_USER_FROM_CONN;
   }
@@ -289,18 +292,18 @@ static int32_t mgmtGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCon
   pShow->numOfRows = pUser->pAcct->acctInfo.numOfUsers;
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
 
-  mgmtDecUserRef(pUser);
+  mnodeDecUserRef(pUser);
   return 0;
 }
 
-static int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+static int32_t mnodeRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t  numOfRows = 0;
   SUserObj *pUser    = NULL;
   int32_t  cols      = 0;
   char     *pWrite;
 
   while (numOfRows < rows) {
-    pShow->pIter = mgmtGetNextUser(pShow->pIter, &pUser);
+    pShow->pIter = mnodeGetNextUser(pShow->pIter, &pUser);
     if (pUser == NULL) break;
     
     cols = 0;
@@ -327,30 +330,30 @@ static int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void
     cols++;
 
     numOfRows++;
-    mgmtDecUserRef(pUser);
+    mnodeDecUserRef(pUser);
   }
 
   pShow->numOfReads += numOfRows;
   return numOfRows;
 }
 
-SUserObj *mgmtGetUserFromConn(void *pConn) {
+SUserObj *mnodeGetUserFromConn(void *pConn) {
   SRpcConnInfo connInfo;
   if (rpcGetConnInfo(pConn, &connInfo) == 0) {
-    return mgmtGetUser(connInfo.user);
+    return mnodeGetUser(connInfo.user);
   } else {
     mError("can not get user from conn:%p", pConn);
     return NULL;
   }
 }
 
-static void mgmtProcessCreateUserMsg(SQueuedMsg *pMsg) {
+static int32_t mnodeProcessCreateUserMsg(SMnodeMsg *pMsg) {
   int32_t code;
   SUserObj *pOperUser = pMsg->pUser;
   
   if (pOperUser->superAuth) {
-    SCMCreateUserMsg *pCreate = pMsg->pCont;
+    SCMCreateUserMsg *pCreate = pMsg->rpcMsg.pCont;
-    code = mgmtCreateUser(pOperUser->pAcct, pCreate->user, pCreate->pass);
+    code = mnodeCreateUser(pOperUser->pAcct, pCreate->user, pCreate->pass);
     if (code == TSDB_CODE_SUCCESS) {
       mLPrint("user:%s, is created by %s", pCreate->user, pOperUser->user);
     }
@@ -359,24 +362,22 @@ static void mgmtProcessCreateUserMsg(SQueuedMsg *pMsg) {
     code = TSDB_CODE_NO_RIGHTS;
   }
 
-  mgmtSendSimpleResp(pMsg->thandle, code);
+  return code;
 }
 
-static void mgmtProcessAlterUserMsg(SQueuedMsg *pMsg) {
+static int32_t mnodeProcessAlterUserMsg(SMnodeMsg *pMsg) {
   int32_t code;
   SUserObj *pOperUser = pMsg->pUser;
   
-  SCMAlterUserMsg *pAlter = pMsg->pCont;
+  SCMAlterUserMsg *pAlter = pMsg->rpcMsg.pCont;
-  SUserObj *pUser = mgmtGetUser(pAlter->user);
+  SUserObj *pUser = mnodeGetUser(pAlter->user);
   if (pUser == NULL) {
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_USER);
+    return TSDB_CODE_INVALID_USER;
-    return;
   }
 
   if (strcmp(pUser->user, "monitor") == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) {
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS);
+    mnodeDecUserRef(pUser);
-    mgmtDecUserRef(pUser);
+    return TSDB_CODE_NO_RIGHTS;
-    return;
   }
 
   if ((pAlter->flag & TSDB_ALTER_USER_PASSWD) != 0) {
@@ -398,14 +399,12 @@ static void mgmtProcessAlterUserMsg(SQueuedMsg *pMsg) {
     if (hasRight) {
       memset(pUser->pass, 0, sizeof(pUser->pass));
       taosEncryptPass((uint8_t*)pAlter->pass, strlen(pAlter->pass), pUser->pass);
-      code = mgmtUpdateUser(pUser);
+      code = mnodeUpdateUser(pUser);
       mLPrint("user:%s, password is altered by %s, result:%s", pUser->user, pOperUser->user, tstrerror(code));
     } else {
       mError("user:%s, no rights to alter user", pOperUser->user);
       code = TSDB_CODE_NO_RIGHTS;
     }
-
-    mgmtSendSimpleResp(pMsg->thandle, code);
   } else if ((pAlter->flag & TSDB_ALTER_USER_PRIVILEGES) != 0) {
     bool hasRight = false;
 
@@ -441,38 +440,35 @@ static void mgmtProcessAlterUserMsg(SQueuedMsg *pMsg) {
         pUser->writeAuth = 1;
       }
 
-      code = mgmtUpdateUser(pUser);
+      code = mnodeUpdateUser(pUser);
       mLPrint("user:%s, privilege is altered by %s, result:%s", pUser->user, pOperUser->user, tstrerror(code));
     } else {
       mError("user:%s, no rights to alter user", pOperUser->user);
       code = TSDB_CODE_NO_RIGHTS;
     }
-
-    mgmtSendSimpleResp(pMsg->thandle, code);
   } else {
     mError("user:%s, no rights to alter user", pOperUser->user);
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS);
+    code = TSDB_CODE_NO_RIGHTS;
   }
 
-  mgmtDecUserRef(pUser);
+  mnodeDecUserRef(pUser);
+  return code;
 }
 
-static void mgmtProcessDropUserMsg(SQueuedMsg *pMsg) {
+static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg) {
   int32_t code;
   SUserObj *pOperUser = pMsg->pUser;
 
-  SCMDropUserMsg *pDrop = pMsg->pCont;
+  SCMDropUserMsg *pDrop = pMsg->rpcMsg.pCont;
-  SUserObj *pUser = mgmtGetUser(pDrop->user);
+  SUserObj *pUser = mnodeGetUser(pDrop->user);
   if (pUser == NULL) {
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_USER);
+    return TSDB_CODE_INVALID_USER;
-    return;
   }
 
   if (strcmp(pUser->user, "monitor") == 0 || strcmp(pUser->user, pUser->acct) == 0 ||
     (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) {
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS);
+    mnodeDecUserRef(pUser);
-    mgmtDecUserRef(pUser);
+    return TSDB_CODE_NO_RIGHTS;
-    return ;
   }
 
   bool hasRight = false;
@@ -491,7 +487,7 @@ static void mgmtProcessDropUserMsg(SQueuedMsg *pMsg) {
   }
 
   if (hasRight) {
-    code = mgmtDropUser(pUser);
+    code = mnodeDropUser(pUser);
     if (code == TSDB_CODE_SUCCESS) {
       mLPrint("user:%s, is dropped by %s, result:%s", pUser->user, pOperUser->user, tstrerror(code));
     }
@@ -499,18 +495,18 @@ static void mgmtProcessDropUserMsg(SQueuedMsg *pMsg) {
     code = TSDB_CODE_NO_RIGHTS;
   }
 
-  mgmtSendSimpleResp(pMsg->thandle, code);
+  mnodeDecUserRef(pUser);
-  mgmtDecUserRef(pUser);
+  return code;
 }
 
-void  mgmtDropAllUsers(SAcctObj *pAcct)  {
+void mnodeDropAllUsers(SAcctObj *pAcct)  {
   void *    pIter = NULL;
   int32_t   numOfUsers = 0;
   int32_t   acctNameLen = strlen(pAcct->user);
   SUserObj *pUser = NULL;
 
   while (1) {
-    pIter = mgmtGetNextUser(pIter, &pUser);
+    pIter = mnodeGetNextUser(pIter, &pUser);
     if (pUser == NULL) break;
 
     if (strncmp(pUser->acct, pAcct->user, acctNameLen) == 0) {
@@ -523,7 +519,7 @@ void  mgmtDropAllUsers(SAcctObj *pAcct)  {
       numOfUsers++;
     }
 
-    mgmtDecUserRef(pUser);
+    mnodeDecUserRef(pUser);
   }
 
   sdbFreeIter(pIter);
@@ -531,14 +527,14 @@ void  mgmtDropAllUsers(SAcctObj *pAcct)  {
   mTrace("acct:%s, all users:%d is dropped from sdb", pAcct->user, numOfUsers);
 }
 
-int32_t mgmtRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
+int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
   if (!sdbIsMaster()) {
     *secret = 0;
     mTrace("user:%s, failed to auth user, reason:%s", user, tstrerror(TSDB_CODE_NOT_READY));
     return TSDB_CODE_NOT_READY;
   }
 
-  SUserObj *pUser = mgmtGetUser(user);
+  SUserObj *pUser = mnodeGetUser(user);
   if (pUser == NULL) {
     *secret = 0;
     mError("user:%s, failed to auth user, reason:%s", user, tstrerror(TSDB_CODE_INVALID_USER));
@@ -549,21 +545,18 @@ int32_t mgmtRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char
     *ckey = 0;
 
     memcpy(secret, pUser->pass, TSDB_KEY_LEN);
-    mgmtDecUserRef(pUser);
+    mnodeDecUserRef(pUser);
     mTrace("user:%s, auth info is returned", user);
     return TSDB_CODE_SUCCESS;
   }
 }
 
-static void mgmtProcessAuthMsg(SRpcMsg *rpcMsg) {
+static int32_t mnodeProcessAuthMsg(SMnodeMsg *pMsg) {
-  SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
+  SDMAuthMsg *pAuthMsg = pMsg->rpcMsg.pCont;
-  
-  SDMAuthMsg *pAuthMsg = rpcMsg->pCont;
   SDMAuthRsp *pAuthRsp = rpcMallocCont(sizeof(SDMAuthRsp));
   
-  rpcRsp.code = mgmtRetriveAuth(pAuthMsg->user, &pAuthRsp->spi, &pAuthRsp->encrypt, pAuthRsp->secret, pAuthRsp->ckey);
+  pMsg->rpcRsp.rsp = pAuthRsp;
-  rpcRsp.pCont = pAuthRsp;
+  pMsg->rpcRsp.len = sizeof(SDMAuthRsp);
-  rpcRsp.contLen = sizeof(SDMAuthRsp);
   
-  rpcSendResponse(&rpcRsp);
+  return mnodeRetriveAuth(pAuthMsg->user, &pAuthRsp->spi, &pAuthRsp->encrypt, pAuthRsp->secret, pAuthRsp->ckey);
 }

src/mnode/src/mnodeVgroup.c

@@ -23,30 +23,32 @@
 #include "ttime.h"
 #include "tbalance.h"
 #include "tglobal.h"
-#include "dnode.h"
 #include "tdataformat.h"
-#include "mgmtDef.h"
+#include "dnode.h"
-#include "mgmtInt.h"
+#include "mnode.h"
-#include "mgmtDb.h"
+#include "mnodeDef.h"
-#include "mgmtDnode.h"
+#include "mnodeInt.h"
-#include "mgmtMnode.h"
+#include "mnodeDb.h"
-#include "mgmtProfile.h"
+#include "mnodeDnode.h"
-#include "mgmtSdb.h"
+#include "mnodeMnode.h"
-#include "mgmtShell.h"
+#include "mnodeProfile.h"
-#include "mgmtTable.h"
+#include "mnodeSdb.h"
-#include "mgmtVgroup.h"
+#include "mnodeShow.h"
+#include "mnodeTable.h"
+#include "mnodeVgroup.h"
+#include "mnodePeer.h"
 
 static void   *tsVgroupSdb = NULL;
 static int32_t tsVgUpdateSize = 0;
 
-static int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn);
+static int32_t mnodeRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void    mgmtProcessCreateVnodeRsp(SRpcMsg *rpcMsg);
+static void    mnodeProcessCreateVnodeRsp(SRpcMsg *rpcMsg);
-static void    mgmtProcessDropVnodeRsp(SRpcMsg *rpcMsg);
+static void    mnodeProcessDropVnodeRsp(SRpcMsg *rpcMsg);
-static void    mgmtProcessVnodeCfgMsg(SRpcMsg *rpcMsg) ;
+static int32_t mnodeProcessVnodeCfgMsg(SMnodeMsg *pMsg) ;
-static void    mgmtSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle);
+static void    mnodeSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle);
 
-static int32_t mgmtVgroupActionDestroy(SSdbOper *pOper) {
+static int32_t mnodeVgroupActionDestroy(SSdbOper *pOper) {
   SVgObj *pVgroup = pOper->pObj;
   if (pVgroup->idPool) {
     taosIdPoolCleanUp(pVgroup->idPool);
@@ -60,11 +62,11 @@ static int32_t mgmtVgroupActionDestroy(SSdbOper *pOper) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtVgroupActionInsert(SSdbOper *pOper) {
+static int32_t mnodeVgroupActionInsert(SSdbOper *pOper) {
   SVgObj *pVgroup = pOper->pObj;
 
   // refer to db
-  SDbObj *pDb = mgmtGetDb(pVgroup->dbName);
+  SDbObj *pDb = mnodeGetDb(pVgroup->dbName);
   if (pDb == NULL) {
     return TSDB_CODE_INVALID_DB;
   }
@@ -88,40 +90,40 @@ static int32_t mgmtVgroupActionInsert(SSdbOper *pOper) {
   }
 
   for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    SDnodeObj *pDnode = mgmtGetDnode(pVgroup->vnodeGid[i].dnodeId);
+    SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId);
     if (pDnode != NULL) {
       pVgroup->vnodeGid[i].pDnode = pDnode;
       atomic_add_fetch_32(&pDnode->openVnodes, 1);
-      mgmtDecDnodeRef(pDnode);
+      mnodeDecDnodeRef(pDnode);
     }
   }
 
-  mgmtAddVgroupIntoDb(pVgroup);
+  mnodeAddVgroupIntoDb(pVgroup);
 
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtVgroupActionDelete(SSdbOper *pOper) {
+static int32_t mnodeVgroupActionDelete(SSdbOper *pOper) {
   SVgObj *pVgroup = pOper->pObj;
 
   if (pVgroup->pDb != NULL) {
-    mgmtRemoveVgroupFromDb(pVgroup);
+    mnodeRemoveVgroupFromDb(pVgroup);
   }
 
-  mgmtDecDbRef(pVgroup->pDb);
+  mnodeDecDbRef(pVgroup->pDb);
 
   for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    SDnodeObj *pDnode = mgmtGetDnode(pVgroup->vnodeGid[i].dnodeId);
+    SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId);
     if (pDnode != NULL) {
       atomic_sub_fetch_32(&pDnode->openVnodes, 1);
     }
-    mgmtDecDnodeRef(pDnode);
+    mnodeDecDnodeRef(pDnode);
   }
 
   return TSDB_CODE_SUCCESS;
 }
 
-static void mgmtVgroupUpdateIdPool(SVgObj *pVgroup) {
+static void mnodeVgroupUpdateIdPool(SVgObj *pVgroup) {
   int32_t oldTables = taosIdPoolMaxSize(pVgroup->idPool);
   SDbObj *pDb = pVgroup->pDb;
   if (pDb != NULL) {
@@ -135,9 +137,9 @@ static void mgmtVgroupUpdateIdPool(SVgObj *pVgroup) {
   }
 }
 
-static int32_t mgmtVgroupActionUpdate(SSdbOper *pOper) {
+static int32_t mnodeVgroupActionUpdate(SSdbOper *pOper) {
   SVgObj *pNew = pOper->pObj;
-  SVgObj *pVgroup = mgmtGetVgroup(pNew->vgId);
+  SVgObj *pVgroup = mnodeGetVgroup(pNew->vgId);
 
   if (pVgroup != pNew) {
     for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
@@ -151,24 +153,24 @@ static int32_t mgmtVgroupActionUpdate(SSdbOper *pOper) {
     free(pNew);
 
     for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-      SDnodeObj *pDnode = mgmtGetDnode(pVgroup->vnodeGid[i].dnodeId);
+      SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId);
       pVgroup->vnodeGid[i].pDnode = pDnode;
       if (pDnode != NULL) {
         atomic_add_fetch_32(&pDnode->openVnodes, 1);
       }
-      mgmtDecDnodeRef(pDnode);
+      mnodeDecDnodeRef(pDnode);
     }
   }
 
-  mgmtVgroupUpdateIdPool(pVgroup);
+  mnodeVgroupUpdateIdPool(pVgroup);
 
-  mgmtDecVgroupRef(pVgroup);
+  mnodeDecVgroupRef(pVgroup);
 
   mTrace("vgId:%d, is updated, numOfVnode:%d", pVgroup->vgId, pVgroup->numOfVnodes);
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtVgroupActionEncode(SSdbOper *pOper) {
+static int32_t mnodeVgroupActionEncode(SSdbOper *pOper) {
   SVgObj *pVgroup = pOper->pObj;
   memcpy(pOper->rowData, pVgroup, tsVgUpdateSize);
   SVgObj *pTmpVgroup = pOper->rowData;
@@ -181,7 +183,7 @@ static int32_t mgmtVgroupActionEncode(SSdbOper *pOper) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtVgroupActionDecode(SSdbOper *pOper) {
+static int32_t mnodeVgroupActionDecode(SSdbOper *pOper) {
   SVgObj *pVgroup = (SVgObj *) calloc(1, sizeof(SVgObj));
   if (pVgroup == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY;
 
@@ -190,11 +192,11 @@ static int32_t mgmtVgroupActionDecode(SSdbOper *pOper) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtVgroupActionRestored() {
+static int32_t mnodeVgroupActionRestored() {
   return 0;
 }
 
-int32_t mgmtInitVgroups() {
+int32_t mnodeInitVgroups() {
   SVgObj tObj;
   tsVgUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj;
 
@@ -205,13 +207,13 @@ int32_t mgmtInitVgroups() {
     .maxRowSize   = tsVgUpdateSize,
     .refCountPos  = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj,
     .keyType      = SDB_KEY_AUTO,
-    .insertFp     = mgmtVgroupActionInsert,
+    .insertFp     = mnodeVgroupActionInsert,
-    .deleteFp     = mgmtVgroupActionDelete,
+    .deleteFp     = mnodeVgroupActionDelete,
-    .updateFp     = mgmtVgroupActionUpdate,
+    .updateFp     = mnodeVgroupActionUpdate,
-    .encodeFp     = mgmtVgroupActionEncode,
+    .encodeFp     = mnodeVgroupActionEncode,
-    .decodeFp     = mgmtVgroupActionDecode,
+    .decodeFp     = mnodeVgroupActionDecode,
-    .destroyFp    = mgmtVgroupActionDestroy,
+    .destroyFp    = mnodeVgroupActionDestroy,
-    .restoredFp   = mgmtVgroupActionRestored,
+    .restoredFp   = mnodeVgroupActionRestored,
   };
 
   tsVgroupSdb = sdbOpenTable(&tableDesc);
@@ -220,30 +222,30 @@ int32_t mgmtInitVgroups() {
     return -1;
   }
 
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_VGROUP, mgmtGetVgroupMeta);
+  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VGROUP, mnodeGetVgroupMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_VGROUP, mgmtRetrieveVgroups);
+  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VGROUP, mnodeRetrieveVgroups);
-  dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP, mgmtProcessCreateVnodeRsp);
+  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP, mnodeProcessCreateVnodeRsp);
-  dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_DROP_VNODE_RSP, mgmtProcessDropVnodeRsp);
+  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_DROP_VNODE_RSP, mnodeProcessDropVnodeRsp);
-  dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_VNODE, mgmtProcessVnodeCfgMsg);
+  mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_VNODE, mnodeProcessVnodeCfgMsg);
 
   mTrace("table:vgroups is created");
   
   return 0;
 }
 
-void mgmtIncVgroupRef(SVgObj *pVgroup) {
+void mnodeIncVgroupRef(SVgObj *pVgroup) {
   return sdbIncRef(tsVgroupSdb, pVgroup); 
 }
 
-void mgmtDecVgroupRef(SVgObj *pVgroup) { 
+void mnodeDecVgroupRef(SVgObj *pVgroup) { 
   return sdbDecRef(tsVgroupSdb, pVgroup); 
 }
 
-SVgObj *mgmtGetVgroup(int32_t vgId) {
+SVgObj *mnodeGetVgroup(int32_t vgId) {
   return (SVgObj *)sdbGetRow(tsVgroupSdb, &vgId);
 }
 
-void mgmtUpdateVgroup(SVgObj *pVgroup) {
+void mnodeUpdateVgroup(SVgObj *pVgroup) {
   SSdbOper oper = {
     .type = SDB_OPER_GLOBAL,
     .table = tsVgroupSdb,
@@ -251,10 +253,10 @@ void mgmtUpdateVgroup(SVgObj *pVgroup) {
   };
 
   sdbUpdateRow(&oper);
-  mgmtSendCreateVgroupMsg(pVgroup, NULL);
+  mnodeSendCreateVgroupMsg(pVgroup, NULL);
 }
 
-void mgmtUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVload) {
+void mnodeUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVload) {
   bool dnodeExist = false;
   for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
     SVnodeGid *pVgid = &pVgroup->vnodeGid[i];
@@ -269,9 +271,9 @@ void mgmtUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVlo
   }
 
   if (!dnodeExist) {
-    SRpcIpSet ipSet = mgmtGetIpSetFromIp(pDnode->dnodeEp);
+    SRpcIpSet ipSet = mnodeGetIpSetFromIp(pDnode->dnodeEp);
     mError("vgId:%d, dnode:%d not exist in mnode, drop it", pVload->vgId, pDnode->dnodeId);
-    mgmtSendDropVnodeMsg(pVload->vgId, &ipSet, NULL);
+    mnodeSendDropVnodeMsg(pVload->vgId, &ipSet, NULL);
     return;
   }
 
@@ -282,22 +284,22 @@ void mgmtUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVlo
   }
 
   if (pVload->cfgVersion != pVgroup->pDb->cfgVersion || pVload->replica != pVgroup->numOfVnodes) {
-    mError("dnode:%d, vgId:%d, vnode cfgVersion:%d repica:%d not match with mgmt cfgVersion:%d replica:%d",
+    mError("dnode:%d, vgId:%d, vnode cfgVersion:%d repica:%d not match with mnode cfgVersion:%d replica:%d",
            pDnode->dnodeId, pVload->vgId, pVload->cfgVersion, pVload->replica, pVgroup->pDb->cfgVersion,
            pVgroup->numOfVnodes);
-    mgmtSendCreateVgroupMsg(pVgroup, NULL);
+    mnodeSendCreateVgroupMsg(pVgroup, NULL);
   }
 }
 
-SVgObj *mgmtGetAvailableVgroup(SDbObj *pDb) {
+SVgObj *mnodeGetAvailableVgroup(SDbObj *pDb) {
   return pDb->pHead;
 }
 
-void *mgmtGetNextVgroup(void *pIter, SVgObj **pVgroup) { 
+void *mnodeGetNextVgroup(void *pIter, SVgObj **pVgroup) { 
   return sdbFetchRow(tsVgroupSdb, pIter, (void **)pVgroup); 
 }
 
-void mgmtCreateVgroup(SQueuedMsg *pMsg, SDbObj *pDb) {
+int32_t mnodeCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) {
   SVgObj *pVgroup = (SVgObj *)calloc(1, sizeof(SVgObj));
   strcpy(pVgroup->dbName, pDb->name);
   pVgroup->numOfVnodes = pDb->cfg.replications;
@@ -305,9 +307,7 @@ void mgmtCreateVgroup(SQueuedMsg *pMsg, SDbObj *pDb) {
   if (balanceAllocVnodes(pVgroup) != 0) {
     mError("db:%s, no enough dnode to alloc %d vnodes to vgroup", pDb->name, pVgroup->numOfVnodes);
     free(pVgroup);
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_ENOUGH_DNODES);
+    return TSDB_CODE_NO_ENOUGH_DNODES;
-    mgmtFreeQueuedMsg(pMsg);
-    return;
   }
 
   SSdbOper oper = {
@@ -320,10 +320,7 @@ void mgmtCreateVgroup(SQueuedMsg *pMsg, SDbObj *pDb) {
   int32_t code = sdbInsertRow(&oper);
   if (code != TSDB_CODE_SUCCESS) {
     tfree(pVgroup);
-    code = TSDB_CODE_SDB_ERROR;
+    return TSDB_CODE_SDB_ERROR;
-    mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SDB_ERROR);
-    mgmtFreeQueuedMsg(pMsg);
-    return;
   }
 
   mPrint("vgId:%d, is created in mnode, db:%s replica:%d", pVgroup->vgId, pDb->name, pVgroup->numOfVnodes);
@@ -331,17 +328,20 @@ void mgmtCreateVgroup(SQueuedMsg *pMsg, SDbObj *pDb) {
     mPrint("vgId:%d, index:%d, dnode:%d", pVgroup->vgId, i, pVgroup->vnodeGid[i].dnodeId);
   }
 
-  pMsg->ahandle = pVgroup;
+  mnodeIncVgroupRef(pVgroup);
+  pMsg->pVgroup = pVgroup;
   pMsg->expected = pVgroup->numOfVnodes;
-  mgmtSendCreateVgroupMsg(pVgroup, pMsg);
+  mnodeSendCreateVgroupMsg(pVgroup, pMsg);
+
+  return TSDB_CODE_ACTION_IN_PROGRESS;
 }
 
-void mgmtDropVgroup(SVgObj *pVgroup, void *ahandle) {
+void mnodeDropVgroup(SVgObj *pVgroup, void *ahandle) {
   if (ahandle != NULL) {
-    mgmtSendDropVgroupMsg(pVgroup, ahandle);
+    mnodeSendDropVgroupMsg(pVgroup, ahandle);
   } else {
     mTrace("vgId:%d, replica:%d is deleting from sdb", pVgroup->vgId, pVgroup->numOfVnodes);
-    mgmtSendDropVgroupMsg(pVgroup, NULL);
+    mnodeSendDropVgroupMsg(pVgroup, NULL);
     SSdbOper oper = {
       .type = SDB_OPER_GLOBAL,
       .table = tsVgroupSdb,
@@ -351,12 +351,12 @@ void mgmtDropVgroup(SVgObj *pVgroup, void *ahandle) {
   }
 }
 
-void mgmtCleanUpVgroups() {
+void mnodeCleanupVgroups() {
   sdbCloseTable(tsVgroupSdb);
 }
 
-int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
+int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SDbObj *pDb = mgmtGetDb(pShow->db);
+  SDbObj *pDb = mnodeGetDb(pShow->db);
   if (pDb == NULL) {
     return TSDB_CODE_DB_NOT_SELECTED;
   }
@@ -380,15 +380,15 @@ int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   SVgObj  *pVgroup   = NULL;
   STableObj *pTable = NULL;
   if (pShow->payloadLen > 0 ) {
-    pTable = mgmtGetTable(pShow->payload);
+    pTable = mnodeGetTable(pShow->payload);
     if (NULL == pTable || pTable->type == TSDB_SUPER_TABLE) {
-      mgmtDecTableRef(pTable);
+      mnodeDecTableRef(pTable);
       return TSDB_CODE_INVALID_TABLE_ID;
     }
-    mgmtDecTableRef(pTable);
+    mnodeDecTableRef(pTable);
-    pVgroup = mgmtGetVgroup(((SChildTableObj*)pTable)->vgId);
+    pVgroup = mnodeGetVgroup(((SChildTableObj*)pTable)->vgId);
     if (NULL == pVgroup) return TSDB_CODE_INVALID_TABLE_ID;
-    mgmtDecVgroupRef(pVgroup);
+    mnodeDecVgroupRef(pVgroup);
     maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica;
   } else {
     SVgObj *pVgroup = pDb->pHead;
@@ -434,19 +434,19 @@ int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
     pShow->pIter = pVgroup;
   }
 
-   mgmtDecDbRef(pDb);
+   mnodeDecDbRef(pDb);
 
   return 0;
 }
 
-int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+int32_t mnodeRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
   int32_t numOfRows = 0;
   SVgObj *pVgroup = NULL;
   int32_t maxReplica = 0;
   int32_t cols = 0;
   char *  pWrite;
 
-  SDbObj *pDb = mgmtGetDb(pShow->db);
+  SDbObj *pDb = mnodeGetDb(pShow->db);
   if (pDb == NULL) return 0;
 
   pVgroup = pDb->pHead;
@@ -483,7 +483,7 @@ int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pCo
         cols++;
 
         pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-        char *role = mgmtGetMnodeRoleStr(pVgroup->vnodeGid[i].role);
+        char *role = mnodeGetMnodeRoleStr(pVgroup->vnodeGid[i].role);
         STR_TO_VARSTR(pWrite, role);
         cols++;
       } else {
@@ -502,12 +502,12 @@ int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pCo
   }
 
   pShow->numOfReads += numOfRows;
-  mgmtDecDbRef(pDb);
+  mnodeDecDbRef(pDb);
 
   return numOfRows;
 }
 
-void mgmtAddTableIntoVgroup(SVgObj *pVgroup, SChildTableObj *pTable) {
+void mnodeAddTableIntoVgroup(SVgObj *pVgroup, SChildTableObj *pTable) {
   if (pTable->sid >= 1 && pVgroup->tableList[pTable->sid - 1] == NULL) {
     pVgroup->tableList[pTable->sid - 1] = pTable;
     taosIdPoolMarkStatus(pVgroup->idPool, pTable->sid);
@@ -515,24 +515,24 @@ void mgmtAddTableIntoVgroup(SVgObj *pVgroup, SChildTableObj *pTable) {
   }
   
   if (pVgroup->numOfTables >= pVgroup->pDb->cfg.maxTables) {
-    mgmtMoveVgroupToTail(pVgroup);
+    mnodeMoveVgroupToTail(pVgroup);
   }
 
-  mgmtIncVgroupRef(pVgroup);
+  mnodeIncVgroupRef(pVgroup);
 }
 
-void mgmtRemoveTableFromVgroup(SVgObj *pVgroup, SChildTableObj *pTable) {
+void mnodeRemoveTableFromVgroup(SVgObj *pVgroup, SChildTableObj *pTable) {
   if (pTable->sid >= 1 && pVgroup->tableList[pTable->sid - 1] != NULL) {
     pVgroup->tableList[pTable->sid - 1] = NULL;
     taosFreeId(pVgroup->idPool, pTable->sid);
     pVgroup->numOfTables--;
   }
 
-  mgmtMoveVgroupToHead(pVgroup);
+  mnodeMoveVgroupToHead(pVgroup);
-  mgmtDecVgroupRef(pVgroup);
+  mnodeDecVgroupRef(pVgroup);
 }
 
-SMDCreateVnodeMsg *mgmtBuildCreateVnodeMsg(SVgObj *pVgroup) {
+SMDCreateVnodeMsg *mnodeBuildCreateVnodeMsg(SVgObj *pVgroup) {
   SDbObj *pDb = pVgroup->pDb;
   if (pDb == NULL) return NULL;
 
@@ -571,7 +571,7 @@ SMDCreateVnodeMsg *mgmtBuildCreateVnodeMsg(SVgObj *pVgroup) {
   return pVnode;
 }
 
-SRpcIpSet mgmtGetIpSetFromVgroup(SVgObj *pVgroup) {
+SRpcIpSet mnodeGetIpSetFromVgroup(SVgObj *pVgroup) {
   SRpcIpSet ipSet = {
     .numOfIps = pVgroup->numOfVnodes,
     .inUse = 0,
@@ -583,7 +583,7 @@ SRpcIpSet mgmtGetIpSetFromVgroup(SVgObj *pVgroup) {
   return ipSet;
 }
 
-SRpcIpSet mgmtGetIpSetFromIp(char *ep) {
+SRpcIpSet mnodeGetIpSetFromIp(char *ep) {
   SRpcIpSet ipSet;
 
   ipSet.numOfIps = 1;
@@ -593,9 +593,9 @@ SRpcIpSet mgmtGetIpSetFromIp(char *ep) {
   return ipSet;
 }
 
-void mgmtSendCreateVnodeMsg(SVgObj *pVgroup, SRpcIpSet *ipSet, void *ahandle) {
+void mnodeSendCreateVnodeMsg(SVgObj *pVgroup, SRpcIpSet *ipSet, void *ahandle) {
   mTrace("vgId:%d, send create vnode:%d msg, ahandle:%p", pVgroup->vgId, pVgroup->vgId, ahandle);
-  SMDCreateVnodeMsg *pCreate = mgmtBuildCreateVnodeMsg(pVgroup);
+  SMDCreateVnodeMsg *pCreate = mnodeBuildCreateVnodeMsg(pVgroup);
   SRpcMsg rpcMsg = {
     .handle  = ahandle,
     .pCont   = pCreate,
@@ -606,34 +606,33 @@ void mgmtSendCreateVnodeMsg(SVgObj *pVgroup, SRpcIpSet *ipSet, void *ahandle) {
   dnodeSendMsgToDnode(ipSet, &rpcMsg);
 }
 
-void mgmtSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle) {
+void mnodeSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle) {
   mTrace("vgId:%d, send create all vnodes msg, ahandle:%p", pVgroup->vgId, ahandle);
   for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    SRpcIpSet ipSet = mgmtGetIpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
+    SRpcIpSet ipSet = mnodeGetIpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
-    mgmtSendCreateVnodeMsg(pVgroup, &ipSet, ahandle);
+    mnodeSendCreateVnodeMsg(pVgroup, &ipSet, ahandle);
   }
 }
 
-static void mgmtProcessCreateVnodeRsp(SRpcMsg *rpcMsg) {
+static void mnodeProcessCreateVnodeRsp(SRpcMsg *rpcMsg) {
   if (rpcMsg->handle == NULL) return;
 
-  SQueuedMsg *queueMsg = rpcMsg->handle;
+  SMnodeMsg *mnodeMsg = rpcMsg->handle;
-  queueMsg->received++;
+  mnodeMsg->received++;
   if (rpcMsg->code == TSDB_CODE_SUCCESS) {
-    queueMsg->code = rpcMsg->code;
+    mnodeMsg->code = rpcMsg->code;
-    queueMsg->successed++;
+    mnodeMsg->successed++;
   }
 
-  SVgObj *pVgroup = queueMsg->ahandle;
+  SVgObj *pVgroup = mnodeMsg->pVgroup;
   mTrace("vgId:%d, create vnode rsp received, result:%s received:%d successed:%d expected:%d, thandle:%p ahandle:%p",
-         pVgroup->vgId, tstrerror(rpcMsg->code), queueMsg->received, queueMsg->successed, queueMsg->expected,
+         pVgroup->vgId, tstrerror(rpcMsg->code), mnodeMsg->received, mnodeMsg->successed, mnodeMsg->expected,
-         queueMsg->thandle, rpcMsg->handle);
+         mnodeMsg->rpcMsg.handle, rpcMsg->handle);
 
-  if (queueMsg->received != queueMsg->expected) return;
+  if (mnodeMsg->received != mnodeMsg->expected) return;
 
-  if (queueMsg->received == queueMsg->successed) {
+  if (mnodeMsg->received == mnodeMsg->successed) {
-    SQueuedMsg *newMsg = mgmtCloneQueuedMsg(queueMsg);
+    dnodeReprocessMnodeWriteMsg(mnodeMsg);
-    mgmtAddToShellQueue(newMsg);
   } else {
     SSdbOper oper = {
       .type = SDB_OPER_GLOBAL,
@@ -645,13 +644,11 @@ static void mgmtProcessCreateVnodeRsp(SRpcMsg *rpcMsg) {
       code = TSDB_CODE_SDB_ERROR;
     }
 
-    mgmtSendSimpleResp(queueMsg->thandle, rpcMsg->code);
+    dnodeSendRpcMnodeWriteRsp(mnodeMsg, code);
+  }
 }
 
-  mgmtFreeQueuedMsg(queueMsg);
+static SMDDropVnodeMsg *mnodeBuildDropVnodeMsg(int32_t vgId) {
-}
-
-static SMDDropVnodeMsg *mgmtBuildDropVnodeMsg(int32_t vgId) {
   SMDDropVnodeMsg *pDrop = rpcMallocCont(sizeof(SMDDropVnodeMsg));
   if (pDrop == NULL) return NULL;
 
@@ -659,8 +656,8 @@ static SMDDropVnodeMsg *mgmtBuildDropVnodeMsg(int32_t vgId) {
   return pDrop;
 }
 
-void mgmtSendDropVnodeMsg(int32_t vgId, SRpcIpSet *ipSet, void *ahandle) {
+void mnodeSendDropVnodeMsg(int32_t vgId, SRpcIpSet *ipSet, void *ahandle) {
-  SMDDropVnodeMsg *pDrop = mgmtBuildDropVnodeMsg(vgId);
+  SMDDropVnodeMsg *pDrop = mnodeBuildDropVnodeMsg(vgId);
   SRpcMsg rpcMsg = {
       .handle  = ahandle,
       .pCont   = pDrop,
@@ -671,32 +668,32 @@ void mgmtSendDropVnodeMsg(int32_t vgId, SRpcIpSet *ipSet, void *ahandle) {
   dnodeSendMsgToDnode(ipSet, &rpcMsg);
 }
 
-static void mgmtSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle) {
+static void mnodeSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle) {
   mTrace("vgId:%d, send drop all vnodes msg, ahandle:%p", pVgroup->vgId, ahandle);
   for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    SRpcIpSet ipSet = mgmtGetIpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
+    SRpcIpSet ipSet = mnodeGetIpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
     mTrace("vgId:%d, send drop vnode msg to dnode:%d, ahandle:%p", pVgroup->vgId, pVgroup->vnodeGid[i].dnodeId, ahandle);
-    mgmtSendDropVnodeMsg(pVgroup->vgId, &ipSet, ahandle);
+    mnodeSendDropVnodeMsg(pVgroup->vgId, &ipSet, ahandle);
   }
 }
 
-static void mgmtProcessDropVnodeRsp(SRpcMsg *rpcMsg) {
+static void mnodeProcessDropVnodeRsp(SRpcMsg *rpcMsg) {
   mTrace("drop vnode rsp is received, handle:%p", rpcMsg->handle);
   if (rpcMsg->handle == NULL) return;
 
-  SQueuedMsg *queueMsg = rpcMsg->handle;
+  SMnodeMsg *mnodeMsg = rpcMsg->handle;
-  queueMsg->received++;
+  mnodeMsg->received++;
   if (rpcMsg->code == TSDB_CODE_SUCCESS) {
-    queueMsg->code = rpcMsg->code;
+    mnodeMsg->code = rpcMsg->code;
-    queueMsg->successed++;
+    mnodeMsg->successed++;
   }
 
-  SVgObj *pVgroup = queueMsg->ahandle;
+  SVgObj *pVgroup = mnodeMsg->pVgroup;
   mTrace("vgId:%d, drop vnode rsp received, result:%s received:%d successed:%d expected:%d, thandle:%p ahandle:%p",
-         pVgroup->vgId, tstrerror(rpcMsg->code), queueMsg->received, queueMsg->successed, queueMsg->expected,
+         pVgroup->vgId, tstrerror(rpcMsg->code), mnodeMsg->received, mnodeMsg->successed, mnodeMsg->expected,
-         queueMsg->thandle, rpcMsg->handle);
+         mnodeMsg->rpcMsg.handle, rpcMsg->handle);
 
-  if (queueMsg->received != queueMsg->expected) return;
+  if (mnodeMsg->received != mnodeMsg->expected) return;
 
   SSdbOper oper = {
     .type = SDB_OPER_GLOBAL,
@@ -708,41 +705,35 @@ static void mgmtProcessDropVnodeRsp(SRpcMsg *rpcMsg) {
     code = TSDB_CODE_SDB_ERROR;
   }
 
-  SQueuedMsg *newMsg = mgmtCloneQueuedMsg(queueMsg);
+  dnodeReprocessMnodeWriteMsg(mnodeMsg);
-  mgmtAddToShellQueue(newMsg);
-
-  queueMsg->pCont = NULL;
-  mgmtFreeQueuedMsg(queueMsg);
 }
 
-static void mgmtProcessVnodeCfgMsg(SRpcMsg *rpcMsg) {
+static int32_t mnodeProcessVnodeCfgMsg(SMnodeMsg *pMsg) {
-  SDMConfigVnodeMsg *pCfg = (SDMConfigVnodeMsg *) rpcMsg->pCont;
+  SDMConfigVnodeMsg *pCfg = pMsg->rpcMsg.pCont;
   pCfg->dnodeId = htonl(pCfg->dnodeId);
   pCfg->vgId    = htonl(pCfg->vgId);
 
-  SDnodeObj *pDnode = mgmtGetDnode(pCfg->dnodeId);
+  SDnodeObj *pDnode = mnodeGetDnode(pCfg->dnodeId);
   if (pDnode == NULL) {
     mTrace("dnode:%s, invalid dnode", taosIpStr(pCfg->dnodeId), pCfg->vgId);
-    mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_NOT_ACTIVE_VNODE);
+    return TSDB_CODE_INVALID_VGROUP_ID;
-    return;
   }
-  mgmtDecDnodeRef(pDnode);
+  mnodeDecDnodeRef(pDnode);
 
-  SVgObj *pVgroup = mgmtGetVgroup(pCfg->vgId);
+  SVgObj *pVgroup = mnodeGetVgroup(pCfg->vgId);
   if (pVgroup == NULL) {
     mTrace("dnode:%s, vgId:%d, no vgroup info", taosIpStr(pCfg->dnodeId), pCfg->vgId);
-    mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_NOT_ACTIVE_VNODE);
+    return TSDB_CODE_INVALID_VGROUP_ID;
-    return;
   }
-  mgmtDecVgroupRef(pVgroup);
+  mnodeDecVgroupRef(pVgroup);
 
-  mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_SUCCESS);
+  SRpcIpSet ipSet = mnodeGetIpSetFromIp(pDnode->dnodeEp);
+  mnodeSendCreateVnodeMsg(pVgroup, &ipSet, NULL);
 
-  SRpcIpSet ipSet = mgmtGetIpSetFromIp(pDnode->dnodeEp);
+  return TSDB_CODE_SUCCESS;
-  mgmtSendCreateVnodeMsg(pVgroup, &ipSet, NULL);
 }
 
-void mgmtDropAllDnodeVgroups(SDnodeObj *pDropDnode) {
+void mnodeDropAllDnodeVgroups(SDnodeObj *pDropDnode) {
   void *  pIter = NULL;
   SVgObj *pVgroup = NULL;
   int32_t numOfVgroups = 0;
@@ -750,11 +741,11 @@ void mgmtDropAllDnodeVgroups(SDnodeObj *pDropDnode) {
   mPrint("dnode:%d, all vgroups will be dropped from sdb", pDropDnode->dnodeId);
 
   while (1) {
-    pIter = mgmtGetNextVgroup(pIter, &pVgroup);
+    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
     if (pVgroup == NULL) break;
 
     if (pVgroup->vnodeGid[0].dnodeId == pDropDnode->dnodeId) {
-      mgmtDropAllChildTablesInVgroups(pVgroup);
+      mnodeDropAllChildTablesInVgroups(pVgroup);
       SSdbOper oper = {
         .type = SDB_OPER_LOCAL,
         .table = tsVgroupSdb,
@@ -763,7 +754,7 @@ void mgmtDropAllDnodeVgroups(SDnodeObj *pDropDnode) {
       sdbDeleteRow(&oper);
       numOfVgroups++;
     }
-    mgmtDecVgroupRef(pVgroup);
+    mnodeDecVgroupRef(pVgroup);
   }
 
   sdbFreeIter(pIter);
@@ -771,21 +762,21 @@ void mgmtDropAllDnodeVgroups(SDnodeObj *pDropDnode) {
   mPrint("dnode:%d, all vgroups is dropped from sdb", pDropDnode->dnodeId);
 }
 
-void mgmtUpdateAllDbVgroups(SDbObj *pAlterDb) {
+void mnodeUpdateAllDbVgroups(SDbObj *pAlterDb) {
   void *  pIter = NULL;
   SVgObj *pVgroup = NULL;
 
   mPrint("db:%s, all vgroups will be update in sdb", pAlterDb->name);
 
   while (1) {
-    pIter = mgmtGetNextVgroup(pIter, &pVgroup);
+    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
     if (pVgroup == NULL) break;
 
     if (pVgroup->pDb == pAlterDb) {
-      mgmtVgroupUpdateIdPool(pVgroup);
+      mnodeVgroupUpdateIdPool(pVgroup);
     }
 
-    mgmtDecVgroupRef(pVgroup);
+    mnodeDecVgroupRef(pVgroup);
   }
 
   sdbFreeIter(pIter);
@@ -793,14 +784,14 @@ void mgmtUpdateAllDbVgroups(SDbObj *pAlterDb) {
   mPrint("db:%s, all vgroups is updated in sdb", pAlterDb->name);
 }
 
-void mgmtDropAllDbVgroups(SDbObj *pDropDb, bool sendMsg) {
+void mnodeDropAllDbVgroups(SDbObj *pDropDb) {
   void *  pIter = NULL;
   int32_t numOfVgroups = 0;
   SVgObj *pVgroup = NULL;
 
   mPrint("db:%s, all vgroups will be dropped from sdb", pDropDb->name);
   while (1) {
-    pIter = mgmtGetNextVgroup(pIter, &pVgroup);
+    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
     if (pVgroup == NULL) break;
 
     if (pVgroup->pDb == pDropDb) {
@@ -811,16 +802,34 @@ void mgmtDropAllDbVgroups(SDbObj *pDropDb, bool sendMsg) {
       };
       sdbDeleteRow(&oper);
       numOfVgroups++;
-
-      if (sendMsg) {
-        mgmtSendDropVgroupMsg(pVgroup, NULL);
-      }
     }
 
-    mgmtDecVgroupRef(pVgroup);
+    mnodeDecVgroupRef(pVgroup);
   }
 
   sdbFreeIter(pIter);
 
   mPrint("db:%s, all vgroups:%d is dropped from sdb", pDropDb->name, numOfVgroups);
 }
+
+void mnodeSendDropAllDbVgroupsMsg(SDbObj *pDropDb) {
+  void *  pIter = NULL;
+  int32_t numOfVgroups = 0;
+  SVgObj *pVgroup = NULL;
+
+  mPrint("db:%s, all vgroups will be dropped in dnode", pDropDb->name);
+  while (1) {
+    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
+    if (pVgroup == NULL) break;
+
+    if (pVgroup->pDb == pDropDb) {
+      mnodeSendDropVgroupMsg(pVgroup, NULL);
+    }
+
+    mnodeDecVgroupRef(pVgroup);
+  }
+
+  sdbFreeIter(pIter);
+
+  mPrint("db:%s, all vgroups:%d drop msg is sent to dnode", pDropDb->name, numOfVgroups);
+}

src/mnode/src/mnodeWrite.c

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "taosdef.h"
+#include "tsched.h"
+#include "tbalance.h"
+#include "tgrant.h"
+#include "tglobal.h"
+#include "trpc.h"
+#include "mnode.h"
+#include "dnode.h"
+#include "mnodeDef.h"
+#include "mnodeInt.h"
+#include "mnodeAcct.h"
+#include "mnodeDnode.h"
+#include "mnodeMnode.h"
+#include "mnodeDb.h"
+#include "mnodeSdb.h"
+#include "mnodeVgroup.h"
+#include "mnodeUser.h"
+#include "mnodeTable.h"
+#include "mnodeShow.h"
+
+static int32_t (*tsMnodeProcessWriteMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *);
+
+void mnodeAddWriteMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg)) {
+  tsMnodeProcessWriteMsgFp[msgType] = fp;
+}
+
+int32_t mnodeProcessWrite(SMnodeMsg *pMsg) {
+  if (pMsg->rpcMsg.pCont == NULL) {
+    mError("%p, msg:%s  in mwrite queue, content is null", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
+    return TSDB_CODE_INVALID_MSG_LEN;
+  }
+
+  if (!sdbIsMaster()) {
+    SMnodeRsp *rpcRsp = &pMsg->rpcRsp;
+    SRpcIpSet *ipSet = rpcMallocCont(sizeof(SRpcIpSet));
+    mnodeGetMnodeIpSetForShell(ipSet);
+    rpcRsp->rsp = ipSet;
+    rpcRsp->len = sizeof(SRpcIpSet);
+
+    mTrace("%p, msg:%s in mwrite queue, will be redireced inUse:%d", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], ipSet->inUse);
+    for (int32_t i = 0; i < ipSet->numOfIps; ++i) {
+      mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i]));
+    }
+
+    return TSDB_CODE_REDIRECT;
+  }
+
+  if (tsMnodeProcessWriteMsgFp[pMsg->rpcMsg.msgType] == NULL) {
+    mError("%p, msg:%s in mwrite queue, not processed", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
+    return TSDB_CODE_MSG_NOT_PROCESSED;
+  }
+
+  int32_t code = mnodeInitMsg(pMsg);
+  if (code != TSDB_CODE_SUCCESS) {
+    mError("%p, msg:%s in mwrite queue, not processed reason:%s", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], tstrerror(code));
+    return code;
+  }
+
+  if (!pMsg->pUser->writeAuth) {
+    mError("%p, msg:%s  in mwrite queue, not processed, no write auth", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
+    return TSDB_CODE_NO_RIGHTS;
+  }
+
+  return (*tsMnodeProcessWriteMsgFp[pMsg->rpcMsg.msgType])(pMsg);
+}

src/plugins/http/src/httpJson.c

@@ -445,7 +445,7 @@ void httpJsonPairStatus(JsonBuf* buf, int code) {
       httpJsonItemToken(buf);
       if (code == TSDB_CODE_DB_NOT_SELECTED) {
         httpJsonPair(buf, "desc", 4, "failed to create database", 23);
-      } else if (code == TSDB_CODE_INVALID_TABLE) {
+      } else if (code == TSDB_CODE_INVALID_TABLE_ID) {
         httpJsonPair(buf, "desc", 4, "failed to create table", 22);
       } else
         httpJsonPair(buf, "desc", 4, (char*)tstrerror(code), (int)strlen(tstrerror(code)));

src/plugins/http/src/tgHandle.c

@@ -281,7 +281,7 @@ int tgReadSchema(char *fileName) {
 }
 
 void tgInitHandle(HttpServer *pServer) {
-  char fileName[256] = {0};
+  char fileName[TSDB_FILENAME_LEN*2] = {0};
   sprintf(fileName, "%s/taos.telegraf.cfg", configDir);
   if (tgReadSchema(fileName) <= 0) {
     tgFreeSchemas();

src/plugins/http/src/tgJson.c

@@ -111,7 +111,7 @@ bool tgCheckFinished(struct HttpContext *pContext, HttpSqlCmd *cmd, int code) {
                     pContext->ipstr);
           return false;
         }
-      } else if (code == TSDB_CODE_INVALID_TABLE) {
+      } else if (code == TSDB_CODE_INVALID_TABLE_ID) {
         cmd->cmdState = HTTP_CMD_STATE_RUN_FINISHED;
         if (multiCmds->cmds[multiCmds->pos - 1].cmdState == HTTP_CMD_STATE_NOT_RUN_YET) {
           multiCmds->pos = (int16_t)(multiCmds->pos - 2);

src/query/inc/qExecutor.h

@@ -28,11 +28,6 @@
 #include "tsdb.h"
 #include "tsqlfunction.h"
 
-//typedef struct tFilePage {
-//  int64_t num;
-//  char    data[];
-//} tFilePage;
-
 struct SColumnFilterElem;
 typedef bool (*__filter_func_t)(struct SColumnFilterElem* pFilter, char* val1, char* val2);
 typedef int32_t (*__block_search_fn_t)(char* data, int32_t num, int64_t key, int32_t order);
@@ -62,25 +57,27 @@ typedef struct SWindowResult {
   SWindowStatus status;      // this result status: closed or opened
 } SWindowResult;
 
+/**
+ * If the number of generated results is greater than this value,
+ * query query will be halt and return results to client immediate.
+ */
 typedef struct SResultRec {
   int64_t total;      // total generated result size in rows
   int64_t rows;       // current result set size in rows
   int64_t capacity;   // capacity of current result output buffer
-  
+  int32_t threshold;  // result size threshold in rows.
-  // result size threshold in rows. If the result buffer is larger than this, pause query and return to client
-  int32_t threshold;
 } SResultRec;
 
 typedef struct SWindowResInfo {
   SWindowResult* pResult;    // result list
-  void*          hashList;   // hash list for quick access
+  SHashObj*      hashList;   // hash list for quick access
   int16_t        type;       // data type for hash key
   int32_t        capacity;   // max capacity
   int32_t        curIndex;   // current start active index
   int32_t        size;       // number of result set
   int64_t        startTime;  // start time of the first time window for sliding query
   int64_t        prevSKey;   // previous (not completed) sliding window start key
-  int64_t        threshold;  // threshold to pausing query and return closed results.
+  int64_t        threshold;  // threshold to halt query and return the generated results.
 } SWindowResInfo;
 
 typedef struct SColumnFilterElem {
@@ -90,15 +87,15 @@ typedef struct SColumnFilterElem {
 } SColumnFilterElem;
 
 typedef struct SSingleColumnFilterInfo {
-  SColumnInfo        info;
-  int32_t            numOfFilters;
-  SColumnFilterElem* pFilters;
   void*              pData;
+  int32_t            numOfFilters;
+  SColumnInfo        info;
+  SColumnFilterElem* pFilters;
 } SSingleColumnFilterInfo;
 
 typedef struct STableQueryInfo {  // todo merge with the STableQueryInfo struct
   int32_t     tableIndex;
-  int32_t     groupIdx;       // group id in table list
+  int32_t     groupIndex;  // group id in table list
   TSKEY       lastKey;
   int32_t     numOfRes;
   int16_t     queryRangeSet;  // denote if the query range is set, only available for interval query
@@ -110,8 +107,21 @@ typedef struct STableQueryInfo {  // todo merge with the STableQueryInfo struct
   SWindowResInfo windowResInfo;
 } STableQueryInfo;
 
-typedef struct SQueryCostSummary {
+typedef struct SQueryCostInfo {
-} SQueryCostSummary;
+  uint64_t loadStatisTime;
+  uint64_t loadFileBlockTime;
+  uint64_t loadDataInCacheTime;
+  uint64_t loadStatisSize;
+  uint64_t loadFileBlockSize;
+  uint64_t loadDataInCacheSize;
+  
+  uint64_t loadDataTime;
+  uint64_t dataInRows;
+  uint64_t checkRows;
+  uint32_t dataBlocks;
+  uint32_t loadBlockStatis;
+  uint32_t discardBlocks;
+} SQueryCostInfo;
 
 typedef struct SGroupItem {
   STableId         id;
@@ -121,7 +131,6 @@ typedef struct SGroupItem {
 typedef struct SQuery {
   int16_t          numOfCols;
   int16_t          numOfTags;
-  
   SOrderVal        order;
   STimeWindow      window;
   int64_t          intervalTime;
@@ -144,6 +153,7 @@ typedef struct SQuery {
   int32_t          pos;
   tFilePage**      sdata;
   STableQueryInfo* current;
+
   SSingleColumnFilterInfo* pFilterInfo;
 } SQuery;
 
@@ -158,7 +168,7 @@ typedef struct SQueryRuntimeEnv {
   SWindowResInfo       windowResInfo;
   STSBuf*              pTSBuf;
   STSCursor            cur;
-  SQueryCostSummary  summary;
+  SQueryCostInfo    summary;
   bool                 stableQuery;  // super table query or not
   void*                pQueryHandle;
   void*                pSecQueryHandle;  // another thread for

src/query/inc/tsqlfunction.h

@@ -237,7 +237,7 @@ enum {
 /* determine the real data need to calculated the result */
 enum {
   BLK_DATA_NO_NEEDED = 0x0,
-  BLK_DATA_FILEDS_NEEDED = 0x1,
+  BLK_DATA_STATIS_NEEDED = 0x1,
   BLK_DATA_ALL_NEEDED = 0x3,
 };
 

src/tsdb/inc/tsdbMain.h

@@ -87,6 +87,7 @@ typedef struct STable {
   struct STable *prev;
   tstr *         name;  // NOTE: there a flexible string here
   char *         sql;
+  void *         cqhandle;
 } STable;
 
 #define TSDB_GET_TABLE_LAST_KEY(tb) ((tb)->lastKey)
@@ -110,6 +111,7 @@ typedef struct {
   SMetaFile *mfh;  // meta file handle
   int        maxRowBytes;
   int        maxCols;
+  void *     pRepo;
 } STsdbMeta;
 
 // element put in skiplist for each table
@@ -118,7 +120,7 @@ typedef struct STableIndexElem {
   STable*    pTable;
 } STableIndexElem;
 
-STsdbMeta *tsdbInitMeta(char *rootDir, int32_t maxTables);
+STsdbMeta *tsdbInitMeta(char *rootDir, int32_t maxTables, void *pRepo);
 int32_t    tsdbFreeMeta(STsdbMeta *pMeta);
 STSchema * tsdbGetTableSchema(STsdbMeta *pMeta, STable *pTable);
 STSchema * tsdbGetTableTagSchema(STsdbMeta *pMeta, STable *pTable);

src/tsdb/src/tsdbMain.c

@@ -189,9 +189,9 @@ _err:
  *
  * @return a TSDB repository handle on success, NULL for failure and the error number is set
  */
-TsdbRepoT *tsdbOpenRepo(char *tsdbDir, STsdbAppH *pAppH) {
+TsdbRepoT *tsdbOpenRepo(char *rootDir, STsdbAppH *pAppH) {
   char dataDir[128] = "\0";
-  if (access(tsdbDir, F_OK | W_OK | R_OK) < 0) {
+  if (access(rootDir, F_OK | W_OK | R_OK) < 0) {
     return NULL;
   }
 
@@ -200,12 +200,12 @@ TsdbRepoT *tsdbOpenRepo(char *tsdbDir, STsdbAppH *pAppH) {
     return NULL;
   }
 
-  pRepo->rootDir = strdup(tsdbDir);
+  pRepo->rootDir = strdup(rootDir);
 
   tsdbRestoreCfg(pRepo, &(pRepo->config));
   if (pAppH) pRepo->appH = *pAppH;
 
-  pRepo->tsdbMeta = tsdbInitMeta(tsdbDir, pRepo->config.maxTables);
+  pRepo->tsdbMeta = tsdbInitMeta(rootDir, pRepo->config.maxTables, pRepo);
   if (pRepo->tsdbMeta == NULL) {
     free(pRepo->rootDir);
     free(pRepo);

src/tsdb/src/tsdbMeta.c

@@ -143,6 +143,7 @@ int tsdbRestoreTable(void *pHandle, void *cont, int contLen) {
 
 void tsdbOrgMeta(void *pHandle) {
   STsdbMeta *pMeta = (STsdbMeta *)pHandle;
+  STsdbRepo *pRepo = (STsdbRepo *)pMeta->pRepo;
 
   for (int i = 1; i < pMeta->maxTables; i++) {
     STable *pTable = pMeta->tables[i];
@@ -150,13 +151,20 @@ void tsdbOrgMeta(void *pHandle) {
       tsdbAddTableIntoIndex(pMeta, pTable);
     }
   }
+
+  for (int i = 0; i < pMeta->maxTables; i++) {
+    STable *pTable = pMeta->tables[i];
+    if (pTable && pTable->type == TSDB_STREAM_TABLE) {
+      pTable->cqhandle = (*pRepo->appH.cqCreateFunc)(pRepo->appH.cqH, i, pTable->sql, tsdbGetTableSchema(pMeta, pTable));
+    }
+  }
 }
 
 /**
  * Initialize the meta handle
  * ASSUMPTIONS: VALID PARAMETER
  */
-STsdbMeta *tsdbInitMeta(char *rootDir, int32_t maxTables) {
+STsdbMeta *tsdbInitMeta(char *rootDir, int32_t maxTables, void *pRepo) {
   STsdbMeta *pMeta = (STsdbMeta *)malloc(sizeof(STsdbMeta));
   if (pMeta == NULL) return NULL;
 
@@ -166,6 +174,7 @@ STsdbMeta *tsdbInitMeta(char *rootDir, int32_t maxTables) {
   pMeta->tables = (STable **)calloc(maxTables, sizeof(STable *));
   pMeta->maxRowBytes = 0;
   pMeta->maxCols = 0;
+  pMeta->pRepo = pRepo;
   if (pMeta->tables == NULL) {
     free(pMeta);
     return NULL;
@@ -190,13 +199,16 @@ STsdbMeta *tsdbInitMeta(char *rootDir, int32_t maxTables) {
 }
 
 int32_t tsdbFreeMeta(STsdbMeta *pMeta) {
+  STsdbRepo *pRepo = (STsdbRepo *)pMeta->pRepo;
   if (pMeta == NULL) return 0;
 
   tsdbCloseMetaFile(pMeta->mfh);
 
   for (int i = 1; i < pMeta->maxTables; i++) {
     if (pMeta->tables[i] != NULL) {
-      tsdbFreeTable(pMeta->tables[i]);
+      STable *pTable = pMeta->tables[i];
+      if (pTable->type == TSDB_STREAM_TABLE) (*pRepo->appH.cqDropFunc)(pTable->cqhandle);
+      tsdbFreeTable(pTable);
     }
   }
 
@@ -503,6 +515,7 @@ STable *tsdbGetTableByUid(STsdbMeta *pMeta, uint64_t uid) {
 }
 
 static int tsdbAddTableToMeta(STsdbMeta *pMeta, STable *pTable, bool addIdx) {
+  STsdbRepo *pRepo = (STsdbRepo *)pMeta->pRepo;
   if (pTable->type == TSDB_SUPER_TABLE) { 
     // add super table to the linked list
     if (pMeta->superList == NULL) {
@@ -522,7 +535,7 @@ static int tsdbAddTableToMeta(STsdbMeta *pMeta, STable *pTable, bool addIdx) {
       tsdbAddTableIntoIndex(pMeta, pTable);
     }
     if (pTable->type == TSDB_STREAM_TABLE && addIdx) {
-      // TODO
+      pTable->cqhandle = (*pRepo->appH.cqCreateFunc)(pRepo->appH.cqH, pTable->tableId.tid, pTable->sql, tsdbGetTableSchema(pMeta, pTable));
     }
     
     pMeta->nTables++;

src/tsdb/src/tsdbRead.c

@@ -1680,6 +1680,13 @@ int32_t tsdbRetrieveDataBlockStatisInfo(TsdbQueryHandleT* pQueryHandle, SDataSta
       ((cur->slot == pHandle->numOfBlocks) && (cur->slot == 0)));
   
   STableBlockInfo* pBlockInfo = &pHandle->pDataBlockInfo[cur->slot];
+  
+  // file block with subblocks has no statistics data
+  if (pBlockInfo->compBlock->numOfSubBlocks > 1) {
+    *pBlockStatis = NULL;
+    return TSDB_CODE_SUCCESS;
+  }
+  
   tsdbLoadCompData(&pHandle->rhelper, pBlockInfo->compBlock, NULL);
   
   size_t numOfCols = QH_GET_NUM_OF_COLS(pHandle);

src/util/src/tconfig.c

@@ -242,6 +242,11 @@ void taosReadGlobalLogCfg() {
   wordexp_t full_path;
   wordexp(configDir, &full_path, 0);
   if (full_path.we_wordv != NULL && full_path.we_wordv[0] != NULL) {    
+    if (strlen(full_path.we_wordv[0]) > TSDB_FILENAME_LEN - 1) {
+      printf("\nconfig file: %s path overflow max len %d, all variables are set to default\n", full_path.we_wordv[0], TSDB_FILENAME_LEN - 1);
+      wordfree(&full_path);
+      return;
+    }
     strcpy(configDir, full_path.we_wordv[0]);
   } else {
     printf("configDir:%s not there, use default value: /etc/taos", configDir);

src/util/src/tqueue.c

@@ -18,24 +18,24 @@
 #include "taoserror.h"
 #include "tqueue.h"
 
-typedef struct _taos_qnode {
+typedef struct STaosQnode {
   int                 type;
-  struct _taos_qnode *next;
+  struct STaosQnode  *next;
   char                item[];
 } STaosQnode;
 
-typedef struct _taos_q {
+typedef struct STaosQueue {
   int32_t             itemSize;
   int32_t             numOfItems;
-  struct _taos_qnode *head;
+  struct STaosQnode  *head;
-  struct _taos_qnode *tail;
+  struct STaosQnode  *tail;
-  struct _taos_q     *next;    // for queue set
+  struct STaosQueue  *next;    // for queue set
-  struct _taos_qset  *qset;    // for queue set
+  struct STaosQset   *qset;    // for queue set
   void               *ahandle; // for queue set
   pthread_mutex_t     mutex;  
 } STaosQueue;
 
-typedef struct _taos_qset {
+typedef struct STaosQset {
   STaosQueue        *head;
   STaosQueue        *current;
   pthread_mutex_t    mutex;
@@ -44,7 +44,7 @@ typedef struct _taos_qset {
   tsem_t             sem;
 } STaosQset;
 
-typedef struct _taos_qall {
+typedef struct STaosQall {
   STaosQnode   *current;
   STaosQnode   *start;
   int32_t       itemSize;
@@ -95,6 +95,7 @@ void *taosAllocateQitem(int size) {
 void taosFreeQitem(void *param) {
   if (param == NULL) return;
 
+  uTrace("item:%p is freed", param);
   char *temp = (char *)param;
   temp -= sizeof(STaosQnode);
   free(temp);
@@ -104,6 +105,7 @@ int taosWriteQitem(taos_queue param, int type, void *item) {
   STaosQueue *queue = (STaosQueue *)param;
   STaosQnode *pNode = (STaosQnode *)(((char *)item) - sizeof(STaosQnode));
   pNode->type = type;
+  pNode->next = NULL;
 
   pthread_mutex_lock(&queue->mutex);
 
@@ -143,7 +145,7 @@ int taosReadQitem(taos_queue param, int *type, void **pitem) {
       queue->numOfItems--;
       if (queue->qset) atomic_sub_fetch_32(&queue->qset->numOfItems, 1);
       code = 1;
-      uTrace("item:%p is read out from queue, items:%d", *pitem, queue->numOfItems);
+      uTrace("item:%p is read out from queue:%p, type:%d items:%d", *pitem, *type, queue->numOfItems);
   } 
 
   pthread_mutex_unlock(&queue->mutex);
@@ -337,6 +339,7 @@ int taosReadQitemFromQset(taos_qset param, int *type, void **pitem, void **phand
         queue->numOfItems--;
         atomic_sub_fetch_32(&qset->numOfItems, 1);
         code = 1;
+        uTrace("item:%p is read out from queue:%p, type:%d items:%d", *pitem, queue, *type, queue->numOfItems);
     } 
 
     pthread_mutex_unlock(&queue->mutex);

src/vnode/inc/vnodeInt.h

@@ -27,9 +27,9 @@ extern "C" {
 
 extern int32_t vDebugFlag;
 
-#define vError(...) if (vDebugFlag & DEBUG_ERROR) {taosPrintLog("ERROR VND ", 255, __VA_ARGS__); }
+#define vError(...) { if (vDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR VND ", 255, __VA_ARGS__); }}
-#define vWarn(...) if (vDebugFlag & DEBUG_WARN) {taosPrintLog("WARN  VND ", vDebugFlag, __VA_ARGS__); }
+#define vWarn(...)  { if (vDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN VND ", vDebugFlag, __VA_ARGS__); }}
-#define vTrace(...) if (vDebugFlag & DEBUG_TRACE) {taosPrintLog("VND ", vDebugFlag, __VA_ARGS__); }
+#define vTrace(...) { if (vDebugFlag & DEBUG_TRACE) { taosPrintLog("VND ", vDebugFlag, __VA_ARGS__); }}
 #define vPrint(...) { taosPrintLog("VND ", 255, __VA_ARGS__); }
 
 typedef struct {