Merge pull request #2067 from taosdata/hotfix/mgmt

Hotfix/mgmt

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/TSDBJNIConnector.c

@@ -23,7 +23,7 @@
 #include "ttime.h"
 
 #define jniError(...)  { if (jniDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR JNI ", jniDebugFlag, __VA_ARGS__); }}
-#define jniWarn(...)   { if (jniDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  JNI ", jniDebugFlag, __VA_ARGS__); }}
+#define jniWarn(...)   { if (jniDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN JNI ", jniDebugFlag, __VA_ARGS__); }}
 #define jniTrace(...)  { if (jniDebugFlag & DEBUG_TRACE) { taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); }}
 #define jniPrint(...)  { taosPrintLog("JNI ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }
 

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]);
   }

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);

src/client/src/tscSystem.c

@@ -116,7 +116,7 @@ void taos_init_imp() {
   }
 
   if (tscSetMgmtIpListFromCfg(tsFirst, tsSecond) < 0) {
-    tscError("failed to init mgmt IP list");
+    tscError("failed to init mnode IP list");
     return;
   } 
 

src/common/inc/tglobal.h

@@ -100,7 +100,7 @@ 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/inc/tulog.h

@@ -26,7 +26,7 @@ extern int32_t uDebugFlag;
 extern int32_t tscEmbedded;
 
 #define uError(...)       { if (uDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR UTL ", uDebugFlag, __VA_ARGS__); }}
-#define uWarn(...)        { if (uDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  UTL ", uDebugFlag, __VA_ARGS__); }}
+#define uWarn(...)        { if (uDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN UTL ", uDebugFlag, __VA_ARGS__); }}
 #define uTrace(...)       { if (uDebugFlag & DEBUG_TRACE) { taosPrintLog("UTL ", uDebugFlag, __VA_ARGS__); }}
 #define uDump(x, y)       { if (uDebugFlag & DEBUG_DUMP)  { taosDumpData(x, y); }}
 #define uPrint(...)       { taosPrintLog("UTL ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }

src/common/src/tglobal.c

@@ -117,7 +117,7 @@ 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
@@ -427,7 +427,7 @@ static void doInitGlobalConfig() {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
 
-  // 0-any; 1-mgmt; 2-dnode
+  // 0-any; 1-mnode; 2-dnode
   cfg.option = "alternativeRole";
   cfg.ptr = &tsAlternativeRole;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
@@ -875,8 +875,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/dnode/inc/dnodeInt.h

@@ -25,7 +25,7 @@ extern "C" {
 extern int32_t dDebugFlag;
 
 #define dError(...) { if (dDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR DND ", 255, __VA_ARGS__); }}
-#define dWarn(...)  { if (dDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  DND ", dDebugFlag, __VA_ARGS__); }}
+#define dWarn(...)  { if (dDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN DND ", dDebugFlag, __VA_ARGS__); }}
 #define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); }}
 #define dPrint(...) { taosPrintLog("DND ", 255, __VA_ARGS__); }
 

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/dnodeMain.h

@@ -21,7 +21,7 @@ extern "C" {
 #endif
 
 int32_t dnodeInitSystem();
-void dnodeCleanUpSystem();
+void    dnodeCleanUpSystem();
 
 #ifdef __cplusplus
 }

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]);
+void dnodeGetMnodeIpSetForShell(void *ipSetRaw) {
-    ipSet->port[i] += TSDB_PORT_DNODEDNODE;
+  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();
@@ -345,10 +370,10 @@ static void dnodeUpdateMnodeInfos(SDMMnodeInfos *pMnodes) {
 
 static bool dnodeReadMnodeInfos() {
   char ipFile[TSDB_FILENAME_LEN] = {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 +384,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 +426,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 +455,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 +464,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 +486,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,7 +533,7 @@ static void dnodeSendStatusMsg(void *handle, void *tmrId) {
     .msgType = TSDB_MSG_TYPE_DM_STATUS
   };
 
-  dnodeSendMsgToDnode(&tsMnodeIpSet, &rpcMsg);
+  dnodeSendMsgToDnode(&tsDMnodeIpSetForPeer, &rpcMsg);
 }
 
 static bool dnodeReadDnodeCfg() {
@@ -590,3 +615,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));
@@ -101,16 +101,14 @@ static void dnodeProcessReqMsgFromDnode(SRpcMsg *pMsg, SRpcIpSet *pIpSet) {
     rpcSendResponse(&rspMsg);
     return;
   }
- 
+
   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 (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);
@@ -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));

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,7 +122,7 @@ 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;
@@ -157,13 +157,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 +223,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,32 @@ typedef enum {
 SDnodeRunStatus dnodeGetRunStatus();
 SDnodeStatisInfo dnodeGetStatisInfo();
 
-void *dnodeAllocateWqueue(void *pVnode);
+bool    dnodeIsFirstDeploy();
-void  dnodeFreeWqueue(void *queue);
+char *  dnodeGetMnodeMasterEp();
-void *dnodeAllocateRqueue(void *pVnode);
+void    dnodeGetMnodeIpSetForPeer(void *ipSet);
-void  dnodeFreeRqueue(void *rqueue);
+void    dnodeGetMnodeIpSetForShell(void *ipSet);
-void  dnodeSendRpcWriteRsp(void *pVnode, void *param, int32_t code);
+void *  dnodeGetMnodeInfos();
+int32_t dnodeGetDnodeId();
 
-bool     dnodeIsFirstDeploy();
+void dnodeAddClientRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg));
-char    *dnodeGetMnodeMasterEp();
+void dnodeSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg);
-void     dnodeGetMnodeDnodeIpSet(void *ipSet);
+void dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp);
-void *   dnodeGetMnodeInfos();
-int32_t  dnodeGetDnodeId();
 
-void     dnodeAddClientRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg));
+void *dnodeAllocateVnodeWqueue(void *pVnode);
-void     dnodeAddServerMsgHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg));
+void  dnodeFreeVnodeWqueue(void *queue);
-void     dnodeSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg);
+void *dnodeAllocateVnodeRqueue(void *pVnode);
-void     dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp);
+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
@@ -373,7 +374,7 @@ typedef enum {
 } ETableType;
 
 typedef enum {
-  TSDB_MOD_MGMT,
+  TSDB_MOD_MNODE,
   TSDB_MOD_HTTP,
   TSDB_MOD_MONITOR,
   TSDB_MOD_MQTT,

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/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/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;
@@ -233,26 +233,6 @@ typedef struct {
   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,21 @@ typedef enum {
   TAOS_DN_STATUS_READY
 } EDnodeStatus;
 
-int32_t mgmtInitDnodes();
+int32_t mnodeInitDnodes();
-void    mgmtCleanupDnodes();
+void    mnodeCleanupDnodes();
 
-char*   mgmtGetDnodeStatusStr(int32_t dnodeStatus);
+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" {
@@ -28,7 +28,7 @@ extern int32_t sdbDebugFlag;
 
 // mnode log function
 #define mError(...) { if (mDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR MND ", 255, __VA_ARGS__); }}
-#define mWarn(...)  { if (mDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  MND ", mDebugFlag, __VA_ARGS__); }}
+#define mWarn(...)  { if (mDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN MND ", mDebugFlag, __VA_ARGS__); }}
 #define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
 #define mPrint(...) { taosPrintLog("MND ", 255, __VA_ARGS__); }
 
@@ -37,7 +37,7 @@ extern int32_t sdbDebugFlag;
 #define mLPrint(...) { monitorSaveLog(0, __VA_ARGS__); mPrint(__VA_ARGS__) }
 
 #define sdbError(...) { if (sdbDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR MND-SDB ", 255, __VA_ARGS__); }}
-#define sdbWarn(...)  { if (sdbDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  MND-SDB ", sdbDebugFlag, __VA_ARGS__); }}
+#define sdbWarn(...)  { if (sdbDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN MND-SDB ", sdbDebugFlag, __VA_ARGS__); }}
 #define sdbTrace(...) { if (sdbDebugFlag & DEBUG_TRACE) { taosPrintLog("MND-SDB ", sdbDebugFlag, __VA_ARGS__);}}
 #define sdbPrint(...) { taosPrintLog("MND-SDB ", 255, __VA_ARGS__); }
 

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,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_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, bool sendMsg);
+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);
+  mnodeDropDbFromAcct(pAcct, pDb);
-  mgmtDropAllChildTables(pDb);
+  mnodeDropAllChildTables(pDb);
-  mgmtDropAllSuperTables(pDb);
+  mnodeDropAllSuperTables(pDb);
-  mgmtDropAllDbVgroups(pDb, false);
+  mnodeDropAllDbVgroups(pDb, false);
-  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,54 @@ 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
-  mgmtDropAllDbVgroups(pMsg->pDb, true);
+  mnodeDropAllDbVgroups(pMsg->pDb, true);
 #else
   SVgObj *pVgroup = pMsg->pDb->pHead;
   if (pVgroup != NULL) {
     mPrint("vgId:%d, will be dropped", pVgroup->vgId);
-    SQueuedMsg *newMsg = mgmtCloneQueuedMsg(pMsg);
+    SMnodeMsg *newMsg = mnodeCloneMsg(pMsg);
     newMsg->ahandle = pVgroup;
     newMsg->expected = pVgroup->numOfVnodes;
-    mgmtDropVgroup(pVgroup, newMsg);
+    mnodeDropVgroup(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 +1024,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 +1038,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,27 @@ 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 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 +73,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 +113,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 +136,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 +151,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 +198,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 +221,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 +239,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,36 +248,34 @@ 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);
-    SMDCfgDnodeMsg *pMdCfgDnode = rpcMallocCont(sizeof(SMDCfgDnodeMsg));
-    strcpy(pMdCfgDnode->ep, pCmCfgDnode->ep);
-    strcpy(pMdCfgDnode->config, pCmCfgDnode->config);
-    SRpcMsg rpcMdCfgDnodeMsg = {
-        .handle = 0,
-        .code = 0,
-        .msgType = TSDB_MSG_TYPE_MD_CONFIG_DNODE,
-        .pCont = pMdCfgDnode,
-        .contLen = sizeof(SMDCfgDnodeMsg)
-    };
-    dnodeSendMsgToDnode(&ipSet, &rpcMdCfgDnodeMsg);
-    rpcRsp.code = TSDB_CODE_SUCCESS;
   }
 
-  if (rpcRsp.code == TSDB_CODE_SUCCESS) {
+  SRpcIpSet ipSet = mnodeGetIpSetFromIp(pCmCfgDnode->ep);
-    mPrint("dnode:%s, is configured by %s", pCmCfgDnode->ep, pMsg->pUser->user);
+  SMDCfgDnodeMsg *pMdCfgDnode = rpcMallocCont(sizeof(SMDCfgDnodeMsg));
-  }
+  strcpy(pMdCfgDnode->ep, pCmCfgDnode->ep);
+  strcpy(pMdCfgDnode->config, pCmCfgDnode->config);
 
-  rpcSendResponse(&rpcRsp);
+  SRpcMsg rpcMdCfgDnodeMsg = {
+    .handle = 0,
+    .code = 0,
+    .msgType = TSDB_MSG_TYPE_MD_CONFIG_DNODE,
+    .pCont = pMdCfgDnode,
+    .contLen = sizeof(SMDCfgDnodeMsg)
+  };
+  dnodeSendMsgToDnode(&ipSet, &rpcMdCfgDnodeMsg);
+
+  mPrint("dnode:%s, is configured by %s", pCmCfgDnode->ep, pMsg->pUser->user);
+
+  return TSDB_CODE_SUCCESS;
 }
 
-static void mgmtProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) {
+static void mnodeProcessCfgDnodeMsgRsp(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 +285,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 +323,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 +359,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 +404,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 +420,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 +435,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));
     }
+
+    return code;
   }
-  rpcSendResponse(&rpcRsp);
 }
 
-
+static int32_t mnodeProcessDropDnodeMsg(SMnodeMsg *pMsg) {
-static void mgmtProcessDropDnodeMsg(SQueuedMsg *pMsg) {
+  SCMDropDnodeMsg *pDrop = pMsg->rpcMsg.pCont;
-  SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0};
-  
-  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));
     }
-  }
 
-  rpcSendResponse(&rpcRsp);
+    return code;
+  }
 }
 
-static int32_t mgmtGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mnodeGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  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;
   }
 
@@ -547,23 +535,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;
@@ -586,7 +574,7 @@ static int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, voi
     
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
     
-    char* status = mgmtGetDnodeStatusStr(pDnode->status);
+    char* status = mnodeGetDnodeStatusStr(pDnode->status);
     STR_TO_VARSTR(pWrite, status);
     cols++;
 
@@ -596,26 +584,26 @@ static int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, voi
 
  
     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 +641,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 +671,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 +686,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 +740,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 +794,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 +826,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 +857,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 +870,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 +886,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";

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();
-  }
-
-  struct stat dirstat;
-  bool fileExist  = (stat(tsMnodeDir, &dirstat) == 0);
-  bool asMaster = (strcmp(tsFirst, tsLocalEp) == 0);
-
-  if (asMaster || fileExist) {
-    if (mgmtStartSystem() != 0) {
-      return -1;
-    }
-  }
-
-  return 0;
 }
 
-void mgmtCleanUpSystem() {
+void mnodeCleanupSystem() {
-  mPrint("starting to clean up mgmt");
+  mPrint("starting to clean up mnode");
   tsMgmtIsRunning = false;
-  mgmtCleanUpShell();
+
-  mgmtCleanupServer();
+  dnodeFreeMnodeWqueue();
+  dnodeFreeMnodeRqueue();
+  dnodeFreeMnodePqueue();
+  mnodeCleanupTimer();
+  mnodeCleanUpShow();
   grantCleanUp();
   balanceCleanUp();
   sdbCleanUp();
-  mgmtCleanupMnodes();
+  mnodeCleanupMnodes();
-  mgmtCleanUpTables();
+  mnodeCleanupTables();
-  mgmtCleanUpVgroups();
+  mnodeCleanupVgroups();
-  mgmtCleanUpDbs();
+  mnodeCleanupDbs();
-  mgmtCleanupDnodes();
+  mnodeCleanupDnodes();
-  mgmtCleanUpUsers();
+  mnodeCleanupUsers();
-  mgmtCleanUpAccts();
+  mnodeCleanupAccts();
-  mPrint("mgmt is cleaned up");
+  mPrint("mnode is cleaned up");
 }
 
-void mgmtStopSystem() {
+void mnodeStopSystem() {
   if (sdbIsMaster()) {
-    mTrace("it is a master mgmt node, it could not be stopped");
+    mTrace("it is a master mnode, it could not be stopped");
     return;
   }
-
+  
-  mgmtCleanUpSystem();
+  mnodeCleanupSystem();
-
+  mPrint("mnode file is removed");
-  mPrint("mgmt file is removed");
   remove(tsMnodeDir);
 }
+
+static void mnodeInitTimer() {
+  if (tsMnodeTmr == NULL) {
+    tsMnodeTmr = taosTmrInit((tsMaxShellConns)*3, 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) {
+    return true;
+  }
+
+  return false;
+}
+
+bool mnodeIsRunning() {
+  return tsMgmtIsRunning;
+}

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 void *        tsMnodeSdb = NULL;
-static int32_t tsMnodeUpdateSize = 0;
+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;
+  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;
+  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;
+  // SCMKillQueryMsg *pKill = pMsg->pCont;
-  int32_t code;
+  // int32_t code;
 
-  if (!pUser->writeAuth) {
+  // if (!pUser->writeAuth) {
-    code = TSDB_CODE_NO_RIGHTS;
+  //   code = TSDB_CODE_NO_RIGHTS;
-  } else {
+  // } else {
-    code = mgmtKillQuery(pKill->queryId, pMsg->thandle);
+  //   code = mgmtKillQuery(pKill->queryId, pMsg->thandle);
-  }
+  // }
 
-  rpcRsp.code = code;
+  // rpcRsp.code = code;
-  rpcSendResponse(&rpcRsp);
+  // rpcSendResponse(&rpcRsp);
-  mgmtDecUserRef(pUser);
+  // mnodeDecUserRef(pUser);
+  return TSDB_CODE_SUCCESS;
 }
 
-void mgmtProcessKillStreamMsg(SQueuedMsg *pMsg) {
+int32_t mnodeProcessKillStreamMsg(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;
-  }
+  // }
 
-  SCMKillStreamMsg *pKill = pMsg->pCont;
+  // SCMKillStreamMsg *pKill = pMsg->pCont;
-  int32_t code;
+  // int32_t code;
 
-  if (!pUser->writeAuth) {
+  // if (!pUser->writeAuth) {
-    code = TSDB_CODE_NO_RIGHTS;
+  //   code = TSDB_CODE_NO_RIGHTS;
-  } else {
+  // } else {
-    code = mgmtKillStream(pKill->queryId, pMsg->thandle);
+  //   code = mgmtKillStream(pKill->queryId, pMsg->thandle);
-  }
+  // }
 
-  rpcRsp.code = code;
+  // rpcRsp.code = code;
-  rpcSendResponse(&rpcRsp);
+  // rpcSendResponse(&rpcRsp);
-  mgmtDecUserRef(pUser);
+  // mnodeDecUserRef(pUser);
+  return TSDB_CODE_SUCCESS;
 }
 
-void mgmtProcessKillConnectionMsg(SQueuedMsg *pMsg) {
+int32_t mnodeProcessKillConnectionMsg(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;
-  }
+  // }
 
-  SCMKillConnMsg *pKill = pMsg->pCont;
+  // SCMKillConnMsg *pKill = pMsg->pCont;
-  int32_t code;
+  // int32_t code;
 
-  if (!pUser->writeAuth) {
+  // if (!pUser->writeAuth) {
-    code = TSDB_CODE_NO_RIGHTS;
+  //   code = TSDB_CODE_NO_RIGHTS;
-  } else {
+  // } else {
-    code = mgmtKillConnection(pKill->queryId, pMsg->thandle);
+  //   code = mgmtKillConnection(pKill->queryId, pMsg->thandle);
-  }
+  // }
 
-  rpcRsp.code = code;
+  // rpcRsp.code = code;
-  rpcSendResponse(&rpcRsp);
+  // rpcSendResponse(&rpcRsp);
-  mgmtDecUserRef(pUser);
+  // mnodeDecUserRef(pUser);
+  return TSDB_CODE_SUCCESS;
 }
 
-int32_t mgmtInitProfile() {
+int32_t mnodeInitProfile() {
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mgmtGetQueryMeta);
+  // mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mnodeGetQueryMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mgmtRetrieveQueries);
+  // mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mnodeRetrieveQueries);
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mgmtGetConnsMeta);
+  // mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mnodeGetConnsMeta);
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mgmtRetrieveConns);
+  // mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mnodeRetrieveConns);
-  mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_STREAMS, mgmtGetStreamMeta);
+
-  mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMS, mgmtRetrieveStreams);
+  // mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mnodeProcessKillQueryMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mgmtProcessKillQueryMsg);
+  // mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mnodeProcessKillStreamMsg);
-  mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mgmtProcessKillStreamMsg);
+  // mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_CONN, mnodeProcessKillConnectionMsg);
-  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;
   }
 

src/mnode/src/mnodeShow.c

@@ -0,0 +1,352 @@
+/*
+ * 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  mnodeCheckShowObj(SShowObj *pShow);
+static bool  mnodeCheckShowFinished(SShowObj *pShow);
+static void *mnodeSaveShowObj(SShowObj *pShow, int32_t size);
+static void  mnodeCleanupShowObj(void *pShow, bool forceRemove);
+
+extern void *tsMnodeTmr;
+static void *tsQhandleCache = NULL;
+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);
+  
+  tsQhandleCache = taosCacheInitWithCb(tsMnodeTmr, 10, mnodeFreeShowObj);
+  return 0;
+}
+
+void mnodeCleanUpShow() {
+  if (tsQhandleCache != NULL) {
+    taosCacheCleanup(tsQhandleCache);
+    tsQhandleCache = 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 size = sizeof(SCMShowRsp) + sizeof(SSchema) * TSDB_MAX_COLUMNS + TSDB_EXTRA_PAYLOAD_SIZE;
+  SCMShowRsp *pShowRsp = rpcMallocCont(size);
+  if (pShowRsp == NULL) {
+    return TSDB_CODE_SERV_OUT_OF_MEMORY;
+  }
+
+  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 = mnodeSaveShowObj(pShow, showObjSize);
+  if (pShow == NULL) {
+    return TSDB_CODE_SERV_OUT_OF_MEMORY;
+  }
+  pShowRsp->qhandle = htobe64((uint64_t) pShow);
+
+  mTrace("show:%p, 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;
+    return TSDB_CODE_SUCCESS;
+  } else {
+    mError("show:%p, type:%s, failed to get meta, reason:%s", pShow, mnodeGetShowType(pShowMsg->type), tstrerror(code));
+    mnodeCleanupShowObj(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("show:%p, 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 (!mnodeCheckShowObj(pShow)) {
+    mError("retrieve:%p, qhandle:%p is invalid", pRetrieve, pShow);
+    return TSDB_CODE_INVALID_QHANDLE;
+  }
+  
+  if (mnodeCheckShowFinished(pShow)) {
+    mTrace("retrieve:%p, qhandle:%p already read finished, numOfReads:%d numOfRows:%d", pRetrieve, pShow, pShow->numOfReads, pShow->numOfRows);
+    pShow->numOfReads = pShow->numOfRows;
+    //mnodeCleanupShowObj(pShow, true);
+    //return TSDB_CODE_SUCCESS;
+  }
+
+  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);
+    mnodeCleanupShowObj(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) {
+    mnodeCleanupShowObj(pShow, true);
+  } else {
+    mnodeCleanupShowObj(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 mnodeCheckShowObj(SShowObj *pShow) {
+  SShowObj *pSaved = taosCacheAcquireByData(tsQhandleCache, pShow);
+  if (pSaved == pShow) {
+    return true;
+  } else {
+    mTrace("show:%p, is already released", pShow);
+    return false;
+  }
+}
+
+static void *mnodeSaveShowObj(SShowObj *pShow, int32_t size) {
+  if (tsQhandleCache != NULL) {
+    char key[24];
+    sprintf(key, "show:%p", pShow);
+    SShowObj *newQhandle = taosCachePut(tsQhandleCache, key, pShow, size, 60);
+    free(pShow);
+
+    mTrace("show:%p, is saved", newQhandle);
+    return newQhandle;
+  }
+
+  return NULL;
+}
+
+static void mnodeFreeShowObj(void *data) {
+  SShowObj *pShow = data;
+  sdbFreeIter(pShow->pIter);
+  mTrace("show:%p, is destroyed", pShow);
+}
+
+static void mnodeCleanupShowObj(void *pShow, bool forceRemove) {
+  mTrace("show:%p, is released, force:%s", pShow, forceRemove ? "true" : "false");
+  taosCacheRelease(tsQhandleCache, &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,
@@ -644,14 +643,12 @@ static void mgmtProcessCreateVnodeRsp(SRpcMsg *rpcMsg) {
     if (code != 0) {
       code = TSDB_CODE_SDB_ERROR;
     }
-    
-    mgmtSendSimpleResp(queueMsg->thandle, rpcMsg->code);
-  }
 
-  mgmtFreeQueuedMsg(queueMsg);
+    dnodeSendRpcMnodeWriteRsp(mnodeMsg, code);
+  }
 }
 
-static SMDDropVnodeMsg *mgmtBuildDropVnodeMsg(int32_t vgId) {
+static SMDDropVnodeMsg *mnodeBuildDropVnodeMsg(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_NOT_ACTIVE_VNODE;
-    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_NOT_ACTIVE_VNODE;
-    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, bool sendMsg) {
   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) {
@@ -813,11 +804,11 @@ void mgmtDropAllDbVgroups(SDbObj *pDropDb, bool sendMsg) {
       numOfVgroups++;
 
       if (sendMsg) {
-        mgmtSendDropVgroupMsg(pVgroup, NULL);
+        mnodeSendDropVgroupMsg(pVgroup, NULL);
       }
     }
 
-    mgmtDecVgroupRef(pVgroup);
+    mnodeDecVgroupRef(pVgroup);
   }
 
   sdbFreeIter(pIter);

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/inc/httpLog.h

@@ -21,7 +21,7 @@
 extern int32_t httpDebugFlag;
 
 #define httpError(...) { if (httpDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR HTP ", 255, __VA_ARGS__); }}
-#define httpWarn(...)  { if (httpDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  HTP ", httpDebugFlag, __VA_ARGS__); }}
+#define httpWarn(...)  { if (httpDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN HTP ", httpDebugFlag, __VA_ARGS__); }}
 #define httpTrace(...) { if (httpDebugFlag & DEBUG_TRACE) { taosPrintLog("HTP ", httpDebugFlag, __VA_ARGS__); }}
 #define httpDump(...)  { if (httpDebugFlag & DEBUG_TRACE) { taosPrintLongString("HTP ", httpDebugFlag, __VA_ARGS__); }}
 #define httpPrint(...) { taosPrintLog("HTP ", 255, __VA_ARGS__); }

src/plugins/monitor/src/monitorMain.c

@@ -28,7 +28,7 @@
 #include "monitor.h"
 
 #define monitorError(...) { if (monitorDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR MON ", 255, __VA_ARGS__); }}
-#define monitorWarn(...)  { if (monitorDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  MON ", monitorDebugFlag, __VA_ARGS__); }}
+#define monitorWarn(...)  { if (monitorDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN MON ", monitorDebugFlag, __VA_ARGS__); }}
 #define monitorTrace(...) { if (monitorDebugFlag & DEBUG_TRACE) { taosPrintLog("MON ", monitorDebugFlag, __VA_ARGS__); }}
 #define monitorPrint(...) { taosPrintLog("MON ", 255, __VA_ARGS__); }
 

src/plugins/mqtt/inc/mqttLog.h

@@ -26,7 +26,7 @@ extern int32_t mqttDebugFlag;
   }
 #define mqttWarn(...)                                  \
   if ( mqttDebugFlag & DEBUG_WARN) {                    \
-    taosPrintLog("WARN  MQT ",  mqttDebugFlag, __VA_ARGS__); \
+    taosPrintLog("WARN MQT ",  mqttDebugFlag, __VA_ARGS__); \
   }
 #define  mqttTrace(...)                           \
   if ( mqttDebugFlag & DEBUG_TRACE) {             \

src/rpc/inc/rpcLog.h

@@ -25,7 +25,7 @@ extern "C" {
 extern int32_t rpcDebugFlag;
 
 #define tError(...) { if (rpcDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR RPC ", rpcDebugFlag, __VA_ARGS__); }}
-#define tWarn(...)  { if (rpcDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN  RPC ", rpcDebugFlag, __VA_ARGS__); }}
+#define tWarn(...)  { if (rpcDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN RPC ", rpcDebugFlag, __VA_ARGS__); }}
 #define tTrace(...) { if (rpcDebugFlag & DEBUG_TRACE) { taosPrintLog("RPC ", rpcDebugFlag, __VA_ARGS__); }}
 #define tDump(x, y) { if (rpcDebugFlag & DEBUG_DUMP)  { taosDumpData((unsigned char *)x, y); }}
 #define tPrint(...) { taosPrintLog("RPC ", 255, __VA_ARGS__); }

src/util/src/ttimer.c

@@ -27,7 +27,7 @@
 
 #define tmrWarn(...)                                  \
   do { if (tmrDebugFlag & DEBUG_WARN) {               \
-    taosPrintLog("WARN  TMR ", tmrDebugFlag, __VA_ARGS__); \
+    taosPrintLog("WARN TMR ", tmrDebugFlag, __VA_ARGS__); \
   } } while(0)
 
 #define tmrTrace(...)                           \

src/vnode/inc/vnodeInt.h

@@ -27,10 +27,10 @@ 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__); }
+#define vPrint(...) { taosPrintLog("VND ", 255, __VA_ARGS__); }
 
 typedef struct {
   int32_t      vgId;      // global vnode group ID

src/vnode/inc/vnodeLog.h

@@ -24,20 +24,10 @@ extern "C" {
 
 extern int32_t dDebugFlag;
 
-#define dError(...)                          \
+#define dError(...) { if (dDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR DND ", 255, __VA_ARGS__); }}
-  if (dDebugFlag & DEBUG_ERROR) {            \
+#define dWarn(...)  { if (dDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN DND ", dDebugFlag, __VA_ARGS__); }}
-    taosPrintLog("ERROR DND ", 255, __VA_ARGS__); \
+#define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); }}
-  }
+#define dPrint(...) { taosPrintLog("DND ", 255, __VA_ARGS__); }
-#define dWarn(...)                                  \
-  if (dDebugFlag & DEBUG_WARN) {                    \
-    taosPrintLog("WARN  DND ", dDebugFlag, __VA_ARGS__); \
-  }
-#define dTrace(...)                           \
-  if (dDebugFlag & DEBUG_TRACE) {             \
-    taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); \
-  }
-#define dPrint(...) \
-  { taosPrintLog("DND ", 255, __VA_ARGS__); }
 
 #ifdef __cplusplus
 }

src/vnode/src/vnodeMain.c

@@ -198,8 +198,8 @@ int32_t vnodeOpen(int32_t vnode, char *rootDir) {
 
   pVnode->fversion = pVnode->version;
   
-  pVnode->wqueue = dnodeAllocateWqueue(pVnode);
+  pVnode->wqueue = dnodeAllocateVnodeWqueue(pVnode);
-  pVnode->rqueue = dnodeAllocateRqueue(pVnode);
+  pVnode->rqueue = dnodeAllocateVnodeRqueue(pVnode);
   if (pVnode->wqueue == NULL || pVnode->rqueue == NULL) {
     vnodeCleanUp(pVnode);
     return terrno;
@@ -245,7 +245,7 @@ int32_t vnodeOpen(int32_t vnode, char *rootDir) {
   syncInfo.getWalInfo = vnodeGetWalInfo;
   syncInfo.getFileInfo = vnodeGetFileInfo;
   syncInfo.writeToCache = vnodeWriteToQueue;
-  syncInfo.confirmForward = dnodeSendRpcWriteRsp; 
+  syncInfo.confirmForward = dnodeSendRpcVnodeWriteRsp; 
   syncInfo.notifyRole = vnodeNotifyRole;
   syncInfo.notifyFileSynced = vnodeNotifyFileSynced;
   pVnode->sync = syncStart(&syncInfo);
@@ -404,11 +404,11 @@ static void vnodeCleanUp(SVnodeObj *pVnode) {
   pVnode->cq = NULL;
 
   if (pVnode->wqueue) 
-    dnodeFreeWqueue(pVnode->wqueue);
+    dnodeFreeVnodeWqueue(pVnode->wqueue);
   pVnode->wqueue = NULL;
 
   if (pVnode->rqueue) 
-    dnodeFreeRqueue(pVnode->rqueue);
+    dnodeFreeVnodeRqueue(pVnode->rqueue);
   pVnode->rqueue = NULL;
  
   vnodeRelease(pVnode);

src/vnode/src/vnodeWrite.c

@@ -106,8 +106,7 @@ static int32_t vnodeProcessSubmitMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pR
 static int32_t vnodeProcessCreateTableMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pRet) {
   SMDCreateTableMsg *pTable = pCont;
   int32_t code = 0;
-  char sql[1024] = "\0";
+  
-
   vTrace("vgId:%d, table:%s, start to create", pVnode->vgId, pTable->tableId);
   int16_t   numOfColumns = htons(pTable->numOfColumns);
   int16_t   numOfTags = htons(pTable->numOfTags);
@@ -152,8 +151,10 @@ static int32_t vnodeProcessCreateTableMsg(SVnodeObj *pVnode, void *pCont, SRspRe
     tsdbTableSetTagValue(&tCfg, dataRow, false);
   }
 
+  // only normal has sql string
   if (pTable->tableType == TSDB_STREAM_TABLE) {
-    // TODO: set sql value
+    char *sql = pTable->data + totalCols * sizeof(SSchema);
+    vTrace("vgId:%d, table:%s is creating, sql:%s", pVnode->vgId, pTable->tableId, sql);
     tsdbTableSetStreamSql(&tCfg, sql, false);
   }
 

tests/pytest/util/dnodes.py

@@ -159,7 +159,7 @@ class TDDnode:
         self.cfg("dataDir", self.dataDir)
         self.cfg("logDir", self.logDir)
         self.cfg("numOfLogLines", "100000000")
-        self.cfg("mgmtEqualVnodeNum", "0")
+        self.cfg("mnodeEqualVnodeNum", "0")
         self.cfg("clog", "1")
         self.cfg("statusInterval", "1")
         self.cfg("numOfTotalVnodes", "64")

tests/script/general/alter/count.sim

@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 
 system sh/cfg.sh -n dnode1 -c wallevel -v 0
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
 
 print ========= start dnode1 as master
 system sh/exec.sh -n dnode1 -s start

tests/script/general/alter/import.sim

@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 
 system sh/cfg.sh -n dnode1 -c wallevel -v 0
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
 
 print ========= start dnode1 as master
 system sh/exec.sh -n dnode1 -s start

tests/script/general/db/backup/keep.sim

@@ -12,9 +12,9 @@ system sh/cfg.sh -n dnode3 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4
 
 print ========= start dnode1 as master
 system sh/exec.sh -n dnode1 -s start

tests/script/general/db/delete_reuse1.sim

@@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4
 
 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4
 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4

tests/script/general/db/delete_reuse2.sim

@@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4
 
 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4
 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4

tests/script/general/db/delete_writing1.sim

@@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4
 
 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4
 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4

tests/script/general/import/basic.sim

@@ -9,10 +9,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 10
 
 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000
 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000

tests/script/general/import/commit.sim

@@ -9,10 +9,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 10
 
 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000
 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000

tests/script/general/import/large.sim

@@ -9,10 +9,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 10
 
 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000
 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000

tests/script/general/import/replica1.sim

@@ -10,10 +10,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 10
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 10
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 10
 
 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000
 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000

tests/script/general/table/delete_reuse1.sim

@@ -14,10 +14,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4
 
 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4
 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4

tests/script/general/table/delete_reuse2.sim

@@ -14,10 +14,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4
 
 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4
 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4

tests/script/general/table/delete_writing.sim

@@ -14,10 +14,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4
 
 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4
 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4

tests/script/sh/clear.sh

@@ -106,7 +106,7 @@ echo "monitor             0"              >> $TAOS_CFG
 echo "numOfThreadsPerCore 2.0"            >> $TAOS_CFG
 echo "defaultPass         taosdata"       >> $TAOS_CFG
 echo "numOfLogLines       100000000"      >> $TAOS_CFG
-echo "mgmtEqualVnodeNum   0"              >> $TAOS_CFG
+echo "mnodeEqualVnodeNum   0"              >> $TAOS_CFG
 echo "clog                0"              >> $TAOS_CFG
 echo "statusInterval      1"              >> $TAOS_CFG
 echo "numOfTotalVnodes    4"              >> $TAOS_CFG

tests/script/sh/deploy.sh

@@ -96,7 +96,6 @@ echo "second              ${HOSTNAME}:7200" >> $TAOS_CFG
 echo "serverPort          ${NODE}"          >> $TAOS_CFG
 echo "dataDir             $DATA_DIR"      >> $TAOS_CFG
 echo "logDir              $LOG_DIR"       >> $TAOS_CFG
-echo "debugFlag           135"            >> $TAOS_CFG
 echo "dDebugFlag          135"            >> $TAOS_CFG
 echo "mDebugFlag          135"            >> $TAOS_CFG
 echo "sdbDebugFlag        135"            >> $TAOS_CFG
@@ -105,8 +104,8 @@ echo "tmrDebugFlag        131"            >> $TAOS_CFG
 echo "cDebugFlag          135"            >> $TAOS_CFG
 echo "httpDebugFlag       135"            >> $TAOS_CFG
 echo "monitorDebugFlag    131"            >> $TAOS_CFG
-echo "udebugFlag          131"            >> $TAOS_CFG
+echo "udebugFlag          135"            >> $TAOS_CFG
-echo "jnidebugFlag        131"            >> $TAOS_CFG
+echo "jnidebugFlag        135"            >> $TAOS_CFG
 echo "sdebugFlag          135"            >> $TAOS_CFG
 echo "qdebugFlag          135"            >> $TAOS_CFG
 echo "monitor             0"              >> $TAOS_CFG
@@ -115,7 +114,7 @@ echo "http                0"              >> $TAOS_CFG
 echo "numOfThreadsPerCore 2.0"            >> $TAOS_CFG
 echo "defaultPass         taosdata"       >> $TAOS_CFG
 echo "numOfLogLines       100000000"      >> $TAOS_CFG
-echo "mgmtEqualVnodeNum   0"              >> $TAOS_CFG
+echo "mnodeEqualVnodeNum   0"              >> $TAOS_CFG
 echo "clog                2"              >> $TAOS_CFG
 echo "statusInterval      1"              >> $TAOS_CFG
 echo "numOfTotalVnodes    4"              >> $TAOS_CFG

tests/script/tmp/prepare.sim

@@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1
 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4
 
 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4
 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4

tests/script/unique/arbitrator/dn3_mn1_replica2_wal1_AddDelDnode.sim

@@ -29,10 +29,10 @@ system sh/cfg.sh -n dnode3 -c numOfTotalVnodes -v 4
 system sh/cfg.sh -n dnode4 -c numOfTotalVnodes -v 4
 system sh/cfg.sh -n dnode5 -c numOfTotalVnodes -v 4
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 200
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 200
-#system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 200
+#system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 200
-#system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 200
+#system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 200
-#system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 200
+#system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 200
 
 system sh/cfg.sh -n dnode1 -c arbitrator -v $arbitrator
 system sh/cfg.sh -n dnode2 -c arbitrator -v $arbitrator

tests/script/unique/cluster/balance1.sim

@@ -26,14 +26,14 @@ system sh/cfg.sh -n dnode6 -c numOfMpeers -v 3
 system sh/cfg.sh -n dnode7 -c numOfMpeers -v 3
 system sh/cfg.sh -n dnode8 -c numOfMpeers -v 3
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode5 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode5 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode6 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode6 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode7 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode7 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode8 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode8 -c mnodeEqualVnodeNum -v 0
 
 system sh/cfg.sh -n dnode1 -c wallevel -v 1
 system sh/cfg.sh -n dnode2 -c wallevel -v 1

tests/script/unique/cluster/balance2.sim

@@ -35,14 +35,14 @@ system sh/cfg.sh -n dnode6 -c wallevel -v 1
 system sh/cfg.sh -n dnode7 -c wallevel -v 1
 system sh/cfg.sh -n dnode8 -c wallevel -v 1
 
-system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode5 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode5 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode6 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode6 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode7 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode7 -c mnodeEqualVnodeNum -v 0
-system sh/cfg.sh -n dnode8 -c mgmtEqualVnodeNum -v 0
+system sh/cfg.sh -n dnode8 -c mnodeEqualVnodeNum -v 0
 
 print ============== step1
 print ========= start dnode1