merge

Jenkinsfile

 import hudson.model.Result
+import hudson.model.*;
 import jenkins.model.CauseOfInterruption
-properties([pipelineTriggers([githubPush()])])
 node {
-    git url: 'https://github.com/taosdata/TDengine.git'
 }
 
 def skipbuild=0
+def win_stop=0
 
 def abortPreviousBuilds() {
   def currentJobName = env.JOB_NAME
@@ -121,6 +121,7 @@ def pre_test(){
 
 pipeline {
   agent none
+  options { skipDefaultCheckout() } 
   environment{
       WK = '/var/lib/jenkins/workspace/TDinternal'
       WKC= '/var/lib/jenkins/workspace/TDinternal/community'
@@ -128,6 +129,7 @@ pipeline {
   stages {
       stage('pre_build'){
           agent{label 'master'}
+          options { skipDefaultCheckout() } 
           when {
               changeRequest()
           }
@@ -181,6 +183,7 @@ pipeline {
       }
       stage('Parallel test stage') {
         //only build pr
+        options { skipDefaultCheckout() } 
         when {
           allOf{
               changeRequest()

include/common/taosmsg.h

@@ -363,6 +363,8 @@ typedef struct {
 } SConnectRsp;
 
 typedef struct {
+  char    user[TSDB_USER_LEN];
+  char    pass[TSDB_KEY_LEN];
   int32_t maxUsers;
   int32_t maxDbs;
   int32_t maxTimeSeries;
@@ -374,12 +376,6 @@ typedef struct {
   int64_t maxInbound;
   int64_t maxOutbound;
   int8_t  accessState;  // Configured only by command
-} SAcctCfg;
-
-typedef struct {
-  char     user[TSDB_USER_LEN];
-  char     pass[TSDB_KEY_LEN];
-  SAcctCfg cfg;
 } SCreateAcctMsg, SAlterAcctMsg;
 
 typedef struct {

include/common/tglobal.h

@@ -151,8 +151,6 @@ extern int8_t  tsPrintAuth;
 extern int8_t  tscEmbedded;
 extern char    tsVnodeDir[];
 extern char    tsMnodeDir[];
-extern char    tsMnodeBakDir[];
-extern char    tsMnodeTmpDir[];
 extern int64_t tsTickPerDay[3];
 extern int32_t tsTopicBianryLen;
 

include/libs/raft/raft.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <cli@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TD_RAFT_H
-#define TD_RAFT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdio.h>
-#include "taosdef.h"
-
-typedef unsigned int RaftId;
-typedef unsigned int RaftGroupId;
-
-// buffer holding data
-typedef struct RaftBuffer {
-  void* data;
-  size_t len;
-} RaftBuffer;
-
-// a single server information in a cluster
-typedef struct RaftServer {
-  RaftId    id;
-  char      fqdn[TSDB_FQDN_LEN];
-  uint16_t  port;
-} RaftServer;
-
-// all servers in a cluster
-typedef struct RaftConfiguration {
-  RaftServer *servers;
-  int nServer;
-} RaftConfiguration;
-
-// raft lib module
-struct Raft;
-typedef struct Raft Raft;
-
-struct RaftNode;
-typedef struct RaftNode RaftNode;
-
-// raft state machine
-struct RaftFSM;
-typedef struct RaftFSM {
-  // statemachine user data
-  void *data;
-
-  // apply buffer data, bufs will be free by raft module
-  int (*apply)(struct RaftFSM *fsm, const RaftBuffer *bufs[], int nBufs);
-
-  // configuration commit callback 
-  int (*onConfigurationCommit)(const RaftConfiguration* cluster);
-
-  // fsm return snapshot in ppBuf, bufs will be free by raft module
-  // TODO: getSnapshot SHOULD be async?
-  int (*getSnapshot)(struct RaftFSM *fsm, RaftBuffer **ppBuf);
-
-  // fsm restore with pBuf data
-  int (*restore)(struct RaftFSM *fsm, RaftBuffer *pBuf);
-
-  // fsm send data in buf to server,buf will be free by raft module
-  int (*send)(struct RaftFSM* fsm, const RaftServer* server, const RaftBuffer *buf);
-} RaftFSM;
-
-typedef struct RaftNodeOptions {
-  // user define state machine
-  RaftFSM* pFSM;
-
-  // election timeout(in ms)
-  // by default: 1000
-  int electionTimeoutMS;
-
-  // heart timeout(in ms)
-  // by default: 100
-  int heartbeatTimeoutMS;
-
-  // install snapshot timeout(in ms)
-  int installSnapshotTimeoutMS;
-
-  /** 
-   * number of log entries before starting a new snapshot. 
-   * by default: 1024
-   */
-  int snapshotThreshold;
-
-  /**
-   * Number of log entries to keep in the log after a snapshot has
-   * been taken. 
-   * by default: 128.
-   */
-  int snapshotTrailing;
-
-  /**
-   * Enable or disable pre-vote support.
-   * by default: false
-   */
-  bool preVote;
-
-} RaftNodeOptions;
-
-// create raft lib
-int RaftCreate(Raft** ppRaft);
-
-int RaftDestroy(Raft* pRaft);
-
-// start a raft node with options,node id,group id
-int RaftStart(Raft* pRaft, 
-              RaftId selfId,
-              RaftGroupId selfGroupId,
-              const RaftConfiguration* cluster,
-              const RaftNodeOptions* options,              
-              RaftNode **ppNode);
-
-// stop a raft node
-int RaftStop(RaftNode* pNode);
-
-// client apply a cmd in buf
-typedef void (*RaftApplyFp)(const RaftBuffer *pBuf, int result);
-
-int RaftApply(RaftNode *pNode,
-              const RaftBuffer *pBuf,
-              RaftApplyFp applyCb);
-
-// recv data from other servers in cluster,buf will be free in raft
-int RaftRecv(RaftNode *pNode, const RaftBuffer* pBuf);
-
-// change cluster servers API
-typedef void (*RaftChangeFp)(const RaftServer* pServer, int result);
-
-int RaftAddServer(RaftNode *pNode,
-                  const RaftServer* pServer,
-                  RaftChangeFp changeCb);
-
-int RaftRemoveServer(RaftNode *pNode, 
-                    const RaftServer* pServer,
-                    RaftChangeFp changeCb);
-
-// transfer leader to id
-typedef void (*RaftTransferFp)(RaftId id, int result);
-int RaftTransfer(RaftNode *pNode,
-                 RaftId id,
-                 RaftTransferFp transferCb);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  /* TD_RAFT_H */ 
\ No newline at end of file

include/libs/sync/sync.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <cli@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_RAFT_SYNC_H
+#define TDENGINE_RAFT_SYNC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include "taosdef.h"
+#include "wal.h"
+
+typedef uint32_t SyncNodeId;
+typedef int32_t SyncGroupId;
+typedef int64_t   SyncIndex;
+typedef uint64_t SSyncTerm;
+
+typedef enum {
+  TAOS_SYNC_ROLE_FOLLOWER  = 0,
+  TAOS_SYNC_ROLE_CANDIDATE = 1,
+  TAOS_SYNC_ROLE_LEADER  = 2,
+} ESyncRole;
+
+typedef struct {
+  void* data;
+  size_t len;
+} SSyncBuffer;
+
+typedef struct {
+  SyncNodeId  nodeId;    // node ID assigned by TDengine
+  uint16_t  nodePort;  // node sync Port
+  char      nodeFqdn[TSDB_FQDN_LEN]; // node FQDN  
+} SNodeInfo;
+
+typedef struct {
+  int selfIndex;
+  int nNode;
+  SNodeInfo*  nodeInfo;
+} SSyncCluster;
+
+typedef struct {
+  int32_t  selfIndex;
+  int nNode;
+  SyncNodeId* nodeId;
+  ESyncRole*  role;
+} SNodesRole;
+
+struct SSyncFSM;
+typedef struct SSyncFSM {
+  void* pData;
+
+  // apply committed log, bufs will be free by raft module
+  int (*applyLog)(struct SSyncFSM *fsm, SyncIndex index, const SSyncBuffer *buf, void *pData);
+
+  // cluster commit callback 
+  int (*onClusterChanged)(struct SSyncFSM *fsm, const SSyncCluster* cluster, void *pData);
+
+  // fsm return snapshot in ppBuf, bufs will be free by raft module
+  // TODO: getSnapshot SHOULD be async?
+  int (*getSnapshot)(struct SSyncFSM *fsm, SSyncBuffer **ppBuf, int* objId, bool *isLast);
+
+  // fsm apply snapshot with pBuf data
+  int (*applySnapshot)(struct SSyncFSM *fsm, SSyncBuffer *pBuf, int objId, bool isLast);
+
+  // call when restore snapshot and log done
+  int (*onRestoreDone)(struct SSyncFSM *fsm);
+
+  void (*onRollback)(struct SSyncFSM *fsm, SyncIndex index, const SSyncBuffer *buf);
+
+  void (*onRoleChanged)(struct SSyncFSM *fsm, const SNodesRole* pRole);
+
+} SSyncFSM;
+
+typedef struct SSyncServerState {
+  SyncNodeId voteFor;
+  SSyncTerm term;  
+} SSyncServerState;
+
+typedef struct SStateManager {
+  void* pData;
+
+  void (*saveServerState)(struct SStateManager* stateMng, const SSyncServerState* state);
+
+  const SSyncServerState* (*readServerState)(struct SStateManager* stateMng);
+
+  void (*saveCluster)(struct SStateManager* stateMng, const SSyncCluster* cluster);
+
+  const SSyncCluster* (*readCluster)(struct SStateManager* stateMng);
+} SStateManager;
+
+typedef struct {
+  SyncGroupId  vgId;
+
+  twalh walHandle;
+
+  SyncIndex snapshotIndex;    // initial version
+  SSyncCluster syncCfg;    // configuration from mgmt
+
+  SSyncFSM fsm;
+
+  SStateManager stateManager;
+} SSyncInfo;
+
+int32_t syncInit();
+void    syncCleanUp();
+
+SyncNodeId syncStart(const SSyncInfo *);
+void    syncStop(SyncNodeId);
+
+int32_t syncPropose(SyncNodeId nodeId, SSyncBuffer buffer, void *pData, bool isWeak);
+
+extern int32_t  raftDebugFlag;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_RAFT_SYNC_H

include/os/osDef.h

@@ -178,6 +178,12 @@ extern "C" {
   #define setThreadName(name)
 #endif
 
+#if defined(_WIN32)
+#define TD_DIRSEP	"\\"
+#else
+#define TD_DIRSEP	"/"
+#endif
+
 #ifdef __cplusplus
 }
 #endif

include/server/mnode/mnode.h

@@ -20,6 +20,8 @@
 extern "C" {
 #endif
 
+typedef enum { MN_STATUS_UNINIT = 0, MN_STATUS_INIT = 1, MN_STATUS_READY = 2, MN_STATUS_CLOSING = 3 } EMnStatus;
+
 typedef struct {
   /**
    * Send messages to other dnodes, such as create vnode message.
@@ -54,13 +56,12 @@ typedef struct {
    * @param port, the port of dnode.
    */
   void (*GetDnodeEp)(int32_t dnodeId, char *ep, char *fqdn, uint16_t *port);
-
 } SMnodeFp;
 
 typedef struct {
-  SMnodeFp      fp;
-  char          clusterId[TSDB_CLUSTER_ID_LEN];
-  int32_t       dnodeId;
+  SMnodeFp fp;
+  char     clusterId[TSDB_CLUSTER_ID_LEN];
+  int32_t  dnodeId;
 } SMnodePara;
 
 /**
@@ -79,10 +80,9 @@ void mnodeCleanup();
 /**
  * Deploy mnode instances in dnode.
  *
- * @param minfos, server information used to deploy the mnode instance.
  * @return Error Code.
  */
-int32_t mnodeDeploy(struct SMInfos *minfos);
+int32_t mnodeDeploy();
 
 /**
  * Delete the mnode instance deployed in dnode.
@@ -94,7 +94,7 @@ void mnodeUnDeploy();
  *
  * @return Server status.
  */
-bool mnodeIsServing();
+EMnStatus mnodeGetStatus();
 
 typedef struct {
   int64_t numOfDnode;

include/util/taoserror.h

@@ -166,6 +166,9 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_NO_USER_FROM_CONN         TAOS_DEF_ERROR_CODE(0, 0x0354)  //"Can not get user from conn")
 #define TSDB_CODE_MND_TOO_MANY_USERS            TAOS_DEF_ERROR_CODE(0, 0x0355)  //"Too many users")
 
+#define TSDB_CODE_MND_MNODE_ALREADY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x0348)  //"Mnode already exists")
+#define TSDB_CODE_MND_MNODE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x0349)  //"Mnode not there")
+
 #define TSDB_CODE_MND_TABLE_ALREADY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x0360)  //"Table already exists")
 #define TSDB_CODE_MND_INVALID_TABLE_ID          TAOS_DEF_ERROR_CODE(0, 0x0361)  //"Table name too long")
 #define TSDB_CODE_MND_INVALID_TABLE_NAME        TAOS_DEF_ERROR_CODE(0, 0x0362)  //"Table does not exist")

include/util/tdef.h

@@ -68,6 +68,7 @@ extern const int32_t TYPE_BYTES[15];
 #define TSDB_DATA_NULL_STR              "NULL"
 #define TSDB_DATA_NULL_STR_L            "null"
 
+#define TSDB_NETTEST_USER               "nettestinternal"
 #define TSDB_DEFAULT_USER               "root"
 #ifdef _TD_POWER_
 #define TSDB_DEFAULT_PASS               "powerdb"

include/util/tstep.h

@@ -20,14 +20,15 @@
 extern "C" {
 #endif
 
+typedef struct SSteps SSteps;
 typedef int32_t (*InitFp)();
 typedef void (*CleanupFp)();
 typedef void (*ReportFp)(char *name, char *desc);
 
-struct SSteps *taosStepInit(int32_t maxsize, ReportFp fp);
-int32_t        taosStepExec(struct SSteps *steps);
-void           taosStepCleanup(struct SSteps *steps);
-int32_t        taosStepAdd(struct SSteps *steps, char *name, InitFp initFp, CleanupFp cleanupFp);
+SSteps *taosStepInit(int32_t maxsize, ReportFp fp);
+int32_t taosStepExec(SSteps *steps);
+void    taosStepCleanup(SSteps *steps);
+int32_t taosStepAdd(SSteps *steps, char *name, InitFp initFp, CleanupFp cleanupFp);
 
 #ifdef __cplusplus
 }

include/util/tworker.h

@@ -16,6 +16,8 @@
 #ifndef _TD_UTIL_WORKER_H
 #define _TD_UTIL_WORKER_H
 
+#include "tqueue.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif

source/common/src/tglobal.c

@@ -201,8 +201,6 @@ int8_t tscEmbedded = 0;
 char   tsVnodeDir[PATH_MAX] = {0};
 char   tsDnodeDir[PATH_MAX] = {0};
 char   tsMnodeDir[PATH_MAX] = {0};
-char   tsMnodeTmpDir[PATH_MAX] = {0};
-char   tsMnodeBakDir[PATH_MAX] = {0};
 
 int32_t  tsDiskCfgNum = 0;
 int32_t tsTopicBianryLen = 16000;

source/libs/CMakeLists.txt

 add_subdirectory(transport)
-add_subdirectory(raft)
+add_subdirectory(sync)
 add_subdirectory(tkv)
 add_subdirectory(index)
 add_subdirectory(wal)

source/libs/raft/CMakeLists.txt

-aux_source_directory(src RAFT_SRC)
-add_library(raft ${RAFT_SRC})
-target_include_directories(
-    raft
-    PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/raft"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-)
\ No newline at end of file

source/libs/sync/CMakeLists.txt

+aux_source_directory(src SYNC_SRC)
+add_library(sync ${SYNC_SRC})
+
+target_link_libraries(
+    sync
+    PUBLIC common
+    PUBLIC util
+    PUBLIC wal
+)
+
+target_include_directories(
+    sync
+    PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/sync"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
\ No newline at end of file

source/libs/raft/src/raft.c → source/libs/sync/src/sync.c

@@ -11,4 +11,6 @@
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
+ */
\ No newline at end of file
+
+#include "sync.h"
\ No newline at end of file

source/server/dnode/inc/dnodeInt.h

@@ -19,7 +19,9 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+#include "os.h"
 #include "taosmsg.h"
+#include "tglobal.h"
 #include "tlog.h"
 #include "trpc.h"
 #include "dnode.h"

source/server/dnode/inc/dnodeMain.h

@@ -22,10 +22,10 @@ extern "C" {
 #include "dnodeInt.h"
 
 typedef enum {
-  TD_RUN_STAT_INIT,
-  TD_RUN_STAT_RUNNING,
-  TD_RUN_STAT_STOPPED
-} RunStat;
+  DN_RUN_STAT_INIT,
+  DN_RUN_STAT_RUNNING,
+  DN_RUN_STAT_STOPPED
+} EDnRunStat;
 
 int32_t dnodeInitMain();
 void    dnodeCleanupMain();
@@ -36,7 +36,7 @@ void    dnodeReportStartupFinished(char *name, char *desc);
 void    dnodeProcessStartupReq(SRpcMsg *pMsg);
 void    dnodeProcessCreateMnodeReq(SRpcMsg *pMsg);
 void    dnodeProcessConfigDnodeReq(SRpcMsg *pMsg);
-RunStat dnodeGetRunStat();
+EDnRunStat dnodeGetRunStat();
 void    dnodeSetRunStat();
 void*   dnodeGetTimer();
 

source/server/dnode/inc/dnodeTrans.h

@@ -25,7 +25,6 @@ int32_t dnodeInitTrans();
 void    dnodeCleanupTrans();
 void    dnodeSendMsgToMnode(SRpcMsg *rpcMsg);
 void    dnodeSendMsgToDnode(SRpcEpSet *epSet, SRpcMsg *rpcMsg);
-void    dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp, SRpcEpSet *epSet);
 
 #ifdef __cplusplus
 }

source/server/dnode/src/dnodeCheck.c

@@ -14,8 +14,6 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "os.h"
-#include "tglobal.h"
 #include "dnodeCheck.h"
 
 #define MIN_AVAIL_MEMORY_MB 32

source/server/dnode/src/dnodeInt.c

@@ -28,7 +28,6 @@
 #include "dnodeMain.h"
 #include "dnodeMnodeEps.h"
 #include "dnodeStatus.h"
-#include "dnodeTelem.h"
 #include "dnodeTrans.h"
 #include "mnode.h"
 #include "vnode.h"
@@ -73,12 +72,11 @@ int32_t dnodeInit() {
   taosStepAdd(tsSteps, "dnode-mnode", dnodeInitMnodeModule, mnodeCleanup);
   taosStepAdd(tsSteps, "dnode-trans", dnodeInitTrans, dnodeCleanupTrans);
   taosStepAdd(tsSteps, "dnode-status", dnodeInitStatus, dnodeCleanupStatus);
-  taosStepAdd(tsSteps, "dnode-telem", dnodeInitTelem, dnodeCleanupTelem);
   //taosStepAdd(tsSteps, "dnode-script",scriptEnvPoolInit, scriptEnvPoolCleanup);
 
   taosStepExec(tsSteps);
 
-  dnodeSetRunStat(TD_RUN_STAT_RUNNING);
+  dnodeSetRunStat(DN_RUN_STAT_RUNNING);
   dnodeReportStartupFinished("TDengine", "initialized successfully");
   dInfo("TDengine is initialized successfully");
 
@@ -86,8 +84,8 @@ int32_t dnodeInit() {
 }
 
 void dnodeCleanup() {
-  if (dnodeGetRunStat() != TD_RUN_STAT_STOPPED) {
-    dnodeSetRunStat(TD_RUN_STAT_STOPPED);
+  if (dnodeGetRunStat() != DN_RUN_STAT_STOPPED) {
+    dnodeSetRunStat(DN_RUN_STAT_STOPPED);
     taosStepCleanup(tsSteps);
     tsSteps = NULL;
   }

source/server/dnode/src/dnodeMain.c

@@ -29,7 +29,7 @@
 #include "mnode.h"
 
 static struct {
-  RunStat      runStatus;
+  EDnRunStat      runStatus;
   void *       dnodeTimer;
   SStartupStep startup;
 } tsDmain;
@@ -55,7 +55,7 @@ static void dnodeCheckDataDirOpenned(char *dir) {
 }
 
 int32_t dnodeInitMain() {
-  tsDmain.runStatus = TD_RUN_STAT_STOPPED;
+  tsDmain.runStatus = DN_RUN_STAT_STOPPED;
   tsDmain.dnodeTimer = taosTmrInit(100, 200, 60000, "DND-TMR");
   if (tsDmain.dnodeTimer == NULL) {
     dError("failed to init dnode timer");
@@ -235,9 +235,9 @@ static int32_t dnodeStartMnode(SRpcMsg *pMsg) {
     dDebug("meps index:%d, meps:%d:%s", i, pCfg->mnodes.mnodeInfos[i].mnodeId, pCfg->mnodes.mnodeInfos[i].mnodeEp);
   }
 
-  if (mnodeIsServing()) return 0;
+  if (mnodeGetStatus() == MN_STATUS_READY) return 0;
 
-  return mnodeDeploy(&pCfg->mnodes);
+  return mnodeDeploy();
 }
 
 void dnodeProcessCreateMnodeReq(SRpcMsg *pMsg) {
@@ -260,8 +260,8 @@ void dnodeProcessConfigDnodeReq(SRpcMsg *pMsg) {
   rpcFreeCont(pMsg->pCont);
 }
 
-RunStat dnodeGetRunStat() { return tsDmain.runStatus; }
+EDnRunStat dnodeGetRunStat() { return tsDmain.runStatus; }
 
-void dnodeSetRunStat(RunStat stat) { tsDmain.runStatus = stat; }
+void dnodeSetRunStat(EDnRunStat stat) { tsDmain.runStatus = stat; }
 
 void* dnodeGetTimer() { return tsDmain.dnodeTimer; }
\ No newline at end of file

source/server/dnode/src/dnodeTrans.c

@@ -20,21 +20,20 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "os.h"
-#include "tglobal.h"
+#include "dnodeTrans.h"
 #include "dnodeMain.h"
 #include "dnodeMnodeEps.h"
 #include "dnodeStatus.h"
-#include "dnodeTrans.h"
+#include "mnode.h"
 #include "vnode.h"
 #include "mnode.h"
 
-typedef void (*RpcMsgFp)( SRpcMsg *pMsg);
+typedef void (*RpcMsgFp)(SRpcMsg *pMsg);
 
 static struct {
-  void *   serverRpc;
-  void *   clientRpc;
-  void *   shellRpc;
+  void    *serverRpc;
+  void    *clientRpc;
+  void    *shellRpc;
   int32_t  queryReqNum;
   int32_t  submitReqNum;
   RpcMsgFp peerMsgFp[TSDB_MSG_TYPE_MAX];
@@ -43,18 +42,18 @@ static struct {
 
 static void dnodeProcessPeerReq(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
   SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0};
+  int32_t msgType = pMsg->msgType;
 
-  if (pMsg->pCont == NULL) return;
-  if (pMsg->msgType == TSDB_MSG_TYPE_NETWORK_TEST) {
+  if (msgType == TSDB_MSG_TYPE_NETWORK_TEST) {
     dnodeProcessStartupReq(pMsg);
     return;
   }
 
-  if (dnodeGetRunStat() != TD_RUN_STAT_RUNNING) {
+  if (dnodeGetRunStat() != DN_RUN_STAT_RUNNING) {
     rspMsg.code = TSDB_CODE_APP_NOT_READY;
     rpcSendResponse(&rspMsg);
     rpcFreeCont(pMsg->pCont);
-    dTrace("RPC %p, msg:%s is ignored since dnode not running", pMsg->handle, taosMsg[pMsg->msgType]);
+    dTrace("RPC %p, peer req:%s is ignored since dnode not running", pMsg->handle, taosMsg[msgType]);
     return;
   }
 
@@ -64,38 +63,40 @@ static void dnodeProcessPeerReq(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
     return;
   }
 
-  RpcMsgFp fp = tsTrans.peerMsgFp[pMsg->msgType];
+  RpcMsgFp fp = tsTrans.peerMsgFp[msgType];
   if (fp != NULL) {
+    dTrace("RPC %p, peer req:%s will be processed", pMsg->handle, taosMsg[msgType]);
     (*fp)(pMsg);
   } else {
-    dDebug("RPC %p, peer req:%s not processed", pMsg->handle, taosMsg[pMsg->msgType]);
+    dError("RPC %p, peer req:%s not processed", pMsg->handle, taosMsg[msgType]);
     rspMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED;
     rpcSendResponse(&rspMsg);
     rpcFreeCont(pMsg->pCont);
   }
 }
 
-int32_t dnodeInitServer() {
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE]  = vnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_TABLE]    = vnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE]   = vnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_STABLE]   = vnodeProcessMsg;
+static int32_t dnodeInitServer() {
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_TABLE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_STABLE] = vnodeProcessMsg;
 
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE]  = vnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE]   = vnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_SYNC_VNODE]    = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_SYNC_VNODE] = vnodeProcessMsg;
   tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_COMPACT_VNODE] = vnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_VNODE]    = vnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM]  = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_VNODE] = vnodeProcessMsg;
 
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE]  = dnodeProcessConfigDnodeReq;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_MNODE]  = dnodeProcessCreateMnodeReq;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM] = vnodeProcessMsg;
 
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE]  = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE]  = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_AUTH]          = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_GRANT]         = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_STATUS]        = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE] = dnodeProcessConfigDnodeReq;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_MNODE] = dnodeProcessCreateMnodeReq;
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_AUTH] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_GRANT] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_STATUS] = mnodeProcessMsg;
 
   tsTrans.peerMsgFp[TSDB_MSG_TYPE_MQ_CONNECT]       = vnodeProcessMsg;
   /*tsTrans.peerMsgFp[TSDB_MSG_TYPE_MQ_CONSUME]       = vnodeProcessRead;*/
@@ -120,7 +121,7 @@ int32_t dnodeInitServer() {
   return 0;
 }
 
-void dnodeCleanupServer() {
+static void dnodeCleanupServer() {
   if (tsTrans.serverRpc) {
     rpcClose(tsTrans.serverRpc);
     tsTrans.serverRpc = NULL;
@@ -128,66 +129,65 @@ void dnodeCleanupServer() {
   }
 }
 
-static void dnodeProcessRspFromPeer(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
-  if (dnodeGetRunStat() == TD_RUN_STAT_STOPPED) {
+static void dnodeProcessPeerRsp(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
+  int32_t msgType = pMsg->msgType;
+
+  if (dnodeGetRunStat() == DN_RUN_STAT_STOPPED) {
     if (pMsg == NULL || pMsg->pCont == NULL) return;
-    dTrace("msg:%p is ignored since dnode is stopping", pMsg);
+    dTrace("RPC %p, peer rsp:%s is ignored since dnode is stopping", pMsg->handle, taosMsg[msgType]);
     rpcFreeCont(pMsg->pCont);
     return;
   }
 
-  if (pMsg->msgType == TSDB_MSG_TYPE_DM_STATUS_RSP && pEpSet) {
+  if (msgType == TSDB_MSG_TYPE_DM_STATUS_RSP && pEpSet) {
     dnodeUpdateMnodeFromPeer(pEpSet);
   }
 
-  RpcMsgFp fp = tsTrans.peerMsgFp[pMsg->msgType];
+  RpcMsgFp fp = tsTrans.peerMsgFp[msgType];
   if (fp != NULL) {
     (*fp)(pMsg);
   } else {
-    dDebug("RPC %p, peer rsp:%s not processed", pMsg->handle, taosMsg[pMsg->msgType]);
-    SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0};
-    rspMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED;
-    rpcSendResponse(&rspMsg);
-    rpcFreeCont(pMsg->pCont);
+    dDebug("RPC %p, peer rsp:%s not processed", pMsg->handle, taosMsg[msgType]);
   }
 
   rpcFreeCont(pMsg->pCont);
 }
 
-int32_t dnodeInitClient() {
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP]  = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_TABLE_RSP]    = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP]   = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_STABLE_RSP]   = mnodeProcessMsg;
+static int32_t dnodeInitClient() {
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_TABLE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_STABLE_RSP] = mnodeProcessMsg;
 
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP]  = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE_RSP]   = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_SYNC_VNODE_RSP]    = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_SYNC_VNODE_RSP] = mnodeProcessMsg;
   tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_COMPACT_VNODE_RSP] = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_VNODE_RSP]    = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM_RSP]  = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_VNODE_RSP] = mnodeProcessMsg;
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM_RSP] = mnodeProcessMsg;
 
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP]  = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_MNODE_RSP]  = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_MNODE_RSP] = mnodeProcessMsg;
 
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE_RSP]  = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE_RSP]  = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_AUTH_RSP]          = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_GRANT_RSP]         = mnodeProcessMsg;
-  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_STATUS_RSP]        = dnodeProcessStatusRsp;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_AUTH_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_GRANT_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_STATUS_RSP] = dnodeProcessStatusRsp;
 
-  char secret[TSDB_KEY_LEN] = "secret";
+  char     secret[TSDB_KEY_LEN] = "secret";
   SRpcInit rpcInit;
   memset(&rpcInit, 0, sizeof(rpcInit));
-  rpcInit.label        = "DND-C";
+  rpcInit.label = "DND-C";
   rpcInit.numOfThreads = 1;
-  rpcInit.cfp          = dnodeProcessRspFromPeer;
-  rpcInit.sessions     = TSDB_MAX_VNODES << 4;
-  rpcInit.connType     = TAOS_CONN_CLIENT;
-  rpcInit.idleTime     = tsShellActivityTimer * 1000;
-  rpcInit.user         = "t";
-  rpcInit.ckey         = "key";
-  rpcInit.secret       = secret;
+  rpcInit.cfp = dnodeProcessPeerRsp;
+  rpcInit.sessions = TSDB_MAX_VNODES << 4;
+  rpcInit.connType = TAOS_CONN_CLIENT;
+  rpcInit.idleTime = tsShellActivityTimer * 1000;
+  rpcInit.user = "t";
+  rpcInit.ckey = "key";
+  rpcInit.secret = secret;
 
   tsTrans.clientRpc = rpcOpen(&rpcInit);
   if (tsTrans.clientRpc == NULL) {
@@ -199,7 +199,7 @@ int32_t dnodeInitClient() {
   return 0;
 }
 
-void dnodeCleanupClient() {
+static void dnodeCleanupClient() {
   if (tsTrans.clientRpc) {
     rpcClose(tsTrans.clientRpc);
     tsTrans.clientRpc = NULL;
@@ -207,59 +207,50 @@ void dnodeCleanupClient() {
   }
 }
 
-static void dnodeProcessMsgFromShell(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
-  SRpcMsg rpcMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0};
+static void dnodeProcessShellReq(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
+  SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0};
+  int32_t msgType = pMsg->msgType;
 
-  if (pMsg->pCont == NULL) return;
-  if (dnodeGetRunStat() == TD_RUN_STAT_STOPPED) {
-    dError("RPC %p, shell msg:%s is ignored since dnode exiting", pMsg->handle, taosMsg[pMsg->msgType]);
-    rpcMsg.code = TSDB_CODE_DND_EXITING;
-    rpcSendResponse(&rpcMsg);
+  if (dnodeGetRunStat() == DN_RUN_STAT_STOPPED) {
+    dError("RPC %p, shell req:%s is ignored since dnode exiting", pMsg->handle, taosMsg[msgType]);
+    rspMsg.code = TSDB_CODE_DND_EXITING;
+    rpcSendResponse(&rspMsg);
     rpcFreeCont(pMsg->pCont);
     return;
-  } else if (dnodeGetRunStat() != TD_RUN_STAT_RUNNING) {
-    dError("RPC %p, shell msg:%s is ignored since dnode not running", pMsg->handle, taosMsg[pMsg->msgType]);
-    rpcMsg.code = TSDB_CODE_APP_NOT_READY;
-    rpcSendResponse(&rpcMsg);
+  } else if (dnodeGetRunStat() != DN_RUN_STAT_RUNNING) {
+    dError("RPC %p, shell req:%s is ignored since dnode not running", pMsg->handle, taosMsg[msgType]);
+    rspMsg.code = TSDB_CODE_APP_NOT_READY;
+    rpcSendResponse(&rspMsg);
     rpcFreeCont(pMsg->pCont);
     return;
   }
 
-  if (pMsg->msgType == TSDB_MSG_TYPE_QUERY) {
+  if (pMsg->pCont == NULL) {
+    rspMsg.code = TSDB_CODE_DND_INVALID_MSG_LEN;
+    rpcSendResponse(&rspMsg);
+    return;
+  }
+
+  if (msgType == TSDB_MSG_TYPE_QUERY) {
     atomic_fetch_add_32(&tsTrans.queryReqNum, 1);
-  } else if (pMsg->msgType == TSDB_MSG_TYPE_SUBMIT) {
+  } else if (msgType == TSDB_MSG_TYPE_SUBMIT) {
     atomic_fetch_add_32(&tsTrans.submitReqNum, 1);
-  } else {}
+  } else {
+  }
 
-  RpcMsgFp fp = tsTrans.shellMsgFp[pMsg->msgType];
+  RpcMsgFp fp = tsTrans.shellMsgFp[msgType];
   if (fp != NULL) {
+    dTrace("RPC %p, shell req:%s will be processed", pMsg->handle, taosMsg[msgType]);
     (*fp)(pMsg);
   } else {
-    dError("RPC %p, shell req:%s is not processed", pMsg->handle, taosMsg[pMsg->msgType]);
-    rpcMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED;
-    rpcSendResponse(&rpcMsg);
+    dError("RPC %p, shell req:%s is not processed", pMsg->handle, taosMsg[msgType]);
+    rspMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED;
+    rpcSendResponse(&rspMsg);
     rpcFreeCont(pMsg->pCont);
   }
 }
 
-static int32_t dnodeAuthNetTest(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
-  if (strcmp(user, "nettestinternal") == 0) {
-    char pass[32] = {0};
-    taosEncryptPass((uint8_t *)user, strlen(user), pass);
-    *spi = 0;
-    *encrypt = 0;
-    *ckey = 0;
-    memcpy(secret, pass, TSDB_KEY_LEN);
-    dTrace("nettest user is authorized");
-    return 0;
-  }
-
-  return -1;
-}
-
-void dnodeSendMsgToDnode(SRpcEpSet *epSet, SRpcMsg *rpcMsg) {
-  rpcSendRequest(tsTrans.clientRpc, epSet, rpcMsg, NULL);
-}
+void dnodeSendMsgToDnode(SRpcEpSet *epSet, SRpcMsg *rpcMsg) { rpcSendRequest(tsTrans.clientRpc, epSet, rpcMsg, NULL); }
 
 void dnodeSendMsgToMnode(SRpcMsg *rpcMsg) {
   SRpcEpSet epSet = {0};
@@ -267,19 +258,13 @@ void dnodeSendMsgToMnode(SRpcMsg *rpcMsg) {
   dnodeSendMsgToDnode(&epSet, rpcMsg);
 }
 
-void dnodeSendMsgToMnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp) {
+static void dnodeSendMsgToMnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp) {
   SRpcEpSet epSet = {0};
   dnodeGetEpSetForPeer(&epSet);
   rpcSendRecv(tsTrans.clientRpc, &epSet, rpcMsg, rpcRsp);
 }
 
-void dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp, SRpcEpSet *epSet) {
-  rpcSendRecv(tsTrans.clientRpc, epSet, rpcMsg, rpcRsp);
-}
-
 static int32_t dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
-  if (dnodeAuthNetTest(user, spi, encrypt, secret, ckey) == 0) return 0;
-
   int32_t code = mnodeRetriveAuth(user, spi, encrypt, secret, ckey);
   if (code != TSDB_CODE_APP_NOT_READY) return code;
 
@@ -310,54 +295,54 @@ static int32_t dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, c
   return rpcRsp.code;
 }
 
-int32_t dnodeInitShell() {
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_SUBMIT]         = vnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_QUERY]          = vnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_FETCH]          = vnodeProcessMsg;
+static int32_t dnodeInitShell() {
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_SUBMIT] = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_QUERY] = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_FETCH] = vnodeProcessMsg;
   tsTrans.shellMsgFp[TSDB_MSG_TYPE_UPDATE_TAG_VAL] = vnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_QUERY]       = vnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_CONSUME]     = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_QUERY] = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_CONSUME] = vnodeProcessMsg;
 
   // the following message shall be treated as mnode write
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT]     = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT]      = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_ACCT]       = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_USER]     = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_USER]      = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_USER]       = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE]    = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE]      = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB]       = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TP]       = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_ACCT] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_USER] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_USER] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TP] = mnodeProcessMsg;
   tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_FUNCTION] = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB]         = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_SYNC_DB]         = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_TP]         = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_FUNCTION]   = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB]        = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TP]        = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE]    = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE]      = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE]     = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM]    = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY]      = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM]     = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN]       = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE]    = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_COMPACT_VNODE]   = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_SYNC_DB] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_TP] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_FUNCTION] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TP] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_COMPACT_VNODE] = mnodeProcessMsg;
 
   // the following message shall be treated as mnode query
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT]     = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CONNECT]       = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_USE_DB]        = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_TABLE_META]    = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CONNECT] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_USE_DB] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_TABLE_META] = mnodeProcessMsg;
   tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_STABLE_VGROUP] = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META]   = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_SHOW]          = mnodeProcessMsg;
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE]      = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_SHOW] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = mnodeProcessMsg;
   tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE_FUNC] = mnodeProcessMsg;
 
-  tsTrans.shellMsgFp[TSDB_MSG_TYPE_NETWORK_TEST]     = dnodeProcessStartupReq;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_NETWORK_TEST] = dnodeProcessStartupReq;
 
   int32_t numOfThreads = (int32_t)((tsNumOfCores * tsNumOfThreadsPerCore) / 2.0);
   if (numOfThreads < 1) {
@@ -366,14 +351,14 @@ int32_t dnodeInitShell() {
 
   SRpcInit rpcInit;
   memset(&rpcInit, 0, sizeof(rpcInit));
-  rpcInit.localPort    = tsDnodeShellPort;
-  rpcInit.label        = "SHELL";
+  rpcInit.localPort = tsDnodeShellPort;
+  rpcInit.label = "SHELL";
   rpcInit.numOfThreads = numOfThreads;
-  rpcInit.cfp          = dnodeProcessMsgFromShell;
-  rpcInit.sessions     = tsMaxShellConns;
-  rpcInit.connType     = TAOS_CONN_SERVER;
-  rpcInit.idleTime     = tsShellActivityTimer * 1000;
-  rpcInit.afp          = dnodeRetrieveUserAuthInfo;
+  rpcInit.cfp = dnodeProcessShellReq;
+  rpcInit.sessions = tsMaxShellConns;
+  rpcInit.connType = TAOS_CONN_SERVER;
+  rpcInit.idleTime = tsShellActivityTimer * 1000;
+  rpcInit.afp = dnodeRetrieveUserAuthInfo;
 
   tsTrans.shellRpc = rpcOpen(&rpcInit);
   if (tsTrans.shellRpc == NULL) {
@@ -385,7 +370,7 @@ int32_t dnodeInitShell() {
   return 0;
 }
 
-void dnodeCleanupShell() {
+static void dnodeCleanupShell() {
   if (tsTrans.shellRpc) {
     rpcClose(tsTrans.shellRpc);
     tsTrans.shellRpc = NULL;

source/server/dnode/src/dnodeTrans.c.orig

+/*
+ * 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/>.
+ */
+
+/* this file is mainly responsible for the communication between DNODEs. Each 
+ * dnode works as both server and client. Dnode may send status, grant, config
+ * messages to mnode, mnode may send create/alter/drop table/vnode messages 
+ * to dnode. All theses messages are handled from here
+ */
+
+#define _DEFAULT_SOURCE
+#include "dnodeTrans.h"
+#include "dnodeMain.h"
+#include "dnodeMnodeEps.h"
+#include "dnodeStatus.h"
+#include "mnode.h"
+#include "vnode.h"
+
+typedef void (*RpcMsgFp)(SRpcMsg *pMsg);
+
+static struct {
+  void    *serverRpc;
+  void    *clientRpc;
+  void    *shellRpc;
+  int32_t  queryReqNum;
+  int32_t  submitReqNum;
+  RpcMsgFp peerMsgFp[TSDB_MSG_TYPE_MAX];
+  RpcMsgFp shellMsgFp[TSDB_MSG_TYPE_MAX];
+} tsTrans;
+
+static void dnodeProcessPeerReq(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
+  SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0};
+  int32_t msgType = pMsg->msgType;
+
+  if (msgType == TSDB_MSG_TYPE_NETWORK_TEST) {
+    dnodeProcessStartupReq(pMsg);
+    return;
+  }
+
+  if (dnodeGetRunStat() != DN_RUN_STAT_RUNNING) {
+    rspMsg.code = TSDB_CODE_APP_NOT_READY;
+    rpcSendResponse(&rspMsg);
+    rpcFreeCont(pMsg->pCont);
+    dTrace("RPC %p, peer req:%s is ignored since dnode not running", pMsg->handle, taosMsg[msgType]);
+    return;
+  }
+
+  if (pMsg->pCont == NULL) {
+    rspMsg.code = TSDB_CODE_DND_INVALID_MSG_LEN;
+    rpcSendResponse(&rspMsg);
+    return;
+  }
+
+  RpcMsgFp fp = tsTrans.peerMsgFp[msgType];
+  if (fp != NULL) {
+    dTrace("RPC %p, peer req:%s will be processed", pMsg->handle, taosMsg[msgType]);
+    (*fp)(pMsg);
+  } else {
+    dError("RPC %p, peer req:%s not processed", pMsg->handle, taosMsg[msgType]);
+    rspMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED;
+    rpcSendResponse(&rspMsg);
+    rpcFreeCont(pMsg->pCont);
+  }
+}
+
+static int32_t dnodeInitServer() {
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_TABLE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_STABLE] = vnodeProcessMsg;
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_SYNC_VNODE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_COMPACT_VNODE] = vnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_VNODE] = vnodeProcessMsg;
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM] = vnodeProcessMsg;
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE] = dnodeProcessConfigDnodeReq;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_MNODE] = dnodeProcessCreateMnodeReq;
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_AUTH] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_GRANT] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_STATUS] = mnodeProcessMsg;
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MQ_CONNECT]       = vnodeProcessMsg;
+  /*tsTrans.peerMsgFp[TSDB_MSG_TYPE_MQ_CONSUME]       = vnodeProcessRead;*/
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MQ_CONNECT]       = vnodeProcessMsg;
+  /*tsTrans.peerMsgFp[TSDB_MSG_TYPE_MQ_CONSUME]       = vnodeProcessRead;*/
+
+  SRpcInit rpcInit;
+  memset(&rpcInit, 0, sizeof(rpcInit));
+  rpcInit.localPort = tsDnodeDnodePort;
+  rpcInit.label = "DND-S";
+  rpcInit.numOfThreads = 1;
+  rpcInit.cfp = dnodeProcessPeerReq;
+  rpcInit.sessions = TSDB_MAX_VNODES << 4;
+  rpcInit.connType = TAOS_CONN_SERVER;
+  rpcInit.idleTime = tsShellActivityTimer * 1000;
+
+  tsTrans.serverRpc = rpcOpen(&rpcInit);
+  if (tsTrans.serverRpc == NULL) {
+    dError("failed to init peer rpc server");
+    return -1;
+  }
+
+  dInfo("dnode peer rpc server is initialized");
+  return 0;
+}
+
+static void dnodeCleanupServer() {
+  if (tsTrans.serverRpc) {
+    rpcClose(tsTrans.serverRpc);
+    tsTrans.serverRpc = NULL;
+    dInfo("dnode peer server is closed");
+  }
+}
+
+static void dnodeProcessPeerRsp(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
+  int32_t msgType = pMsg->msgType;
+
+  if (dnodeGetRunStat() == DN_RUN_STAT_STOPPED) {
+    if (pMsg == NULL || pMsg->pCont == NULL) return;
+    dTrace("RPC %p, peer rsp:%s is ignored since dnode is stopping", pMsg->handle, taosMsg[msgType]);
+    rpcFreeCont(pMsg->pCont);
+    return;
+  }
+
+  if (msgType == TSDB_MSG_TYPE_DM_STATUS_RSP && pEpSet) {
+    dnodeUpdateMnodeFromPeer(pEpSet);
+  }
+
+  RpcMsgFp fp = tsTrans.peerMsgFp[msgType];
+  if (fp != NULL) {
+    dTrace("RPC %p, peer rsp:%s will be processed", pMsg->handle, taosMsg[msgType]);
+    (*fp)(pMsg);
+  } else {
+    dDebug("RPC %p, peer rsp:%s not processed", pMsg->handle, taosMsg[msgType]);
+  }
+
+  rpcFreeCont(pMsg->pCont);
+}
+
+static int32_t dnodeInitClient() {
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_TABLE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_STABLE_RSP] = mnodeProcessMsg;
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_SYNC_VNODE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_COMPACT_VNODE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_VNODE_RSP] = mnodeProcessMsg;
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM_RSP] = mnodeProcessMsg;
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_MNODE_RSP] = mnodeProcessMsg;
+
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_AUTH_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_GRANT_RSP] = mnodeProcessMsg;
+  tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_STATUS_RSP] = dnodeProcessStatusRsp;
+
+  char     secret[TSDB_KEY_LEN] = "secret";
+  SRpcInit rpcInit;
+  memset(&rpcInit, 0, sizeof(rpcInit));
+  rpcInit.label = "DND-C";
+  rpcInit.numOfThreads = 1;
+  rpcInit.cfp = dnodeProcessPeerRsp;
+  rpcInit.sessions = TSDB_MAX_VNODES << 4;
+  rpcInit.connType = TAOS_CONN_CLIENT;
+  rpcInit.idleTime = tsShellActivityTimer * 1000;
+  rpcInit.user = "t";
+  rpcInit.ckey = "key";
+  rpcInit.secret = secret;
+
+  tsTrans.clientRpc = rpcOpen(&rpcInit);
+  if (tsTrans.clientRpc == NULL) {
+    dError("failed to init peer rpc client");
+    return -1;
+  }
+
+  dInfo("dnode peer rpc client is initialized");
+  return 0;
+}
+
+static void dnodeCleanupClient() {
+  if (tsTrans.clientRpc) {
+    rpcClose(tsTrans.clientRpc);
+    tsTrans.clientRpc = NULL;
+    dInfo("dnode peer rpc client is closed");
+  }
+}
+
+static void dnodeProcessShellReq(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
+  SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0};
+  int32_t msgType = pMsg->msgType;
+
+  if (dnodeGetRunStat() == DN_RUN_STAT_STOPPED) {
+    dError("RPC %p, shell req:%s is ignored since dnode exiting", pMsg->handle, taosMsg[msgType]);
+    rspMsg.code = TSDB_CODE_DND_EXITING;
+    rpcSendResponse(&rspMsg);
+    rpcFreeCont(pMsg->pCont);
+    return;
+  } else if (dnodeGetRunStat() != DN_RUN_STAT_RUNNING) {
+    dError("RPC %p, shell req:%s is ignored since dnode not running", pMsg->handle, taosMsg[msgType]);
+    rspMsg.code = TSDB_CODE_APP_NOT_READY;
+    rpcSendResponse(&rspMsg);
+    rpcFreeCont(pMsg->pCont);
+    return;
+  }
+
+  if (pMsg->pCont == NULL) {
+    rspMsg.code = TSDB_CODE_DND_INVALID_MSG_LEN;
+    rpcSendResponse(&rspMsg);
+    return;
+  }
+
+  if (msgType == TSDB_MSG_TYPE_QUERY) {
+    atomic_fetch_add_32(&tsTrans.queryReqNum, 1);
+  } else if (msgType == TSDB_MSG_TYPE_SUBMIT) {
+    atomic_fetch_add_32(&tsTrans.submitReqNum, 1);
+  } else {
+  }
+
+  RpcMsgFp fp = tsTrans.shellMsgFp[msgType];
+  if (fp != NULL) {
+    dTrace("RPC %p, shell req:%s will be processed", pMsg->handle, taosMsg[msgType]);
+    (*fp)(pMsg);
+  } else {
+    dError("RPC %p, shell req:%s is not processed", pMsg->handle, taosMsg[msgType]);
+    rspMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED;
+    rpcSendResponse(&rspMsg);
+    rpcFreeCont(pMsg->pCont);
+  }
+}
+
+void dnodeSendMsgToDnode(SRpcEpSet *epSet, SRpcMsg *rpcMsg) { rpcSendRequest(tsTrans.clientRpc, epSet, rpcMsg, NULL); }
+
+void dnodeSendMsgToMnode(SRpcMsg *rpcMsg) {
+  SRpcEpSet epSet = {0};
+  dnodeGetEpSetForPeer(&epSet);
+  dnodeSendMsgToDnode(&epSet, rpcMsg);
+}
+
+static void dnodeSendMsgToMnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp) {
+  SRpcEpSet epSet = {0};
+  dnodeGetEpSetForPeer(&epSet);
+  rpcSendRecv(tsTrans.clientRpc, &epSet, rpcMsg, rpcRsp);
+}
+
+static int32_t dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
+  int32_t code = mnodeRetriveAuth(user, spi, encrypt, secret, ckey);
+  if (code != TSDB_CODE_APP_NOT_READY) return code;
+
+  SAuthMsg *pMsg = rpcMallocCont(sizeof(SAuthMsg));
+  tstrncpy(pMsg->user, user, sizeof(pMsg->user));
+
+  SRpcMsg rpcMsg = {0};
+  rpcMsg.pCont = pMsg;
+  rpcMsg.contLen = sizeof(SAuthMsg);
+  rpcMsg.msgType = TSDB_MSG_TYPE_DM_AUTH;
+
+  dDebug("user:%s, send auth msg to mnodes", user);
+  SRpcMsg rpcRsp = {0};
+  dnodeSendMsgToMnodeRecv(&rpcMsg, &rpcRsp);
+
+  if (rpcRsp.code != 0) {
+    dError("user:%s, auth msg received from mnodes, error:%s", user, tstrerror(rpcRsp.code));
+  } else {
+    SAuthRsp *pRsp = rpcRsp.pCont;
+    dDebug("user:%s, auth msg received from mnodes", user);
+    memcpy(secret, pRsp->secret, TSDB_KEY_LEN);
+    memcpy(ckey, pRsp->ckey, TSDB_KEY_LEN);
+    *spi = pRsp->spi;
+    *encrypt = pRsp->encrypt;
+  }
+
+  rpcFreeCont(rpcRsp.pCont);
+  return rpcRsp.code;
+}
+
+<<<<<<< HEAD
+int32_t dnodeInitShell() {
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_SUBMIT]         = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_QUERY]          = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_FETCH]          = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_UPDATE_TAG_VAL] = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_QUERY]       = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_CONSUME]     = vnodeProcessMsg;
+=======
+static int32_t dnodeInitShell() {
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_SUBMIT] = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_QUERY] = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_FETCH] = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_UPDATE_TAG_VAL] = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_QUERY] = vnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_CONSUME] = vnodeProcessMsg;
+>>>>>>> 3.0
+
+  // the following message shall be treated as mnode write
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_ACCT] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_USER] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_USER] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TP] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_FUNCTION] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_SYNC_DB] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_TP] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_FUNCTION] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TP] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_COMPACT_VNODE] = mnodeProcessMsg;
+
+  // the following message shall be treated as mnode query
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CONNECT] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_USE_DB] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_TABLE_META] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_STABLE_VGROUP] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_SHOW] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = mnodeProcessMsg;
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE_FUNC] = mnodeProcessMsg;
+
+  tsTrans.shellMsgFp[TSDB_MSG_TYPE_NETWORK_TEST] = dnodeProcessStartupReq;
+
+  int32_t numOfThreads = (int32_t)((tsNumOfCores * tsNumOfThreadsPerCore) / 2.0);
+  if (numOfThreads < 1) {
+    numOfThreads = 1;
+  }
+
+  SRpcInit rpcInit;
+  memset(&rpcInit, 0, sizeof(rpcInit));
+  rpcInit.localPort = tsDnodeShellPort;
+  rpcInit.label = "SHELL";
+  rpcInit.numOfThreads = numOfThreads;
+  rpcInit.cfp = dnodeProcessShellReq;
+  rpcInit.sessions = tsMaxShellConns;
+  rpcInit.connType = TAOS_CONN_SERVER;
+  rpcInit.idleTime = tsShellActivityTimer * 1000;
+  rpcInit.afp = dnodeRetrieveUserAuthInfo;
+
+  tsTrans.shellRpc = rpcOpen(&rpcInit);
+  if (tsTrans.shellRpc == NULL) {
+    dError("failed to init shell rpc server");
+    return -1;
+  }
+
+  dInfo("dnode shell rpc server is initialized");
+  return 0;
+}
+
+static void dnodeCleanupShell() {
+  if (tsTrans.shellRpc) {
+    rpcClose(tsTrans.shellRpc);
+    tsTrans.shellRpc = NULL;
+  }
+}
+
+int32_t dnodeInitTrans() {
+  if (dnodeInitClient() != 0) {
+    return -1;
+  }
+
+  if (dnodeInitServer() != 0) {
+    return -1;
+  }
+
+  if (dnodeInitShell() != 0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+void dnodeCleanupTrans() {
+  dnodeCleanupShell();
+  dnodeCleanupServer();
+  dnodeCleanupClient();
+}

source/server/mnode/CMakeLists.txt

@@ -8,4 +8,5 @@ target_include_directories(
 target_link_libraries(
     mnode
     PUBLIC transport
+    PUBLIC cjson
 )
\ No newline at end of file

src/mnode/inc/mnodeRead.h → source/server/mnode/inc/mnodeAcct.h

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

src/mnode/inc/mnodeWrite.h → source/server/mnode/inc/mnodeAuth.h

@@ -13,19 +13,20 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MNODE_WRITE_H
-#define TDENGINE_MNODE_WRITE_H
+#ifndef _TD_MNODE_AUTH_H_
+#define _TD_MNODE_AUTH_H_
+
+#include "mnodeInt.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "mnodeDef.h"
 
-void    mnodeAddWriteMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg));
-int32_t mnodeProcessRead(SMnodeMsg *pMsg);
+int32_t mnodeInitAuth();
+void    mnodeCleanupAuth();
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif
+#endif /*_TD_MNODE_AUTH_H_*/

source/server/mnode/inc/mnodeBalance.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_BALANCE_H_
+#define _TD_MNODE_BALANCE_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitBalance();
+void    mnodeCleanupBalance();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_BALANCE_H_*/

src/mnode/inc/mnodeCluster.h → source/server/mnode/inc/mnodeCluster.h

@@ -13,8 +13,10 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MNODE_CLUSTER_H
-#define TDENGINE_MNODE_CLUSTER_H
+#ifndef _TD_MNODE_CLUSTER_H_
+#define _TD_MNODE_CLUSTER_H_
+
+#include "mnodeInt.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -22,13 +24,9 @@ extern "C" {
 
 int32_t mnodeInitCluster();
 void    mnodeCleanupCluster();
-void    mnodeUpdateClusterId();
-const char* mnodeGetClusterId();
-
-int32_t mnodeCompactCluster();
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif
+#endif /*_TD_MNODE_CLUSTER_H_*/

source/server/mnode/inc/mnodeDb.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_DATABASE_H_
+#define _TD_MNODE_DATABASE_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitDb();
+void    mnodeCleanupDb();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_DATABASE_H_*/

src/mnode/inc/mnodeDef.h → source/server/mnode/inc/mnodeDef.h

@@ -13,149 +13,175 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MNODE_DEF_H
-#define TDENGINE_MNODE_DEF_H
+#ifndef _TD_MNODE_DEF_H_
+#define _TD_MNODE_DEF_H_
+
+#include "os.h"
+#include "taosmsg.h"
+#include "tlog.h"
+#include "trpc.h"
+#include "ttimer.h"
+#include "thash.h"
+#include "cJSON.h"
+#include "mnode.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "taosdef.h"
-#include "taosmsg.h"
+extern int32_t mDebugFlag;
 
-struct SVgObj;
-struct SDbObj;
-struct SAcctObj;
-struct SUserObj;
-struct SMnodeObj;
+// mnode log function
+#define mFatal(...) { if (mDebugFlag & DEBUG_FATAL) { taosPrintLog("MND FATAL ", 255, __VA_ARGS__); }}
+#define mError(...) { if (mDebugFlag & DEBUG_ERROR) { taosPrintLog("MND ERROR ", 255, __VA_ARGS__); }}
+#define mWarn(...)  { if (mDebugFlag & DEBUG_WARN)  { taosPrintLog("MND WARN ", 255, __VA_ARGS__); }}
+#define mInfo(...)  { if (mDebugFlag & DEBUG_INFO)  { taosPrintLog("MND ", 255, __VA_ARGS__); }}
+#define mDebug(...) { if (mDebugFlag & DEBUG_DEBUG) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
+#define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
 
-/*
-struct define notes:
-1. The first field must be the xxxxId field or name field , e.g. 'int32_t dnodeId', 'int32_t mnodeId', 'char name[]', 'char user[]', ...
-2. From the dnodeId field to the updataEnd field, these information will be falled disc;
-3. The fields behind the updataEnd field can be changed;
-*/
+// #define mLError(...) { monSaveLog(2, __VA_ARGS__); mError(__VA_ARGS__) }
+// #define mLWarn(...)  { monSaveLog(1, __VA_ARGS__); mWarn(__VA_ARGS__)  }
+// #define mLInfo(...)  { monSaveLog(0, __VA_ARGS__); mInfo(__VA_ARGS__) }
+
+#define mLError(...) {mError(__VA_ARGS__) }
+#define mLWarn(...)  {mWarn(__VA_ARGS__)  }
+#define mLInfo(...)  {mInfo(__VA_ARGS__) }
+
+typedef struct SClusterObj SClusterObj; 
+typedef struct SDnodeObj SDnodeObj;
+typedef struct SMnodeObj SMnodeObj;
+typedef struct SAcctObj SAcctObj;
+typedef struct SUserObj SUserObj;
+typedef struct SDbObj SDbObj;
+typedef struct SVgObj SVgObj;
+typedef struct SSTableObj SSTableObj;
+typedef struct SFuncObj SFuncObj; 
+typedef struct SOperObj SOperObj;
+typedef struct SMnMsg SMnMsg;
+
+typedef enum {
+  MN_SDB_START = 0,
+  MN_SDB_CLUSTER = 1,
+  MN_SDB_DNODE = 2,
+  MN_SDB_MNODE = 3,
+  MN_SDB_ACCT = 4,
+  MN_SDB_AUTH = 5,
+  MN_SDB_USER = 6,
+  MN_SDB_DB = 7,
+  MN_SDB_VGROUP = 8,
+  MN_SDB_STABLE = 9,
+  MN_SDB_FUNC = 10,
+  MN_SDB_OPER = 11,
+  MN_SDB_MAX = 12
+} EMnSdb;
+
+typedef enum { MN_OP_START = 0, MN_OP_INSERT = 1, MN_OP_UPDATE = 2, MN_OP_DELETE = 3, MN_OP_MAX = 4 } EMnOp;
+
+typedef enum { MN_KEY_START = 0, MN_KEY_BINARY = 1, MN_KEY_INT32 = 2, MN_KEY_INT64 = 3, MN_KEY_MAX } EMnKey;
+
+typedef enum {
+  MN_AUTH_ACCT_START = 0,
+  MN_AUTH_ACCT_USER,
+  MN_AUTH_ACCT_DNODE,
+  MN_AUTH_ACCT_MNODE,
+  MN_AUTH_ACCT_DB,
+  MN_AUTH_ACCT_TABLE,
+  MN_AUTH_ACCT_MAX
+} EMnAuthAcct;
+
+typedef enum {
+  MN_AUTH_OP_START = 0,
+  MN_AUTH_OP_CREATE_USER,
+  MN_AUTH_OP_ALTER_USER,
+  MN_AUTH_OP_DROP_USER,
+  MN_AUTH_MAX
+} EMnAuthOp;
+
+typedef enum { MN_SDB_STAT_AVAIL = 0, MN_SDB_STAT_DROPPED = 1 } EMnSdbStat;
+
+typedef struct {
+  int8_t type;
+  int8_t status;
+  int8_t align[6];
+} SdbHead;
 
 typedef struct SClusterObj {
+  SdbHead head;
+  int64_t id;
   char    uid[TSDB_CLUSTER_ID_LEN];
   int64_t createdTime;
-  int8_t  reserved[12];
-  int8_t  updateEnd[4];
-  int32_t refCount;
+  int64_t updateTime;
 } SClusterObj;
 
 typedef struct SDnodeObj {
-  int32_t    dnodeId;
-  int32_t    openVnodes;
-  int64_t    createdTime;
-  int64_t    lastAccess;
-  int32_t    customScore;      // config by user
-  uint16_t   numOfCores;       // from dnode status msg
-  uint16_t   dnodePort;
-  char       dnodeFqdn[TSDB_FQDN_LEN];
-  char       dnodeEp[TSDB_EP_LEN];
-  int8_t     alternativeRole;  // from dnode status msg, 0-any, 1-mgmt, 2-dnode
-  int8_t     status;           // set in balance function
-  int8_t     isMgmt;
-  int8_t     reserve1[11];  
-  int8_t     updateEnd[4];
-  int32_t    refCount;
-  uint32_t   moduleStatus;
-  uint32_t   lastReboot;       // time stamp for last reboot
-  float      score;            // calc in balance function
-  float      diskAvailable;    // from dnode status msg
-  int16_t    diskAvgUsage;     // calc from sys.disk
-  int16_t    cpuAvgUsage;      // calc from sys.cpu
-  int16_t    memoryAvgUsage;   // calc from sys.mem
-  int16_t    bandwidthUsage;   // calc from sys.band
-  int8_t     offlineReason;
-  int8_t     reserved2[1];
+  SdbHead  head;
+  int32_t  id;
+  int32_t  vnodes;
+  int64_t  createdTime;
+  int64_t  updateTime;
+  int64_t  lastAccess;
+  int64_t  lastReboot;  // time stamp for last reboot
+  char     fqdn[TSDB_FQDN_LEN];
+  char     ep[TSDB_EP_LEN];
+  uint16_t port;
+  int16_t  numOfCores;       // from dnode status msg
+  int8_t   alternativeRole;  // from dnode status msg, 0-any, 1-mgmt, 2-dnode
+  int8_t   status;           // set in balance function
+  int8_t   offlineReason;
 } SDnodeObj;
 
 typedef struct SMnodeObj {
-  int32_t    mnodeId;
-  int8_t     reserved0[4];
-  int64_t    createdTime;
-  int8_t     reserved1[4];
-  int8_t     updateEnd[4];
-  int32_t    refCount;
+  SdbHead    head;
+  int32_t    id;
+  int8_t     status;
   int8_t     role;
+  int32_t    roleTerm;
   int64_t    roleTime;
-  int8_t     reserved2[3];
-} SMnodeObj;
-
-typedef struct STableObj {
-  char  *tableId;
-  int8_t type;
-} STableObj;
-
-typedef struct SSTableObj {
-  STableObj  info; 
-  int8_t     reserved0[9]; // for fill struct STableObj to 4byte align
-  int16_t    nextColId;
-  int32_t    sversion;
-  uint64_t   uid;
   int64_t    createdTime;
-  int32_t    tversion;
-  int32_t    numOfColumns;
-  int32_t    numOfTags;
-  int8_t     updateEnd[4];
-  int32_t    refCount;
-  int32_t    numOfTables;
-  SSchema *  schema;
-  void *     vgHash;
-} SSTableObj;
+  int64_t    updateTime;
+  SDnodeObj *pDnode;
+} SMnodeObj;
 
 typedef struct {
-  STableObj  info;  
-  int8_t     reserved0[9]; // for fill struct STableObj to 4byte align
-  int16_t    nextColId;    //used by normal table
-  int32_t    sversion;     //used by normal table  
-  uint64_t   uid;
-  uint64_t   suid;
-  int64_t    createdTime;
-  int32_t    numOfColumns; //used by normal table
-  int32_t    tid;
-  int32_t    vgId;
-  int32_t    sqlLen;
-  int8_t     updateEnd[4];
-  int32_t    refCount;
-  char*      sql;          //used by normal table
-  SSchema*   schema;       //used by normal table
-  SSTableObj*superTable;
-} SCTableObj;
+  int32_t maxUsers;
+  int32_t maxDbs;
+  int32_t maxTimeSeries;
+  int32_t maxStreams;
+  int64_t maxStorage;    // In unit of GB
+  int8_t  accessState;  // Configured only by command
+} SAcctCfg;
 
 typedef struct {
-  int32_t    dnodeId;
-  int8_t     role;
-  int8_t     vver[3];  // To ensure compatibility, 3 bits are used to represent the remainder of 64 bit version
-  SDnodeObj *pDnode;
-} SVnodeGid;
+  int32_t numOfUsers;
+  int32_t numOfDbs;
+  int32_t numOfTimeSeries;
+  int32_t numOfStreams;
+  int64_t totalStorage;  // Total storage wrtten from this account
+  int64_t compStorage;   // Compressed storage on disk
+} SAcctInfo;
 
-typedef struct SVgObj {
-  uint32_t       vgId;
-  int32_t        numOfVnodes;
-  int64_t        createdTime;
-  int32_t        lbDnodeId;
-  int32_t        lbTime;
-  char           dbName[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
-  int8_t         inUse;
-  int8_t         accessState;
-  int8_t         status;
-  int8_t         reserved0[4];
-  SVnodeGid      vnodeGid[TSDB_MAX_REPLICA];
-  int32_t        vgCfgVersion;
-  int8_t         compact;
-  int8_t         reserved1[8];
-  int8_t         updateEnd[4];
-  int32_t        refCount;
-  int32_t        numOfTables;
-  int64_t        totalStorage;
-  int64_t        compStorage;
-  int64_t        pointsWritten;
-  struct SDbObj *pDb;
-  void *         idPool;
-} SVgObj;
+typedef struct SAcctObj {
+  SdbHead   head;
+  char      acct[TSDB_USER_LEN];
+  int64_t   createdTime;
+  int64_t   updateTime;
+  int32_t   acctId;
+  int8_t    status;
+  SAcctCfg  cfg;
+  SAcctInfo info;
+} SAcctObj;
+
+typedef struct SUserObj {
+  SdbHead   head;
+  char      user[TSDB_USER_LEN];
+  char      pass[TSDB_KEY_LEN];
+  char      acct[TSDB_USER_LEN];
+  int64_t   createdTime;
+  int64_t   updateTime;
+  int8_t    rootAuth;
+  SHashObj *prohibitDbHash;
+  SAcctObj *pAcct;
+} SUserObj;
 
 typedef struct {
   int32_t cacheBlockSize;
@@ -178,115 +204,117 @@ typedef struct {
   int8_t  cacheLastRow;
   int8_t  dbType;
   int16_t partitions;
-  int8_t  reserved[7];
 } SDbCfg;
 
 typedef struct SDbObj {
-  char    name[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
-  int8_t  reserved0[4];
-  char    acct[TSDB_USER_LEN];
-  int64_t createdTime;
-  int32_t dbCfgVersion;
-  SDbCfg  cfg;
-  int8_t  status;
-  int8_t  reserved1[11];
-  int8_t  updateEnd[4];
-  int32_t refCount;
-  int32_t numOfVgroups;
-  int32_t numOfTables;
-  int32_t numOfSuperTables;
-  int32_t vgListSize; 
-  int32_t vgListIndex;
-  SVgObj **vgList;
-  struct SAcctObj *pAcct;
-  pthread_mutex_t  mutex;
+  SdbHead   head;
+  char      name[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
+  char      acct[TSDB_USER_LEN];
+  int64_t   createdTime;
+  int64_t   updateTime;
+  SDbCfg    cfg;
+  int8_t    status;
+  int32_t   numOfVgroups;
+  int32_t   numOfTables;
+  int32_t   numOfSuperTables;
+  int32_t   vgListSize;
+  int32_t   vgListIndex;
+  SVgObj  **vgList;
+  SAcctObj *pAcct;
 } SDbObj;
 
-typedef struct SUserObj {
-  char              user[TSDB_USER_LEN];
-  char              pass[TSDB_KEY_LEN];
-  char              acct[TSDB_USER_LEN];
-  int64_t           createdTime;
-  int8_t            superAuth;
-  int8_t            writeAuth;
-  int8_t            reserved[10];
-  int8_t            updateEnd[4];
-  int32_t           refCount;
-  struct SAcctObj * pAcct;
-} SUserObj;
-
-typedef struct SFuncObj {
-  char              name[TSDB_FUNC_NAME_LEN];
-  char              path[128];
-  int32_t           contLen;
-  char              cont[TSDB_FUNC_CODE_LEN];
-  int32_t           funcType;
-  int32_t           bufSize;
-  int64_t           createdTime;
-  uint8_t           resType;
-  int16_t           resBytes;
-  int64_t           sig;         // partial md5 sign
-  int16_t           type;        // [lua script|so|js]
-  int8_t            reserved[64];
-  int8_t            updateEnd[4];
-  int32_t           refCount;
-} SFuncObj;
-
 typedef struct {
-  int64_t totalStorage;  // Total storage wrtten from this account
-  int64_t compStorage;   // Compressed storage on disk
-  int64_t queryTime;
-  int64_t totalPoints;
-  int64_t inblound;
-  int64_t outbound;
-  int64_t sKey;
-  int32_t numOfUsers;
-  int32_t numOfDbs;
-  int32_t numOfTimeSeries;
-  int32_t numOfPointsPerSecond;
-  int32_t numOfConns;
-  int32_t numOfQueries;
-  int32_t numOfStreams;
-  int8_t  accessState;   // Checked by mgmt heartbeat message
-  int8_t  reserved[3];
-} SAcctInfo;
+  int32_t    dnodeId;
+  int8_t     role;
+  SDnodeObj *pDnode;
+} SVnodeGid;
 
-typedef struct SAcctObj {
-  char      user[TSDB_USER_LEN];
-  char      pass[TSDB_KEY_LEN];
-  SAcctCfg  cfg;
+typedef struct SVgObj {
+  uint32_t  vgId;
+  int32_t   numOfVnodes;
   int64_t   createdTime;
-  int32_t   acctId;
+  int64_t   updateTime;
+  int32_t   lbDnodeId;
+  int32_t   lbTime;
+  char      dbName[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
+  int8_t    inUse;
+  int8_t    accessState;
   int8_t    status;
-  int8_t    reserved0[7];
-  int8_t    updateEnd[4];
-  int32_t   refCount;
-  int8_t    reserved1[4];
-  SAcctInfo acctInfo;
-  pthread_mutex_t  mutex;
-} SAcctObj;
+  SVnodeGid vnodeGid[TSDB_MAX_REPLICA];
+  int32_t   vgCfgVersion;
+  int8_t    compact;
+  int32_t   numOfTables;
+  int64_t   totalStorage;
+  int64_t   compStorage;
+  int64_t   pointsWritten;
+  SDbObj   *pDb;
+} SVgObj;
+
+typedef struct SSTableObj {
+  SdbHead    head;
+  char       tableId[TSDB_TABLE_NAME_LEN];
+  uint64_t   uid;
+  int64_t    createdTime;
+  int64_t    updateTime;
+  int32_t    numOfColumns;  // used by normal table
+  int32_t    numOfTags;
+  SSchema *  schema;
+} SSTableObj;
+
+typedef struct SFuncObj {
+  SdbHead head;
+  char    name[TSDB_FUNC_NAME_LEN];
+  char    path[128];
+  int32_t contLen;
+  char    cont[TSDB_FUNC_CODE_LEN];
+  int32_t funcType;
+  int32_t bufSize;
+  int64_t createdTime;
+  uint8_t resType;
+  int16_t resBytes;
+  int64_t sig;
+  int16_t type;
+} SFuncObj;
 
 typedef struct {
-  char     db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
   int8_t   type;
+  int8_t   maxReplica;
   int16_t  numOfColumns;
   int32_t  index;
   int32_t  rowSize;
   int32_t  numOfRows;
-  void *   pIter;
-  void *   pVgIter;
-  void **  ppShow;
-  int16_t  offset[TSDB_MAX_COLUMNS];
-  int32_t  bytes[TSDB_MAX_COLUMNS];
   int32_t  numOfReads;
-  int8_t   maxReplica;
-  int8_t   reserved0[1];
   uint16_t payloadLen;
+  void    *pIter;
+  void    *pVgIter;
+  void   **ppShow;
+  char     db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
+  int16_t  offset[TSDB_MAX_COLUMNS];
+  int32_t  bytes[TSDB_MAX_COLUMNS];
   char     payload[];
 } SShowObj;
 
+typedef struct {
+  int32_t len;
+  void   *rsp;
+} SMnRsp;
+
+typedef struct SMnMsg {
+  void (*fp)(SMnMsg *pMsg, int32_t code);
+  SUserObj *pUser;
+  int16_t   received;
+  int16_t   successed;
+  int16_t   expected;
+  int16_t   retry;
+  int32_t   code;
+  int64_t   createdTime;
+  SMnRsp    rpcRsp;
+  SRpcMsg   rpcMsg;
+  char      pCont[];
+} SMnReq;
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif
+#endif /*_TD_MNODE_DEF_H_*/

source/server/mnode/inc/mnodeDnode.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_DNODE_H_
+#define _TD_MNODE_DNODE_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitDnode();
+void    mnodeCleanupDnode();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_DNODE_H_*/

source/server/mnode/inc/mnodeFunc.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_FUNC_H_
+#define _TD_MNODE_FUNC_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitFunc();
+void    mnodeCleanupFunc();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_FUNC_H_*/

source/server/mnode/inc/mnodeInt.h

@@ -16,17 +16,24 @@
 #ifndef _TD_MNODE_INT_H_
 #define _TD_MNODE_INT_H_
 
+#include "mnodeDef.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "os.h"
-#include "taosmsg.h"
-#include "trpc.h"
-#include "mnode.h"
+tmr_h     mnodeGetTimer();
+int32_t   mnodeGetDnodeId();
+char     *mnodeGetClusterId();
+EMnStatus mnodeGetStatus();
+
+void mnodeSendMsgToDnode(struct SRpcEpSet *epSet, struct SRpcMsg *rpcMsg);
+void mnodeSendMsgToMnode(struct SRpcMsg *rpcMsg);
+void mnodeSendRedirectMsg(struct SRpcMsg *rpcMsg, bool forShell);
+void mnodeGetDnodeEp(int32_t dnodeId, char *ep, char *fqdn, uint16_t *port);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_MNODE_INT_H_*/
+#endif /*_TD_MNODE_INT_H_*/
\ No newline at end of file

source/server/mnode/inc/mnodeMnode.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_MNODE_H_
+#define _TD_MNODE_MNODE_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitMnode();
+void    mnodeCleanupMnode();
+void    mnodeGetMnodeEpSetForPeer(SRpcEpSet *epSet, bool redirect);
+void    mnodeGetMnodeEpSetForShell(SRpcEpSet *epSet, bool redirect);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_MNODE_H_*/

source/server/mnode/inc/mnodeOper.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_OPER_H_
+#define _TD_MNODE_OPER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitOper();
+void    mnodeCleanupOper();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_OPER_H_*/

source/server/mnode/inc/mnodeProfile.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_PROFILE_H_
+#define _TD_MNODE_PROFILE_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitProfile();
+void    mnodeCleanupProfile();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_PROFILE_H_*/

src/mnode/inc/mnodeFunc.h → source/server/mnode/inc/mnodeSdb.h

@@ -13,28 +13,40 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MNODE_FUNC_H
-#define TDENGINE_MNODE_FUNC_H
+#ifndef _TD_MNODE_SDB_H_
+#define _TD_MNODE_SDB_H_
+
+#include "mnodeInt.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "mnodeDef.h"
 
-int32_t   mnodeInitFuncs();
-void      mnodeCleanupFuncs();
+typedef void (*SdbDeployFp)();
+typedef void *(*SdbDecodeFp)(cJSON *root);
+typedef int32_t (*SdbEncodeFp)(void *pHead, char *buf, int32_t maxLen);
+
+int32_t sdbInit();
+void    sdbCleanup();
 
-SFuncObj *mnodeGetFunc(char *name);
-void *    mnodeGetNextFunc(void *pIter, SFuncObj **pFunc);
-void      mnodeCancelGetNextFunc(void *pIter);
+int32_t sdbRead();
+int32_t sdbCommit();
 
-void      mnodeIncFuncRef(SFuncObj *pFunc);
-void      mnodeDecFuncRef(SFuncObj *pFunc);
+int32_t sdbDeploy();
+void    sdbUnDeploy();
 
-int32_t   mnodeCreateFunc(SAcctObj *pAcct, char *name, int32_t codeLen, char *code, char *path, uint8_t outputType, int16_t outputLen, int32_t funcType, int32_t bufSize, SMnodeMsg *pMsg);
+void   *sdbInsertRow(EMnSdb sdb, void *pObj);
+void    sdbDeleteRow(EMnSdb sdb, void *pHead);
+void   *sdbUpdateRow(EMnSdb sdb, void *pHead);
+void   *sdbGetRow(EMnSdb sdb, void *pKey);
+void   *sdbFetchRow(EMnSdb sdb, void *pIter);
+void    sdbCancelFetch(EMnSdb sdb, void *pIter);
+int32_t sdbGetCount(EMnSdb sdb);
+
+void sdbSetFp(EMnSdb, EMnKey, SdbDeployFp, SdbEncodeFp, SdbDecodeFp, int32_t dataSize);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif
+#endif /*_TD_MNODE_INT_H_*/

source/server/mnode/inc/mnodeShow.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_SHOW_H_
+#define _TD_MNODE_SHOW_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitShow();
+void    mnodeCleanUpShow();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_SHOW_H_*/

source/server/mnode/inc/mnodeStable.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_STABLE_H_
+#define _TD_MNODE_STABLE_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitStable();
+void    mnodeCleanupStable();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_STABLE_H_*/

source/server/mnode/inc/mnodeSync.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_SYNC_H_
+#define _TD_MNODE_SYNC_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitSync();
+void    mnodeCleanUpSync();
+
+bool mnodeIsMaster();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_SYNC_H_*/

source/server/dnode/inc/dnodeTelem.h → source/server/mnode/inc/mnodeTelem.h

@@ -13,19 +13,19 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TD_DNODE_TELEMETRY_H_
-#define _TD_DNODE_TELEMETRY_H_
+#ifndef _TD_MNODE_TELEMETRY_H_
+#define _TD_MNODE_TELEMETRY_H_
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "dnodeInt.h"
+#include "mnodeInt.h"
 
-int32_t dnodeInitTelem();
-void    dnodeCleanupTelem();
+int32_t mnodeInitTelem();
+void    mnodeCleanupTelem();
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_DNODE_TELEMETRY_H_*/
+#endif /*_TD_MNODE_TELEMETRY_H_*/

source/server/mnode/inc/mnodeUser.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_USER_H_
+#define _TD_MNODE_USER_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitUser();
+void    mnodeCleanupUser();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_USER_H_*/

source/server/mnode/inc/mnodeVgroup.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_VGROUP_H_
+#define _TD_MNODE_VGROUP_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitVgroup();
+void    mnodeCleanupVgroup();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_VGROUP_H_*/

source/server/mnode/inc/mnodeWorker.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MNODE_WORKER_H_
+#define _TD_MNODE_WORKER_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mnodeInitWorker();
+void    mnodeCleanupWorker();
+void    mnodeProcessMsg(SRpcMsg *rpcMsg);
+void    mnodeSendRsp(SMnMsg *pMsg, int32_t code);
+void    mnodeReDispatchToWriteQueue(SMnMsg *pMsg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MNODE_WORKER_H_*/

source/server/mnode/src/mnodeAcct.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeSdb.h"
+
+static void mnodeCreateDefaultAcct() {
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  SAcctObj acctObj = {0};
+  tstrncpy(acctObj.acct, TSDB_DEFAULT_USER, TSDB_USER_LEN);
+  acctObj.cfg = (SAcctCfg){.maxUsers = 128,
+                           .maxDbs = 128,
+                           .maxTimeSeries = INT32_MAX,
+                           .maxStreams = 1000,
+                           .maxStorage = INT64_MAX,
+                           .accessState = TSDB_VN_ALL_ACCCESS};
+  acctObj.acctId = 1;
+  acctObj.createdTime = taosGetTimestampMs();
+  acctObj.updateTime = taosGetTimestampMs();
+
+  sdbInsertRow(MN_SDB_ACCT, &acctObj);
+}
+
+int32_t mnodeEncodeAcct(SAcctObj *pAcct, char *buf, int32_t maxLen) {
+  int32_t len = 0;
+
+  len += snprintf(buf + len, maxLen - len, "{\"type\":%d, ", MN_SDB_ACCT);
+  len += snprintf(buf + len, maxLen - len, "\"acct\":\"%s\", ", pAcct->acct);
+  len += snprintf(buf + len, maxLen - len, "\"acctId\":\"%d\", ", pAcct->acctId);
+  len += snprintf(buf + len, maxLen - len, "\"maxUsers\":\"%d\", ", pAcct->cfg.maxUsers);
+  len += snprintf(buf + len, maxLen - len, "\"maxDbs\":\"%d\", ", pAcct->cfg.maxDbs);
+  len += snprintf(buf + len, maxLen - len, "\"maxTimeSeries\":\"%d\", ", pAcct->cfg.maxTimeSeries);
+  len += snprintf(buf + len, maxLen - len, "\"maxStreams\":\"%d\", ", pAcct->cfg.maxStreams);
+  len += snprintf(buf + len, maxLen - len, "\"maxStorage\":\"%" PRIu64 "\", ", pAcct->cfg.maxStorage);
+  len += snprintf(buf + len, maxLen - len, "\"accessState\":\"%d\", ", pAcct->cfg.accessState);
+  len += snprintf(buf + len, maxLen - len, "\"createdTime\":\"%" PRIu64 "\", ", pAcct->createdTime);
+  len += snprintf(buf + len, maxLen - len, "\"updateTime\":\"%" PRIu64 "\"}\n", pAcct->updateTime);
+
+  return len;
+}
+
+SAcctObj *mnodeDecodeAcct(cJSON *root) {
+  int32_t   code = -1;
+  SAcctObj *pAcct = calloc(1, sizeof(SAcctObj));
+
+  cJSON *acct = cJSON_GetObjectItem(root, "acct");
+  if (!acct || acct->type != cJSON_String) {
+    mError("failed to parse acct since acct not found");
+    goto DECODE_ACCT_OVER;
+  }
+  tstrncpy(pAcct->acct, acct->valuestring, TSDB_USER_LEN);
+
+  cJSON *acctId = cJSON_GetObjectItem(root, "acctId");
+  if (!acctId || acctId->type != cJSON_String) {
+    mError("acct:%s, failed to parse since acctId not found", pAcct->acct);
+    goto DECODE_ACCT_OVER;
+  }
+  pAcct->acctId = atol(acctId->valuestring);
+
+  cJSON *maxUsers = cJSON_GetObjectItem(root, "maxUsers");
+  if (!maxUsers || maxUsers->type != cJSON_String) {
+    mError("acct:%s, failed to parse since maxUsers not found", pAcct->acct);
+    goto DECODE_ACCT_OVER;
+  }
+  pAcct->cfg.maxUsers = atol(maxUsers->valuestring);
+
+  cJSON *maxDbs = cJSON_GetObjectItem(root, "maxDbs");
+  if (!maxDbs || maxDbs->type != cJSON_String) {
+    mError("acct:%s, failed to parse since maxDbs not found", pAcct->acct);
+    goto DECODE_ACCT_OVER;
+  }
+  pAcct->cfg.maxDbs = atol(maxDbs->valuestring);
+
+  cJSON *maxTimeSeries = cJSON_GetObjectItem(root, "maxTimeSeries");
+  if (!maxTimeSeries || maxTimeSeries->type != cJSON_String) {
+    mError("acct:%s, failed to parse since maxTimeSeries not found", pAcct->acct);
+    goto DECODE_ACCT_OVER;
+  }
+  pAcct->cfg.maxTimeSeries = atol(maxTimeSeries->valuestring);
+
+  cJSON *maxStreams = cJSON_GetObjectItem(root, "maxStreams");
+  if (!maxStreams || maxStreams->type != cJSON_String) {
+    mError("acct:%s, failed to parse since maxStreams not found", pAcct->acct);
+    goto DECODE_ACCT_OVER;
+  }
+  pAcct->cfg.maxStreams = atol(maxStreams->valuestring);
+
+  cJSON *maxStorage = cJSON_GetObjectItem(root, "maxStorage");
+  if (!maxStorage || maxStorage->type != cJSON_String) {
+    mError("acct:%s, failed to parse since maxStorage not found", pAcct->acct);
+    goto DECODE_ACCT_OVER;
+  }
+  pAcct->cfg.maxStorage = atoll(maxStorage->valuestring);
+
+  cJSON *accessState = cJSON_GetObjectItem(root, "accessState");
+  if (!accessState || accessState->type != cJSON_String) {
+    mError("acct:%s, failed to parse since accessState not found", pAcct->acct);
+    goto DECODE_ACCT_OVER;
+  }
+  pAcct->cfg.accessState = atol(accessState->valuestring);
+
+  cJSON *createdTime = cJSON_GetObjectItem(root, "createdTime");
+  if (!createdTime || createdTime->type != cJSON_String) {
+    mError("acct:%s, failed to parse since createdTime not found", pAcct->acct);
+    goto DECODE_ACCT_OVER;
+  }
+  pAcct->createdTime = atol(createdTime->valuestring);
+
+  cJSON *updateTime = cJSON_GetObjectItem(root, "updateTime");
+  if (!updateTime || updateTime->type != cJSON_String) {
+    mError("acct:%s, failed to parse since updateTime not found", pAcct->acct);
+    goto DECODE_ACCT_OVER;
+  }
+  pAcct->updateTime = atol(updateTime->valuestring);
+
+  code = 0;
+  mTrace("acct:%s, parse success", pAcct->acct);
+
+DECODE_ACCT_OVER:
+  if (code != 0) {
+    free(pAcct);
+    pAcct = NULL;
+  }
+  return pAcct;
+}
+
+int32_t mnodeInitAcct() {
+  sdbSetFp(MN_SDB_ACCT, MN_KEY_BINARY, mnodeCreateDefaultAcct, (SdbEncodeFp)mnodeEncodeAcct,
+           (SdbDecodeFp)(mnodeDecodeAcct), sizeof(SAcctObj));
+
+  return 0;
+}
+
+void mnodeCleanupAcct() {}

source/server/mnode/src/mnodeMain.c → source/server/mnode/src/mnodeAuth.c

@@ -13,20 +13,24 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "mnodeInt.h"
-
-int32_t mnodeInit(SMnodePara para) { return 0; }
-
-void mnodeCleanup() {}
-
-int32_t mnodeDeploy(struct SMInfos *minfos) { return 0; }
-
-void mnodeUnDeploy() {}
-
-bool mnodeIsServing() { return false; }
-
-int32_t mnodeGetStatistics(SMnodeStat *stat) { return 0; }
-
-int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey) { return 0; }
-
-void mnodeProcessMsg(SRpcMsg *rpcMsg) {}
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeAuth.h"
+
+int32_t mnodeInitAuth() { return 0; }
+void    mnodeCleanupAuth() {}
+
+int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
+  if (strcmp(user, TSDB_NETTEST_USER) == 0) {
+    char pass[32] = {0};
+    taosEncryptPass((uint8_t *)user, strlen(user), pass);
+    *spi = 0;
+    *encrypt = 0;
+    *ckey = 0;
+    memcpy(secret, pass, TSDB_KEY_LEN);
+    mDebug("nettest user is authorized");
+    return 0;
+  }
+
+  return 0;
+}
\ No newline at end of file

source/server/mnode/src/mnodeBalance.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitBalance() { return 0; }
+void    mnodeCleanupBalance() {}
\ No newline at end of file

source/server/mnode/src/mnodeCluster.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitCluster() { return 0; }
+void    mnodeCleanupCluster() {}
\ No newline at end of file

source/server/mnode/src/mnodeDb.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitDb() { return 0; }
+void    mnodeCleanupDb() {}
\ No newline at end of file

source/server/mnode/src/mnodeDnode.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitDnode() { return 0; }
+void    mnodeCleanupDnode() {}
\ No newline at end of file

source/server/mnode/src/mnodeFunc.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitFunc() { return 0; }
+void    mnodeCleanupFunc() {}
\ No newline at end of file

source/server/mnode/src/mnodeMnode.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitMnode() { return 0; }
+void    mnodeCleanupMnode() {}
+
+void mnodeGetMnodeEpSetForPeer(SRpcEpSet *epSet, bool redirect) {}
+void mnodeGetMnodeEpSetForShell(SRpcEpSet *epSet, bool redirect) {}
\ No newline at end of file

source/server/mnode/src/mnodeOper.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitOper() { return 0; }
+void    mnodeCleanupOper() {}
\ No newline at end of file

source/server/mnode/src/mnodeProfile.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitProfile() { return 0; }
+void    mnodeCleanupProfile() {}
\ No newline at end of file

source/server/mnode/src/mnodeSdb.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "thash.h"
+#include "tglobal.h"
+#include "cJSON.h"
+#include "mnodeSdb.h"
+
+static struct {
+  char        currDir[PATH_MAX];
+  char        backDir[PATH_MAX];
+  char        tmpDir[PATH_MAX];
+  int64_t     version;
+  EMnKey      hashKey[MN_SDB_MAX];
+  int32_t     dataSize[MN_SDB_MAX];
+  SHashObj   *hashObj[MN_SDB_MAX];
+  SdbDeployFp deployFp[MN_SDB_MAX];
+  SdbEncodeFp encodeFp[MN_SDB_MAX];
+  SdbDecodeFp decodeFp[MN_SDB_MAX];
+} tsSdb = {0};
+
+static int32_t sdbCreateDir() {
+  if (!taosMkDir(tsSdb.currDir)) {
+    mError("failed to create dir:%s", tsSdb.currDir);
+    return TAOS_SYSTEM_ERROR(errno);
+  }
+
+  if (!taosMkDir(tsSdb.backDir)) {
+    mError("failed to create dir:%s", tsSdb.backDir);
+    return -1;
+  }
+
+  if (!taosMkDir(tsSdb.tmpDir)) {
+    mError("failed to create dir:%s", tsSdb.tmpDir);
+    return -1;
+  }
+
+  return 0;
+}
+
+static int32_t sdbRunDeployFp() {
+  for (int32_t i = MN_SDB_START; i < MN_SDB_MAX; ++i) {
+    SdbDeployFp fp = tsSdb.deployFp[i];
+    if (fp) {
+      (*fp)();
+    }
+  }
+
+  return 0;
+}
+
+static int32_t sdbReadVersion(cJSON *root) {
+  cJSON *ver = cJSON_GetObjectItem(root, "version");
+  if (!ver || ver->type != cJSON_String) {
+    mError("failed to parse version since version not found");
+    return -1;
+  }
+
+  tsSdb.version = (int64_t)atoll(ver->valuestring);
+  mTrace("parse version success, version:%" PRIu64, tsSdb.version);
+
+  return 0;
+}
+
+static void sdbWriteVersion(FileFd fd) {
+  char    content[128];
+  int32_t len =
+      snprintf(content, sizeof(content), "{\"type\":0, \"version\":\"%" PRIu64 "\", \"updateTime\":\"%" PRIu64 "\"}\n",
+               tsSdb.version, taosGetTimestampMs());
+  taosWriteFile(fd, content, len);
+}
+
+static int32_t sdbReadDataFile() {
+  ssize_t _bytes = 0;
+  size_t  len = 4096;
+  char   *line = calloc(1, len);
+  int32_t code = -1;
+  FILE   *fp = NULL;
+  cJSON  *root = NULL;
+
+  char file[PATH_MAX + 20];
+  snprintf(file, sizeof(file), "%ssdb.data", tsSdb.currDir);
+  fp = fopen(file, "r");
+  if (!fp) {
+    mDebug("failed to open file:%s for read since %s", file, strerror(errno));
+    goto PARSE_SDB_DATA_ERROR;
+  }
+
+  while (!feof(fp)) {
+    memset(line, 0, len);
+    _bytes = tgetline(&line, &len, fp);
+    if (_bytes < 0) {
+      break;
+    }
+
+    line[len - 1] = 0;
+    if (len <= 10) continue;
+
+    root = cJSON_Parse(line);
+    if (root == NULL) {
+      mError("failed to parse since invalid json format, %s", line);
+      goto PARSE_SDB_DATA_ERROR;
+    }
+
+    cJSON *type = cJSON_GetObjectItem(root, "type");
+    if (!type || type->type != cJSON_Number) {
+      mError("failed to parse since invalid type not found, %s", line);
+      goto PARSE_SDB_DATA_ERROR;
+    }
+
+    if (type->valueint >= MN_SDB_MAX || type->valueint < MN_SDB_START) {
+      mError("failed to parse since invalid type, %s", line);
+      goto PARSE_SDB_DATA_ERROR;
+    }
+
+    if (type->valueint == MN_SDB_START) {
+      if (sdbReadVersion(root) != 0) {
+        mError("failed to parse version, %s", line);
+        goto PARSE_SDB_DATA_ERROR;
+      }
+      cJSON_Delete(root);
+      root = NULL;
+      continue;
+    }
+
+    SdbDecodeFp decodeFp = tsSdb.decodeFp[type->valueint];
+    SdbHead    *pHead = (*decodeFp)(root);
+    if (pHead == NULL) {
+      mError("failed to parse since decode error, %s", line);
+      goto PARSE_SDB_DATA_ERROR;
+    }
+
+    pHead->type = type->valueint;
+    pHead->status = MN_SDB_STAT_AVAIL;
+
+    sdbInsertRow(pHead->type, pHead);
+    free(pHead);
+    cJSON_Delete(root);
+    root = NULL;
+  }
+
+  code = 0;
+
+PARSE_SDB_DATA_ERROR:
+  if (line) free(line);
+  if (fp) fclose(fp);
+  if (root) cJSON_Delete(root);
+
+  return code;
+}
+
+static int32_t sdbWriteDataFile() {
+  char file[PATH_MAX + 20] = {0};
+  snprintf(file, sizeof(file), "%ssdb.data", tsSdb.currDir);
+  FileFd fd = taosOpenFileCreateWrite(file);
+  if (fd <= 0) {
+    mError("failed to open file:%s for write since %s", file, strerror(errno));
+    return -1;
+  }
+
+  int32_t len;
+  int32_t maxLen = 10240;
+  char   *buf = malloc(maxLen);
+
+  for (int32_t i = MN_SDB_START; i < MN_SDB_MAX; ++i) {
+    SHashObj *hash = tsSdb.hashObj[i];
+    if (!hash) continue;
+
+    SdbEncodeFp encodeFp = tsSdb.encodeFp[i];
+    if (!encodeFp) continue;
+
+    SdbHead *pHead = taosHashIterate(hash, NULL);
+    while (pHead != NULL) {
+      len = (*encodeFp)(pHead, buf, maxLen);
+      if (len >= 0) {
+        taosWriteFile(fd, buf, len);
+      }
+
+      pHead = taosHashIterate(hash, pHead);
+    }
+  }
+
+  sdbWriteVersion(fd);
+  taosFsyncFile(fd);
+  taosCloseFile(fd);
+
+  mInfo("write file:%s successfully", file);
+  return 0;
+}
+
+int32_t sdbCommit() {
+  int32_t code = sdbWriteDataFile();
+  if (code != 0) {
+    return code;
+  }
+
+  return 0;
+}
+
+int32_t sdbRead() {
+  int32_t code = sdbReadDataFile();
+  if (code != 0) {
+    return code;
+  }
+
+  mInfo("read sdb file successfully");
+  return -1;
+}
+
+int32_t sdbDeploy() {
+  if (sdbCreateDir() != 0) {
+    return -1;
+  }
+
+  if (sdbRunDeployFp() != 0) {
+    return -1;
+  }
+
+  if (sdbCommit() != 0) {
+    return -1;
+  }
+
+  // if (!taosMkDir())
+  // if (pMinfos == NULL) {  // first deploy
+  //   tsMint.dnodeId = 1;
+  //   bool getuid = taosGetSystemUid(tsMint.clusterId);
+  //   if (!getuid) {
+  //     strcpy(tsMint.clusterId, "tdengine3.0");
+  //     mError("deploy new mnode but failed to get uid, set to default val %s", tsMint.clusterId);
+  //   } else {
+  //     mDebug("deploy new mnode and uid is %s", tsMint.clusterId);
+  //   }
+  // } else {  // todo
+  // }
+
+  // if (mkdir(tsMnodeDir, 0755) != 0 && errno != EEXIST) {
+  //   mError("failed to init mnode dir:%s, reason:%s", tsMnodeDir, strerror(errno));
+  //   return -1;
+  // }
+  return 0;
+}
+
+void sdbUnDeploy() {}
+
+int32_t sdbInit() {
+  snprintf(tsSdb.currDir, PATH_MAX, "%s%scurrent%s", tsMnodeDir, TD_DIRSEP, TD_DIRSEP);
+  snprintf(tsSdb.backDir, PATH_MAX, "%s%sbackup%s", tsMnodeDir, TD_DIRSEP, TD_DIRSEP);
+  snprintf(tsSdb.tmpDir, PATH_MAX, "%s%stmp%s", tsMnodeDir, TD_DIRSEP, TD_DIRSEP);
+
+  for (int32_t i = 0; i < MN_SDB_MAX; ++i) {
+    int32_t type;
+    if (tsSdb.hashKey[i] == MN_KEY_INT32) {
+      type = TSDB_DATA_TYPE_INT;
+    } else if (tsSdb.hashKey[i] == MN_KEY_INT64) {
+      type = TSDB_DATA_TYPE_BIGINT;
+    } else {
+      type = TSDB_DATA_TYPE_BINARY;
+    }
+
+    SHashObj *hash = taosHashInit(128, taosGetDefaultHashFunction(type), true, HASH_NO_LOCK);
+    if (hash == NULL) {
+      return -1;
+    }
+
+    tsSdb.hashObj[i] = hash;
+  }
+
+  return 0;
+}
+
+void sdbCleanup() {
+  for (int32_t i = 0; i < MN_SDB_MAX; ++i) {
+    SHashObj *hash = tsSdb.hashObj[i];
+    if (hash != NULL) {
+      taosHashCleanup(hash);
+    }
+    tsSdb.hashObj[i] = NULL;
+  }
+}
+
+void sdbSetFp(EMnSdb sdb, EMnKey keyType, SdbDeployFp deployFp, SdbEncodeFp encodeFp, SdbDecodeFp decodeFp,
+              int32_t dataSize) {
+  tsSdb.deployFp[sdb] = deployFp;
+  tsSdb.encodeFp[sdb] = encodeFp;
+  tsSdb.decodeFp[sdb] = decodeFp;
+  tsSdb.dataSize[sdb] = dataSize;
+  tsSdb.hashKey[sdb] = keyType;
+}
+
+static SHashObj *sdbGetHash(int32_t sdb) {
+  if (sdb >= MN_SDB_MAX || sdb <= MN_SDB_START) {
+    return NULL;
+  }
+
+  SHashObj *hash = tsSdb.hashObj[sdb];
+  if (hash == NULL) {
+    return NULL;
+  }
+
+  return hash;
+}
+
+void *sdbInsertRow(EMnSdb sdb, void *p) {
+  SdbHead *pHead = p;
+  pHead->type = sdb;
+  pHead->status = MN_SDB_STAT_AVAIL;
+
+  char   *pKey = (char *)pHead + sizeof(pHead);
+  int32_t keySize;
+  EMnKey  keyType = tsSdb.hashKey[pHead->type];
+  int32_t dataSize = tsSdb.dataSize[pHead->type];
+
+  SHashObj *hash = sdbGetHash(pHead->type);
+  if (hash == NULL) {
+    return NULL;
+  }
+
+  if (keyType == MN_KEY_INT32) {
+    keySize = sizeof(int32_t);
+  } else if (keyType == MN_KEY_BINARY) {
+    keySize = strlen(pKey) + 1;
+  } else {
+    keySize = sizeof(int64_t);
+  }
+
+  taosHashPut(hash, pKey, keySize, pHead, dataSize);
+  return taosHashGet(hash, pKey, keySize);
+}
+
+void sdbDeleteRow(EMnSdb sdb, void *p) {
+  SdbHead *pHead = p;
+  pHead->status = MN_SDB_STAT_DROPPED;
+}
+
+void *sdbUpdateRow(EMnSdb sdb, void *pHead) { return sdbInsertRow(sdb, pHead); }
+
+void *sdbGetRow(EMnSdb sdb, void *pKey) {
+  SHashObj *hash = sdbGetHash(sdb);
+  if (hash == NULL) {
+    return NULL;
+  }
+
+  int32_t keySize;
+  EMnKey  keyType = tsSdb.hashKey[sdb];
+
+  if (keyType == MN_KEY_INT32) {
+    keySize = sizeof(int32_t);
+  } else if (keyType == MN_KEY_BINARY) {
+    keySize = strlen(pKey) + 1;
+  } else {
+    keySize = sizeof(int64_t);
+  }
+
+  return taosHashGet(hash, pKey, keySize);
+}
+
+void *sdbFetchRow(EMnSdb sdb, void *pIter) {
+  SHashObj *hash = sdbGetHash(sdb);
+  if (hash == NULL) {
+    return NULL;
+  }
+
+  return taosHashIterate(hash, pIter);
+}
+
+void sdbCancelFetch(EMnSdb sdb, void *pIter) {
+  SHashObj *hash = sdbGetHash(sdb);
+  if (hash == NULL) {
+    return;
+  }
+
+  taosHashCancelIterate(hash, pIter);
+}
+
+int32_t sdbGetCount(EMnSdb sdb) {
+  SHashObj *hash = sdbGetHash(sdb);
+  if (hash == NULL) {
+    return 0;
+  }
+  return taosHashGetSize(hash);
+}
\ No newline at end of file

source/server/mnode/src/mnodeShow.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitShow() { return 0; }
+void    mnodeCleanUpShow() {}
\ No newline at end of file

source/server/mnode/src/mnodeStable.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitStable() { return 0; }
+void    mnodeCleanupStable() {}
\ No newline at end of file

source/server/mnode/src/mnodeSync.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitSync() { return 0; }
+void    mnodeCleanUpSync() {}
+
+bool mnodeIsMaster() { return true; }
\ No newline at end of file

source/server/dnode/src/dnodeTelem.c → source/server/mnode/src/mnodeTelem.c

@@ -14,12 +14,9 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "os.h"
+#include "mnodeTelem.h"
 #include "tbuffer.h"
 #include "tglobal.h"
-#include "dnodeCfg.h"
-#include "dnodeTelem.h"
-#include "mnode.h"
 
 #define TELEMETRY_SERVER "telemetry.taosdata.com"
 #define TELEMETRY_PORT 80
@@ -38,9 +35,9 @@ static struct {
   char             email[TSDB_FQDN_LEN];
 } tsTelem;
 
-static void dnodeBeginObject(SBufferWriter* bw) { tbufWriteChar(bw, '{'); }
+static void mnodeBeginObject(SBufferWriter* bw) { tbufWriteChar(bw, '{'); }
 
-static void dnodeCloseObject(SBufferWriter* bw) {
+static void mnodeCloseObject(SBufferWriter* bw) {
   size_t len = tbufTell(bw);
   if (tbufGetData(bw, false)[len - 1] == ',') {
     tbufWriteCharAt(bw, len - 1, '}');
@@ -66,14 +63,14 @@ static void closeArray(SBufferWriter* bw) {
 }
 #endif
 
-static void dnodeWriteString(SBufferWriter* bw, const char* str) {
+static void mnodeWriteString(SBufferWriter* bw, const char* str) {
   tbufWriteChar(bw, '"');
   tbufWrite(bw, str, strlen(str));
   tbufWriteChar(bw, '"');
 }
 
-static void dnodeAddIntField(SBufferWriter* bw, const char* k, int64_t v) {
-  dnodeWriteString(bw, k);
+static void mnodeAddIntField(SBufferWriter* bw, const char* k, int64_t v) {
+  mnodeWriteString(bw, k);
   tbufWriteChar(bw, ':');
   char buf[32];
   sprintf(buf, "%" PRId64, v);
@@ -81,14 +78,14 @@ static void dnodeAddIntField(SBufferWriter* bw, const char* k, int64_t v) {
   tbufWriteChar(bw, ',');
 }
 
-static void dnodeAddStringField(SBufferWriter* bw, const char* k, const char* v) {
-  dnodeWriteString(bw, k);
+static void mnodeAddStringField(SBufferWriter* bw, const char* k, const char* v) {
+  mnodeWriteString(bw, k);
   tbufWriteChar(bw, ':');
-  dnodeWriteString(bw, v);
+  mnodeWriteString(bw, v);
   tbufWriteChar(bw, ',');
 }
 
-static void dnodeAddCpuInfo(SBufferWriter* bw) {
+static void mnodeAddCpuInfo(SBufferWriter* bw) {
   char*   line = NULL;
   size_t  size = 0;
   int32_t done = 0;
@@ -102,11 +99,11 @@ static void dnodeAddCpuInfo(SBufferWriter* bw) {
     line[size - 1] = '\0';
     if (((done & 1) == 0) && strncmp(line, "model name", 10) == 0) {
       const char* v = strchr(line, ':') + 2;
-      dnodeAddStringField(bw, "cpuModel", v);
+      mnodeAddStringField(bw, "cpuModel", v);
       done |= 1;
     } else if (((done & 2) == 0) && strncmp(line, "cpu cores", 9) == 0) {
       const char* v = strchr(line, ':') + 2;
-      dnodeWriteString(bw, "numOfCpu");
+      mnodeWriteString(bw, "numOfCpu");
       tbufWriteChar(bw, ':');
       tbufWrite(bw, v, strlen(v));
       tbufWriteChar(bw, ',');
@@ -118,7 +115,7 @@ static void dnodeAddCpuInfo(SBufferWriter* bw) {
   fclose(fp);
 }
 
-static void dnodeAddOsInfo(SBufferWriter* bw) {
+static void mnodeAddOsInfo(SBufferWriter* bw) {
   char*  line = NULL;
   size_t size = 0;
 
@@ -135,7 +132,7 @@ static void dnodeAddOsInfo(SBufferWriter* bw) {
         p++;
         line[size - 2] = 0;
       }
-      dnodeAddStringField(bw, "os", p);
+      mnodeAddStringField(bw, "os", p);
       break;
     }
   }
@@ -144,7 +141,7 @@ static void dnodeAddOsInfo(SBufferWriter* bw) {
   fclose(fp);
 }
 
-static void dnodeAddMemoryInfo(SBufferWriter* bw) {
+static void mnodeAddMemoryInfo(SBufferWriter* bw) {
   char*  line = NULL;
   size_t size = 0;
 
@@ -158,7 +155,7 @@ static void dnodeAddMemoryInfo(SBufferWriter* bw) {
     if (strncmp(line, "MemTotal", 8) == 0) {
       const char* p = strchr(line, ':') + 1;
       while (*p == ' ') p++;
-      dnodeAddStringField(bw, "memory", p);
+      mnodeAddStringField(bw, "memory", p);
       break;
     }
   }
@@ -167,57 +164,57 @@ static void dnodeAddMemoryInfo(SBufferWriter* bw) {
   fclose(fp);
 }
 
-static void dnodeAddVersionInfo(SBufferWriter* bw) {
-  dnodeAddStringField(bw, "version", version);
-  dnodeAddStringField(bw, "buildInfo", buildinfo);
-  dnodeAddStringField(bw, "gitInfo", gitinfo);
-  dnodeAddStringField(bw, "email", tsTelem.email);
+static void mnodeAddVersionInfo(SBufferWriter* bw) {
+  mnodeAddStringField(bw, "version", version);
+  mnodeAddStringField(bw, "buildInfo", buildinfo);
+  mnodeAddStringField(bw, "gitInfo", gitinfo);
+  mnodeAddStringField(bw, "email", tsTelem.email);
 }
 
-static void dnodeAddRuntimeInfo(SBufferWriter* bw) {
+static void mnodeAddRuntimeInfo(SBufferWriter* bw) {
   SMnodeStat stat = {0};
   if (mnodeGetStatistics(&stat) != 0) {
     return;
   }
 
-  dnodeAddIntField(bw, "numOfDnode", stat.numOfDnode);
-  dnodeAddIntField(bw, "numOfMnode", stat.numOfMnode);
-  dnodeAddIntField(bw, "numOfVgroup", stat.numOfVgroup);
-  dnodeAddIntField(bw, "numOfDatabase", stat.numOfDatabase);
-  dnodeAddIntField(bw, "numOfSuperTable", stat.numOfSuperTable);
-  dnodeAddIntField(bw, "numOfChildTable", stat.numOfChildTable);
-  dnodeAddIntField(bw, "numOfColumn", stat.numOfColumn);
-  dnodeAddIntField(bw, "numOfPoint", stat.totalPoints);
-  dnodeAddIntField(bw, "totalStorage", stat.totalStorage);
-  dnodeAddIntField(bw, "compStorage", stat.compStorage);
+  mnodeAddIntField(bw, "numOfDnode", stat.numOfDnode);
+  mnodeAddIntField(bw, "numOfMnode", stat.numOfMnode);
+  mnodeAddIntField(bw, "numOfVgroup", stat.numOfVgroup);
+  mnodeAddIntField(bw, "numOfDatabase", stat.numOfDatabase);
+  mnodeAddIntField(bw, "numOfSuperTable", stat.numOfSuperTable);
+  mnodeAddIntField(bw, "numOfChildTable", stat.numOfChildTable);
+  mnodeAddIntField(bw, "numOfColumn", stat.numOfColumn);
+  mnodeAddIntField(bw, "numOfPoint", stat.totalPoints);
+  mnodeAddIntField(bw, "totalStorage", stat.totalStorage);
+  mnodeAddIntField(bw, "compStorage", stat.compStorage);
 }
 
-static void dnodeSendTelemetryReport() {
+static void mnodeSendTelemetryReport() {
   char     buf[128] = {0};
   uint32_t ip = taosGetIpv4FromFqdn(TELEMETRY_SERVER);
   if (ip == 0xffffffff) {
-    dTrace("failed to get IP address of " TELEMETRY_SERVER ", reason:%s", strerror(errno));
+    mTrace("failed to get IP address of " TELEMETRY_SERVER ", reason:%s", strerror(errno));
     return;
   }
   SOCKET fd = taosOpenTcpClientSocket(ip, TELEMETRY_PORT, 0);
   if (fd < 0) {
-    dTrace("failed to create socket for telemetry, reason:%s", strerror(errno));
+    mTrace("failed to create socket for telemetry, reason:%s", strerror(errno));
     return;
   }
 
   char clusterId[TSDB_CLUSTER_ID_LEN] = {0};
-  dnodeGetClusterId(clusterId);
+  mnodeGetClusterId(clusterId);
 
   SBufferWriter bw = tbufInitWriter(NULL, false);
-  dnodeBeginObject(&bw);
-  dnodeAddStringField(&bw, "instanceId", clusterId);
-  dnodeAddIntField(&bw, "reportVersion", 1);
-  dnodeAddOsInfo(&bw);
-  dnodeAddCpuInfo(&bw);
-  dnodeAddMemoryInfo(&bw);
-  dnodeAddVersionInfo(&bw);
-  dnodeAddRuntimeInfo(&bw);
-  dnodeCloseObject(&bw);
+  mnodeBeginObject(&bw);
+  mnodeAddStringField(&bw, "instanceId", clusterId);
+  mnodeAddIntField(&bw, "reportVersion", 1);
+  mnodeAddOsInfo(&bw);
+  mnodeAddCpuInfo(&bw);
+  mnodeAddMemoryInfo(&bw);
+  mnodeAddVersionInfo(&bw);
+  mnodeAddRuntimeInfo(&bw);
+  mnodeCloseObject(&bw);
 
   const char* header =
       "POST /report HTTP/1.1\n"
@@ -235,18 +232,18 @@ static void dnodeSendTelemetryReport() {
 
   // read something to avoid nginx error 499
   if (taosReadSocket(fd, buf, 10) < 0) {
-    dTrace("failed to receive response since %s", strerror(errno));
+    mTrace("failed to receive response since %s", strerror(errno));
   }
 
   taosCloseSocket(fd);
 }
 
-static void* dnodeTelemThreadFp(void* param) {
+static void* mnodeTelemThreadFp(void* param) {
   struct timespec end = {0};
   clock_gettime(CLOCK_REALTIME, &end);
   end.tv_sec += 300;  // wait 5 minutes before send first report
 
-  setThreadName("dnode-telem");
+  setThreadName("mnode-telem");
 
   while (!tsTelem.exit) {
     int32_t         r = 0;
@@ -257,8 +254,8 @@ static void* dnodeTelemThreadFp(void* param) {
     if (r == 0) break;
     if (r != ETIMEDOUT) continue;
 
-    if (mnodeIsServing()) {
-      dnodeSendTelemetryReport();
+    if (mnodeGetStatus() == MN_STATUS_READY) {
+      mnodeSendTelemetryReport();
     }
     end.tv_sec += REPORT_INTERVAL;
   }
@@ -266,20 +263,20 @@ static void* dnodeTelemThreadFp(void* param) {
   return NULL;
 }
 
-static void dnodeGetEmail(char* filepath) {
+static void mnodeGetEmail(char* filepath) {
   int32_t fd = taosOpenFileRead(filepath);
   if (fd < 0) {
     return;
   }
 
   if (taosReadFile(fd, (void*)tsTelem.email, TSDB_FQDN_LEN) < 0) {
-    dError("failed to read %d bytes from file %s since %s", TSDB_FQDN_LEN, filepath, strerror(errno));
+    mError("failed to read %d bytes from file %s since %s", TSDB_FQDN_LEN, filepath, strerror(errno));
   }
 
   taosCloseFile(fd);
 }
 
-int32_t dnodeInitTelem() {
+int32_t mnodeInitTelem() {
   tsTelem.enable = tsEnableTelemetryReporting;
   if (!tsTelem.enable) return 0;
 
@@ -288,23 +285,23 @@ int32_t dnodeInitTelem() {
   pthread_cond_init(&tsTelem.cond, NULL);
   tsTelem.email[0] = 0;
 
-  dnodeGetEmail("/usr/local/taos/email");
+  mnodeGetEmail("/usr/local/taos/email");
 
   pthread_attr_t attr;
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
-  int32_t code = pthread_create(&tsTelem.thread, &attr, dnodeTelemThreadFp, NULL);
+  int32_t code = pthread_create(&tsTelem.thread, &attr, mnodeTelemThreadFp, NULL);
   pthread_attr_destroy(&attr);
   if (code != 0) {
-    dTrace("failed to create telemetry thread since :%s", strerror(code));
+    mTrace("failed to create telemetry thread since :%s", strerror(code));
   }
 
-  dInfo("dnode telemetry is initialized");
+  mInfo("mnode telemetry is initialized");
   return 0;
 }
 
-void dnodeCleanupTelem() {
+void mnodeCleanupTelem() {
   if (!tsTelem.enable) return;
 
   if (taosCheckPthreadValid(tsTelem.thread)) {

source/server/mnode/src/mnodeUser.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tkey.h"
+#include "tglobal.h"
+#include "mnodeSdb.h"
+
+static int32_t mnodeCreateDefaultUser(char *acct, char *user, char *pass) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  SUserObj userObj = {0};
+  tstrncpy(userObj.user, user, TSDB_USER_LEN);
+  tstrncpy(userObj.acct, acct, TSDB_USER_LEN);
+  taosEncryptPass((uint8_t *)pass, strlen(pass), userObj.pass);
+  userObj.createdTime = taosGetTimestampMs();
+  userObj.updateTime = taosGetTimestampMs();
+
+  if (strcmp(user, TSDB_DEFAULT_USER) == 0) {
+    userObj.rootAuth = 1;
+  }
+
+  sdbInsertRow(MN_SDB_USER, &userObj);
+}
+
+static void mnodeCreateDefaultUsers() {
+  mnodeCreateDefaultUser(TSDB_DEFAULT_USER, TSDB_DEFAULT_USER, TSDB_DEFAULT_PASS);
+  mnodeCreateDefaultUser(TSDB_DEFAULT_USER, "monitor", tsInternalPass);
+  mnodeCreateDefaultUser(TSDB_DEFAULT_USER, "_" TSDB_DEFAULT_USER, tsInternalPass);
+}
+
+int32_t mnodeEncodeUser(SUserObj *pUser, char *buf, int32_t maxLen) {
+  int32_t len = 0;
+  char   *base64 = base64_encode((const unsigned char *)pUser->pass, TSDB_KEY_LEN);
+
+  len += snprintf(buf + len, maxLen - len, "{\"type\":%d, ", MN_SDB_USER);
+  len += snprintf(buf + len, maxLen - len, "\"user\":\"%s\", ", pUser->user);
+  len += snprintf(buf + len, maxLen - len, "\"auth\":\"%24s\", ", base64);
+  len += snprintf(buf + len, maxLen - len, "\"acct\":\"%s\", ", pUser->acct);
+  len += snprintf(buf + len, maxLen - len, "\"createdTime\":\"%" PRIu64 "\", ", pUser->createdTime);
+  len += snprintf(buf + len, maxLen - len, "\"updateTime\":\"%" PRIu64 "\"}\n", pUser->updateTime);
+
+  free(base64);
+  return len;
+}
+
+SUserObj *mnodeDecodeUser(cJSON *root) {
+  int32_t   code = -1;
+  SUserObj *pUser = calloc(1, sizeof(SUserObj));
+
+  cJSON *user = cJSON_GetObjectItem(root, "user");
+  if (!user || user->type != cJSON_String) {
+    mError("failed to parse user since user not found");
+    goto DECODE_USER_OVER;
+  }
+  tstrncpy(pUser->user, user->valuestring, TSDB_USER_LEN);
+
+  if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
+    pUser->rootAuth = 1;
+  }
+
+  cJSON *pass = cJSON_GetObjectItem(root, "auth");
+  if (!pass || pass->type != cJSON_String) {
+    mError("user:%s, failed to parse since auth not found", pUser->user);
+    goto DECODE_USER_OVER;
+  }
+
+  int32_t outlen = 0;
+  char   *base64 = (char *)base64_decode(pass->valuestring, strlen(pass->valuestring), &outlen);
+  if (outlen != TSDB_KEY_LEN) {
+    mError("user:%s, failed to parse since invalid auth format", pUser->user);
+    free(base64);
+    goto DECODE_USER_OVER;
+  } else {
+    memcpy(pUser->pass, base64, outlen);
+    free(base64);
+  }
+
+  cJSON *acct = cJSON_GetObjectItem(root, "acct");
+  if (!acct || acct->type != cJSON_String) {
+    mError("user:%s, failed to parse since acct not found", pUser->user);
+    goto DECODE_USER_OVER;
+  }
+  tstrncpy(pUser->acct, acct->valuestring, TSDB_USER_LEN);
+
+  cJSON *createdTime = cJSON_GetObjectItem(root, "createdTime");
+  if (!createdTime || createdTime->type != cJSON_String) {
+    mError("user:%s, failed to parse since createdTime not found", pUser->user);
+    goto DECODE_USER_OVER;
+  }
+  pUser->createdTime = atol(createdTime->valuestring);
+
+  cJSON *updateTime = cJSON_GetObjectItem(root, "updateTime");
+  if (!updateTime || updateTime->type != cJSON_String) {
+    mError("user:%s, failed to parse since updateTime not found", pUser->user);
+    goto DECODE_USER_OVER;
+  }
+  pUser->updateTime = atol(updateTime->valuestring);
+
+  code = 0;
+  mTrace("user:%s, parse success", pUser->user);
+
+DECODE_USER_OVER:
+  if (code != 0) {
+    free(pUser);
+    pUser = NULL;
+  }
+  return pUser;
+}
+
+int32_t mnodeInitUser() {
+  sdbSetFp(MN_SDB_USER, MN_KEY_BINARY, mnodeCreateDefaultUsers, (SdbEncodeFp)mnodeEncodeUser,
+           (SdbDecodeFp)(mnodeDecodeUser), sizeof(SUserObj));
+  return 0;
+}
+
+void mnodeCleanupUser() {}
\ No newline at end of file

source/server/mnode/src/mnodeVgroup.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitVgroup() { return 0; }
+void    mnodeCleanupVgroup() {}
\ No newline at end of file

source/server/mnode/src/mnodeWorker.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tworker.h"
+#include "tglobal.h"
+#include "mnodeMnode.h"
+#include "mnodeSdb.h"
+#include "mnodeShow.h"
+#include "mnodeSync.h"
+#include "mnodeWorker.h"
+
+static struct {
+  SWorkerPool read;
+  SWorkerPool write;
+  SWorkerPool peerReq;
+  SWorkerPool peerRsp;
+  taos_queue  readQ;
+  taos_queue  writeQ;
+  taos_queue  peerReqQ;
+  taos_queue  peerRspQ;
+  int32_t (*writeMsgFp[TSDB_MSG_TYPE_MAX])(SMnMsg *);
+  int32_t (*readMsgFp[TSDB_MSG_TYPE_MAX])(SMnMsg *);
+  int32_t (*peerReqFp[TSDB_MSG_TYPE_MAX])(SMnMsg *);
+  void (*peerRspFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *);
+  void (*msgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *pMsg);
+} tsMworker = {0};
+
+static SMnMsg *mnodeInitMsg(SRpcMsg *pRpcMsg) {
+  int32_t    size = sizeof(SMnMsg) + pRpcMsg->contLen;
+  SMnMsg *pMsg = taosAllocateQitem(size);
+
+  pMsg->rpcMsg = *pRpcMsg;
+  pMsg->rpcMsg.pCont = pMsg->pCont;
+  pMsg->createdTime = taosGetTimestampSec();
+  memcpy(pMsg->pCont, pRpcMsg->pCont, pRpcMsg->contLen);
+
+  SRpcConnInfo connInfo = {0};
+  if (rpcGetConnInfo(pMsg->rpcMsg.handle, &connInfo) == 0) {
+    pMsg->pUser = sdbGetRow(MN_SDB_USER, connInfo.user);
+  }
+
+  if (pMsg->pUser == NULL) {
+    mError("can not get user from conn:%p", pMsg->rpcMsg.handle);
+    taosFreeQitem(pMsg);
+    return NULL;
+  }
+
+  return pMsg;
+}
+
+static void mnodeCleanupMsg(SMnMsg *pMsg) {
+  if (pMsg == NULL) return;
+  if (pMsg->rpcMsg.pCont != pMsg->pCont) {
+    tfree(pMsg->rpcMsg.pCont);
+  }
+
+  taosFreeQitem(pMsg);
+}
+
+static void mnodeDispatchToWriteQueue(SRpcMsg *pRpcMsg) {
+  if (mnodeGetStatus() != MN_STATUS_READY || tsMworker.writeQ == NULL) {
+    mnodeSendRedirectMsg(pRpcMsg, true);
+  } else {
+    SMnMsg *pMsg = mnodeInitMsg(pRpcMsg);
+    if (pMsg == NULL) {
+      SRpcMsg rpcRsp = {.handle = pRpcMsg->handle, .code = TSDB_CODE_MND_INVALID_USER};
+      rpcSendResponse(&rpcRsp);
+    } else {
+      mTrace("msg:%p, app:%p type:%s is put into wqueue", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
+      taosWriteQitem(tsMworker.writeQ, TAOS_QTYPE_RPC, pMsg);
+    }
+  }
+
+  rpcFreeCont(pRpcMsg->pCont);
+}
+
+void mnodeReDispatchToWriteQueue(SMnMsg *pMsg) {
+  if (mnodeGetStatus() != MN_STATUS_READY || tsMworker.writeQ == NULL) {
+    mnodeSendRedirectMsg(&pMsg->rpcMsg, true);
+    mnodeCleanupMsg(pMsg);
+  } else {
+    taosWriteQitem(tsMworker.writeQ, TAOS_QTYPE_RPC, pMsg);
+  }
+}
+
+static void mnodeDispatchToReadQueue(SRpcMsg *pRpcMsg) {
+  if (mnodeGetStatus() != MN_STATUS_READY || tsMworker.readQ == NULL) {
+    mnodeSendRedirectMsg(pRpcMsg, true);
+  } else {
+    SMnMsg *pMsg = mnodeInitMsg(pRpcMsg);
+    if (pMsg == NULL) {
+      SRpcMsg rpcRsp = {.handle = pRpcMsg->handle, .code = TSDB_CODE_MND_INVALID_USER};
+      rpcSendResponse(&rpcRsp);
+    } else {
+      mTrace("msg:%p, app:%p type:%s is put into rqueue", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
+      taosWriteQitem(tsMworker.readQ, TAOS_QTYPE_RPC, pMsg);
+    }
+  }
+
+  rpcFreeCont(pRpcMsg->pCont);
+}
+
+static void mnodeDispatchToPeerQueue(SRpcMsg *pRpcMsg) {
+  if (mnodeGetStatus() != MN_STATUS_READY || tsMworker.peerReqQ == NULL) {
+    mnodeSendRedirectMsg(pRpcMsg, false);
+  } else {
+    SMnMsg *pMsg = mnodeInitMsg(pRpcMsg);
+    if (pMsg == NULL) {
+      SRpcMsg rpcRsp = {.handle = pRpcMsg->handle, .code = TSDB_CODE_MND_INVALID_USER};
+      rpcSendResponse(&rpcRsp);
+    } else {
+      mTrace("msg:%p, app:%p type:%s is put into peer req queue", pMsg, pMsg->rpcMsg.ahandle,
+             taosMsg[pMsg->rpcMsg.msgType]);
+      taosWriteQitem(tsMworker.peerReqQ, TAOS_QTYPE_RPC, pMsg);
+    }
+  }
+
+  rpcFreeCont(pRpcMsg->pCont);
+}
+
+void mnodeDispatchToPeerRspQueue(SRpcMsg *pRpcMsg) {
+  SMnMsg *pMsg = mnodeInitMsg(pRpcMsg);
+  if (pMsg == NULL) {
+    SRpcMsg rpcRsp = {.handle = pRpcMsg->handle, .code = TSDB_CODE_MND_INVALID_USER};
+    rpcSendResponse(&rpcRsp);
+  } else {
+    mTrace("msg:%p, app:%p type:%s is put into peer rsp queue", pMsg, pMsg->rpcMsg.ahandle,
+           taosMsg[pMsg->rpcMsg.msgType]);
+    taosWriteQitem(tsMworker.peerRspQ, TAOS_QTYPE_RPC, pMsg);
+  }
+
+  // rpcFreeCont(pRpcMsg->pCont);
+}
+
+static void mnodeSendRpcRsp(void *ahandle, SMnMsg *pMsg, int32_t qtype, int32_t code) {
+  if (pMsg == NULL) return;
+  if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) return;
+  if (code == TSDB_CODE_MND_ACTION_NEED_REPROCESSED) {
+    mnodeReDispatchToWriteQueue(pMsg);
+    return;
+  }
+
+  SRpcMsg rpcRsp = {
+    .handle  = pMsg->rpcMsg.handle,
+    .pCont   = pMsg->rpcRsp.rsp,
+    .contLen = pMsg->rpcRsp.len,
+    .code    = code,
+  };
+
+  rpcSendResponse(&rpcRsp);
+  mnodeCleanupMsg(pMsg);
+}
+
+void mnodeSendRsp(SMnMsg *pMsg, int32_t code) { mnodeSendRpcRsp(NULL, pMsg, 0, code); }
+
+static void mnodeProcessPeerRspEnd(void *ahandle, SMnMsg *pMsg, int32_t qtype, int32_t code) {
+  mnodeCleanupMsg(pMsg);
+}
+
+static void mnodeInitMsgFp() {
+//   // peer req
+//   tsMworker.msgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = mnodeDispatchToPeerQueue;
+//   tsMworker.peerReqFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = mnodeProcessTableCfgMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = mnodeDispatchToPeerQueue;
+//   tsMworker.peerReqFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = mnodeProcessVnodeCfgMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_DM_AUTH] = mnodeDispatchToPeerQueue;
+//   tsMworker.peerReqFp[TSDB_MSG_TYPE_DM_AUTH] = mnodeProcessAuthMsg;
+//   // tsMworker.msgFp[TSDB_MSG_TYPE_DM_GRANT] = mnodeDispatchToPeerQueue;
+//   // tsMworker.peerReqFp[TSDB_MSG_TYPE_DM_GRANT] = grantProcessMsgInMgmt;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_DM_STATUS] = mnodeDispatchToPeerQueue;
+//   tsMworker.peerReqFp[TSDB_MSG_TYPE_DM_STATUS] = mnodeProcessDnodeStatusMsg;
+
+//   // peer rsp
+//   tsMworker.msgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP] = mnodeDispatchToPeerRspQueue;
+//   tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP] = mnodeProcessCfgDnodeMsgRsp;
+
+//   tsMworker.msgFp[TSDB_MSG_TYPE_MD_DROP_STABLE_RSP] = mnodeDispatchToPeerRspQueue;
+//   tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_DROP_STABLE_RSP] = mnodeProcessDropSuperTableRsp;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP] = mnodeDispatchToPeerRspQueue;
+//   tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP] = mnodeProcessCreateChildTableRsp;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_MD_DROP_TABLE_RSP] = mnodeDispatchToPeerRspQueue;
+//   tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_DROP_TABLE_RSP] = mnodeProcessDropChildTableRsp;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP] = mnodeDispatchToPeerRspQueue;
+//   tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP] = mnodeProcessAlterTableRsp;
+
+//   tsMworker.msgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP] = mnodeDispatchToPeerRspQueue;
+//   tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP] = mnodeProcessCreateVnodeRsp;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE_RSP] = mnodeDispatchToPeerRspQueue;
+//   tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_ALTER_VNODE_RSP] = mnodeProcessAlterVnodeRsp;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_MD_COMPACT_VNODE_RSP] = mnodeDispatchToPeerRspQueue;
+//   tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_COMPACT_VNODE_RSP] = mnodeProcessCompactVnodeRsp;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_MD_DROP_VNODE_RSP] = mnodeDispatchToPeerRspQueue;
+//   tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_DROP_VNODE_RSP] = mnodeProcessDropVnodeRsp;
+
+//   // read msg
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = mnodeDispatchToReadQueue;
+//   tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = mnodeProcessHeartBeatMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_CONNECT] = mnodeDispatchToReadQueue;
+//   tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_CONNECT] = mnodeProcessConnectMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_USE_DB] = mnodeDispatchToReadQueue;
+//   tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_USE_DB] = mnodeProcessUseMsg;
+
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_TABLE_META] = mnodeDispatchToReadQueue;
+//   tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_TABLE_META] = mnodeProcessTableMetaMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_TABLES_META] = mnodeDispatchToReadQueue;
+//   tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = mnodeProcessMultiTableMetaMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_STABLE_VGROUP] = mnodeDispatchToReadQueue;
+//   tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_STABLE_VGROUP] = mnodeProcessSuperTableVgroupMsg;
+
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_SHOW] = mnodeDispatchToReadQueue;
+//   tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_SHOW] = mnodeProcessShowMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = mnodeDispatchToReadQueue;
+//   tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = mnodeProcessRetrieveMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_RETRIEVE_FUNC] = mnodeDispatchToReadQueue;
+//   tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE_FUNC] = mnodeProcessRetrieveFuncReq;
+
+//   // tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = mnodeDispatchToWriteQueue;
+//   // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = acctProcessCreateAcctMsg;
+//   // tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT] = mnodeDispatchToWriteQueue;
+//   // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT] = acctProcessDropAcctMsg;
+//   // tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_ACCT] = mnodeDispatchToWriteQueue;
+//   // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_DROP_ACCT] = acctProcessAlterAcctMsg;
+
+//   // write msg
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = mnodeProcessCreateUserMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_USER] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_ALTER_USER] = mnodeProcessAlterUserMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_USER] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_DROP_USER] = mnodeProcessDropUserMsg;
+
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE] = mnodeProcessCreateDnodeMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = mnodeProcessDropDnodeMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE] = mnodeProcessCfgDnodeMsg;
+
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = mnodeProcessCreateDbMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = mnodeProcessAlterDbMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_DB] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_DROP_DB] = mnodeProcessDropDbMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_SYNC_DB] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_SYNC_DB] = mnodeProcessSyncDbMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_COMPACT_VNODE] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_COMPACT_VNODE] = mnodeProcessCompactMsg;
+
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_FUNCTION] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CREATE_FUNCTION] = mnodeProcessCreateFuncMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_FUNCTION] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_DROP_FUNCTION] = mnodeProcessDropFuncMsg;
+
+//   // tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_TP] = mnodeDispatchToWriteQueue;
+//   // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_CREATE_TP] = tpProcessCreateTpMsg;
+//   // tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_TP] = mnodeDispatchToWriteQueue;
+//   // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_DROP_TP] = tpProcessAlterTpMsg;
+//   // tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_TP] = mnodeDispatchToWriteQueue;
+//   // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_ALTER_TP] = tpProcessDropTpMsg;
+
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE] = mnodeProcessCreateTableMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_TABLE] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE] = mnodeProcessDropTableMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = mnodeProcessAlterTableMsg;
+
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM] = NULL;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_KILL_QUERY] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY] = mnodeProcessKillQueryMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = mnodeProcessKillStreamMsg;
+//   tsMworker.msgFp[TSDB_MSG_TYPE_CM_KILL_CONN] = mnodeDispatchToWriteQueue;
+//   tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN] = mnodeProcessKillConnectionMsg;
+}
+
+static int32_t mnodeProcessWriteReq(void *unused, SMnMsg *pMsg, int32_t qtype) {
+  int32_t msgType = pMsg->rpcMsg.msgType;
+  void *ahandle = pMsg->rpcMsg.ahandle;
+
+  if (pMsg->rpcMsg.pCont == NULL) {
+    mError("msg:%p, app:%p type:%s content is null", pMsg, ahandle, taosMsg[msgType]);
+    return TSDB_CODE_MND_INVALID_MSG_LEN;
+  }
+
+  if (!mnodeIsMaster()) {
+    SMnRsp *rpcRsp = &pMsg->rpcRsp;
+    SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
+    mnodeGetMnodeEpSetForShell(epSet, true);
+    rpcRsp->rsp = epSet;
+    rpcRsp->len = sizeof(SRpcEpSet);
+
+    mDebug("msg:%p, app:%p type:%s in write queue, is redirected, numOfEps:%d inUse:%d", pMsg, ahandle,
+           taosMsg[msgType], epSet->numOfEps, epSet->inUse);
+
+    return TSDB_CODE_RPC_REDIRECT;
+  }
+
+  if (tsMworker.writeMsgFp[msgType] == NULL) {
+    mError("msg:%p, app:%p type:%s not processed", pMsg, ahandle, taosMsg[msgType]);
+    return TSDB_CODE_MND_MSG_NOT_PROCESSED;
+  }
+
+  return (*tsMworker.writeMsgFp[msgType])(pMsg);
+}
+
+static int32_t mnodeProcessReadReq(void* unused, SMnMsg *pMsg, int32_t qtype) {
+  int32_t msgType = pMsg->rpcMsg.msgType;
+  void *ahandle = pMsg->rpcMsg.ahandle;
+
+  if (pMsg->rpcMsg.pCont == NULL) {
+    mError("msg:%p, app:%p type:%s in mread queue, content is null", pMsg, ahandle, taosMsg[msgType]);
+    return TSDB_CODE_MND_INVALID_MSG_LEN;
+  }
+
+  if (!mnodeIsMaster()) {
+    SMnRsp *rpcRsp = &pMsg->rpcRsp;
+    SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
+    if (!epSet) {
+      return TSDB_CODE_MND_OUT_OF_MEMORY;
+    }
+    mnodeGetMnodeEpSetForShell(epSet, true);
+    rpcRsp->rsp = epSet;
+    rpcRsp->len = sizeof(SRpcEpSet);
+
+    mDebug("msg:%p, app:%p type:%s in mread queue is redirected, numOfEps:%d inUse:%d", pMsg, ahandle, taosMsg[msgType],
+           epSet->numOfEps, epSet->inUse);
+    return TSDB_CODE_RPC_REDIRECT;
+  }
+
+  if (tsMworker.readMsgFp[msgType] == NULL) {
+    mError("msg:%p, app:%p type:%s in mread queue, not processed", pMsg, ahandle, taosMsg[msgType]);
+    return TSDB_CODE_MND_MSG_NOT_PROCESSED;
+  }
+
+  mTrace("msg:%p, app:%p type:%s will be processed in mread queue", pMsg, ahandle, taosMsg[msgType]);
+  return (*tsMworker.readMsgFp[msgType])(pMsg);
+}
+
+static int32_t mnodeProcessPeerReq(void *unused, SMnMsg *pMsg, int32_t qtype) {
+  int32_t msgType = pMsg->rpcMsg.msgType;
+  void *  ahandle = pMsg->rpcMsg.ahandle;
+
+  if (pMsg->rpcMsg.pCont == NULL) {
+    mError("msg:%p, ahandle:%p type:%s in mpeer queue, content is null", pMsg, ahandle, taosMsg[msgType]);
+    return TSDB_CODE_MND_INVALID_MSG_LEN;
+  }
+
+  if (!mnodeIsMaster()) {
+    SMnRsp *rpcRsp = &pMsg->rpcRsp;
+    SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
+    mnodeGetMnodeEpSetForPeer(epSet, true);
+    rpcRsp->rsp = epSet;
+    rpcRsp->len = sizeof(SRpcEpSet);
+
+    mDebug("msg:%p, ahandle:%p type:%s in mpeer queue is redirected, numOfEps:%d inUse:%d", pMsg, ahandle,
+           taosMsg[msgType], epSet->numOfEps, epSet->inUse);
+
+    return TSDB_CODE_RPC_REDIRECT;
+  }
+
+  if (tsMworker.peerReqFp[msgType] == NULL) {
+    mError("msg:%p, ahandle:%p type:%s in mpeer queue, not processed", pMsg, ahandle, taosMsg[msgType]);
+    return TSDB_CODE_MND_MSG_NOT_PROCESSED;
+  }
+
+  return (*tsMworker.peerReqFp[msgType])(pMsg);
+}
+
+static int32_t mnodeProcessPeerRsp(void *ahandle, SMnMsg *pMsg, int32_t qtype) {
+  int32_t  msgType = pMsg->rpcMsg.msgType;
+  SRpcMsg *pRpcMsg = &pMsg->rpcMsg;
+
+  if (!mnodeIsMaster()) {
+    mError("msg:%p, ahandle:%p type:%s not processed for not master", pRpcMsg, pRpcMsg->ahandle, taosMsg[msgType]);
+    return 0;
+  }
+
+  if (tsMworker.peerRspFp[msgType]) {
+    (*tsMworker.peerRspFp[msgType])(pRpcMsg);
+  } else {
+    mError("msg:%p, ahandle:%p type:%s is not processed", pRpcMsg, pRpcMsg->ahandle, taosMsg[msgType]);
+  }
+
+  return 0;
+}
+
+int32_t mnodeInitWorker() {
+  mnodeInitMsgFp();
+
+  SWorkerPool *pPool = &tsMworker.write;
+  pPool->name = "mnode-write";
+  pPool->startFp = (ProcessStartFp)mnodeProcessWriteReq;
+  pPool->endFp = (ProcessEndFp)mnodeSendRpcRsp;
+  pPool->min = 1;
+  pPool->max = 1;
+  if (tWorkerInit(pPool) != 0) {
+    return TSDB_CODE_MND_OUT_OF_MEMORY;
+  } else {
+    tsMworker.writeQ = tWorkerAllocQueue(pPool, NULL);
+  }
+
+  pPool = &tsMworker.read;
+  pPool->name = "mnode-read";
+  pPool->startFp = (ProcessStartFp)mnodeProcessReadReq;
+  pPool->endFp = (ProcessEndFp)mnodeSendRpcRsp;
+  pPool->min = 2;
+  pPool->max = (int32_t)(tsNumOfCores * tsNumOfThreadsPerCore / 2);
+  pPool->max = MAX(2, pPool->max);
+  pPool->max = MIN(4, pPool->max);
+  if (tWorkerInit(pPool) != 0) {
+    return TSDB_CODE_MND_OUT_OF_MEMORY;
+  } else {
+    tsMworker.readQ = tWorkerAllocQueue(pPool, NULL);
+  }
+
+  pPool = &tsMworker.peerReq;
+  pPool->name = "mnode-peer-req";
+  pPool->startFp = (ProcessStartFp)mnodeProcessPeerReq;
+  pPool->endFp = (ProcessEndFp)mnodeSendRpcRsp;
+  pPool->min = 1;
+  pPool->max = 1;
+  if (tWorkerInit(pPool) != 0) {
+    return TSDB_CODE_MND_OUT_OF_MEMORY;
+  } else {
+    tsMworker.peerReqQ = tWorkerAllocQueue(pPool, NULL);
+  }
+
+  pPool = &tsMworker.peerRsp;
+  pPool->name = "mnode-peer-rsp";
+  pPool->startFp = (ProcessStartFp)mnodeProcessPeerRsp;
+  pPool->endFp = (ProcessEndFp)mnodeProcessPeerRspEnd;
+  pPool->min = 1;
+  pPool->max = 1;
+  if (tWorkerInit(pPool) != 0) {
+    return TSDB_CODE_MND_OUT_OF_MEMORY;
+  } else {
+    tsMworker.peerRspQ = tWorkerAllocQueue(pPool, NULL);
+  }
+
+  mInfo("mnode worker is initialized");
+  return 0;
+}
+
+void mnodeCleanupWorker() {
+  tWorkerFreeQueue(&tsMworker.write, tsMworker.writeQ);
+  tWorkerCleanup(&tsMworker.write);
+  tsMworker.writeQ = NULL;
+
+  tWorkerFreeQueue(&tsMworker.read, tsMworker.readQ);
+  tWorkerCleanup(&tsMworker.read);
+  tsMworker.readQ = NULL;
+
+  tWorkerFreeQueue(&tsMworker.peerReq, tsMworker.peerReqQ);
+  tWorkerCleanup(&tsMworker.peerReq);
+  tsMworker.peerReqQ = NULL;
+
+  tWorkerFreeQueue(&tsMworker.peerRsp, tsMworker.peerRspQ);
+  tWorkerCleanup(&tsMworker.peerRsp);
+  tsMworker.peerRspQ = NULL;
+
+  mInfo("mnode worker is closed");
+}
+
+void mnodeProcessMsg(SRpcMsg *pMsg) {
+  if (tsMworker.msgFp[pMsg->msgType]) {
+    (*tsMworker.msgFp[pMsg->msgType])(pMsg);
+  } else {
+    assert(0);
+  }
+}

source/server/mnode/src/mondeInt.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tglobal.h"
+#include "tstep.h"
+#include "mnodeAcct.h"
+#include "mnodeAuth.h"
+#include "mnodeBalance.h"
+#include "mnodeCluster.h"
+#include "mnodeDb.h"
+#include "mnodeDnode.h"
+#include "mnodeFunc.h"
+#include "mnodeMnode.h"
+#include "mnodeOper.h"
+#include "mnodeProfile.h"
+#include "mnodeSdb.h"
+#include "mnodeShow.h"
+#include "mnodeStable.h"
+#include "mnodeSync.h"
+#include "mnodeUser.h"
+#include "mnodeVgroup.h"
+#include "mnodeWorker.h"
+#include "mnodeTelem.h"
+
+static struct {
+  int32_t  state;
+  int32_t  dnodeId;
+  char     clusterId[TSDB_CLUSTER_ID_LEN];
+  tmr_h    timer;
+  SMnodeFp fp;
+  SSteps * steps1;
+  SSteps * steps2;
+} tsMint;
+
+tmr_h mnodeGetTimer() { return tsMint.timer; }
+
+int32_t mnodeGetDnodeId() { return tsMint.dnodeId; }
+
+char *mnodeGetClusterId() { return tsMint.clusterId; }
+
+EMnStatus mnodeGetStatus() { return tsMint.state; }
+
+void mnodeSendMsgToDnode(struct SRpcEpSet *epSet, struct SRpcMsg *rpcMsg) {
+  (*tsMint.fp.SendMsgToDnode)(epSet, rpcMsg);
+}
+
+void mnodeSendMsgToMnode(struct SRpcMsg *rpcMsg) { return (*tsMint.fp.SendMsgToMnode)(rpcMsg); }
+
+void mnodeSendRedirectMsg(struct SRpcMsg *rpcMsg, bool forShell) { (*tsMint.fp.SendRedirectMsg)(rpcMsg, forShell); }
+
+void mnodeGetDnodeEp(int32_t dnodeId, char *ep, char *fqdn, uint16_t *port) {
+  (*tsMint.fp.GetDnodeEp)(dnodeId, ep, fqdn, port);
+}
+
+int32_t mnodeGetStatistics(SMnodeStat *stat) { return 0; }
+
+static int32_t mnodeSetPara(SMnodePara para) {
+  tsMint.fp = para.fp;
+  tsMint.dnodeId = para.dnodeId;
+  strncpy(tsMint.clusterId, para.clusterId, TSDB_CLUSTER_ID_LEN);
+
+  if (tsMint.fp.SendMsgToDnode == NULL) return -1;
+  if (tsMint.fp.SendMsgToMnode == NULL) return -1;
+  if (tsMint.fp.SendRedirectMsg == NULL) return -1;
+  if (tsMint.dnodeId < 0) return -1;
+
+  return 0;
+}
+
+static int32_t mnodeInitTimer() {
+  if (tsMint.timer == NULL) {
+    tsMint.timer = taosTmrInit(tsMaxShellConns, 200, 3600000, "MND");
+  }
+
+  return 0;
+}
+
+static void mnodeCleanupTimer() {
+  if (tsMint.timer != NULL) {
+    taosTmrCleanUp(tsMint.timer);
+    tsMint.timer = NULL;
+  }
+}
+
+static int32_t mnodeInitStep1() {
+  struct SSteps *steps = taosStepInit(16, NULL);
+  if (steps == NULL) return -1;
+
+  taosStepAdd(steps, "mnode-sdb", sdbInit, sdbCleanup);
+  taosStepAdd(steps, "mnode-cluster", mnodeInitCluster, mnodeCleanupCluster);
+  taosStepAdd(steps, "mnode-dnode", mnodeInitDnode, mnodeCleanupDnode);
+  taosStepAdd(steps, "mnode-mnode", mnodeInitMnode, mnodeCleanupMnode);
+  taosStepAdd(steps, "mnode-acct", mnodeInitAcct, mnodeCleanupAcct);
+  taosStepAdd(steps, "mnode-auth", mnodeInitAuth, mnodeCleanupAuth);
+  taosStepAdd(steps, "mnode-user", mnodeInitUser, mnodeCleanupUser);
+  taosStepAdd(steps, "mnode-db", mnodeInitDb, mnodeCleanupDb);
+  taosStepAdd(steps, "mnode-vgroup", mnodeInitVgroup, mnodeCleanupVgroup);
+  taosStepAdd(steps, "mnode-stable", mnodeInitStable, mnodeCleanupStable);
+  taosStepAdd(steps, "mnode-func", mnodeInitFunc, mnodeCleanupFunc);
+  taosStepAdd(steps, "mnode-oper", mnodeInitOper, mnodeCleanupOper);
+
+  tsMint.steps1 = steps;
+  return taosStepExec(tsMint.steps1);
+}
+
+static int32_t mnodeInitStep2() {
+  struct SSteps *steps = taosStepInit(12, NULL);
+  if (steps == NULL) return -1;
+
+  taosStepAdd(steps, "mnode-timer", mnodeInitTimer, NULL);
+  taosStepAdd(steps, "mnode-worker", mnodeInitWorker, NULL);
+  taosStepAdd(steps, "mnode-balance", mnodeInitBalance, mnodeCleanupBalance);
+  taosStepAdd(steps, "mnode-profile", mnodeInitProfile, mnodeCleanupProfile);
+  taosStepAdd(steps, "mnode-show", mnodeInitShow, mnodeCleanUpShow);
+  taosStepAdd(steps, "mnode-sync", mnodeInitSync, mnodeCleanUpSync);
+  taosStepAdd(steps, "mnode-worker", NULL, mnodeCleanupWorker);
+  taosStepAdd(steps, "mnode-telem", mnodeInitTelem, mnodeCleanupTelem);
+  taosStepAdd(steps, "mnode-timer", NULL, mnodeCleanupTimer);
+
+  tsMint.steps2 = steps;
+  return taosStepExec(tsMint.steps2);
+}
+
+static void mnodeCleanupStep1() { taosStepCleanup(tsMint.steps1); }
+
+static void mnodeCleanupStep2() { taosStepCleanup(tsMint.steps2); }
+
+static bool mnodeNeedDeploy() {
+  if (tsMint.dnodeId > 0) return false;
+  if (tsMint.clusterId[0] != 0) return false;
+  if (strcmp(tsFirst, tsLocalEp) != 0) return false;
+  return true;
+}
+
+int32_t mnodeDeploy() {
+  if (tsMint.state != MN_STATUS_UNINIT) {
+    mError("failed to deploy mnode since its deployed");
+    return 0;
+  } else {
+    tsMint.state = MN_STATUS_INIT;
+  }
+
+  if (tsMint.dnodeId <= 0 || tsMint.clusterId[0] == 0) {
+    mError("failed to deploy mnode since cluster not ready");
+    return TSDB_CODE_MND_NOT_READY;
+  }
+
+  mInfo("starting to deploy mnode");
+
+  int32_t code = mnodeInitStep1();
+  if (code != 0) {
+    mError("failed to deploy mnode since init step1 error");
+    tsMint.state = MN_STATUS_UNINIT;
+    return TSDB_CODE_MND_SDB_ERROR;
+  }
+
+  code = mnodeInitStep2();
+  if (code != 0) {
+    mnodeCleanupStep1();
+    mError("failed to deploy mnode since init step2 error");
+    tsMint.state = MN_STATUS_UNINIT;
+    return TSDB_CODE_MND_SDB_ERROR;
+  }
+
+  mDebug("mnode is deployed and waiting for raft to confirm");
+  tsMint.state = MN_STATUS_READY;
+  return 0;
+}
+
+void mnodeUnDeploy() {
+  sdbUnDeploy();
+  mnodeCleanup();
+}
+
+int32_t mnodeInit(SMnodePara para) {
+  mDebugFlag = 207;
+  if (tsMint.state != MN_STATUS_UNINIT) {
+    return 0;
+  } else {
+    tsMint.state = MN_STATUS_INIT;
+  }
+
+  mInfo("starting to initialize mnode ...");
+
+  int32_t code = mnodeSetPara(para);
+  if (code != 0) {
+    tsMint.state = MN_STATUS_UNINIT;
+    return code;
+  }
+
+  code = mnodeInitStep1();
+  if (code != 0) {
+    tsMint.state = MN_STATUS_UNINIT;
+    return -1;
+  }
+
+  code = sdbRead();
+  if (code != 0) {
+    if (mnodeNeedDeploy()) {
+      code = sdbDeploy();
+      if (code != 0) {
+        mnodeCleanupStep1();
+        tsMint.state = MN_STATUS_UNINIT;
+        return -1;
+      }
+    } else {
+      mnodeCleanupStep1();
+      tsMint.state = MN_STATUS_UNINIT;
+      return -1;
+    }
+  }
+
+  code = mnodeInitStep2();
+  if (code != 0) {
+    mnodeCleanupStep1();
+    tsMint.state = MN_STATUS_UNINIT;
+    return -1;
+  }
+
+  tsMint.state = MN_STATUS_READY;
+  mInfo("mnode is initialized successfully");
+  return 0;
+}
+
+void mnodeCleanup() {
+  if (tsMint.state != MN_STATUS_UNINIT && tsMint.state != MN_STATUS_CLOSING) {
+    mInfo("starting to clean up mnode");
+    tsMint.state = MN_STATUS_CLOSING;
+
+    mnodeCleanupStep2();
+    mnodeCleanupStep1();
+
+    tsMint.state = MN_STATUS_UNINIT;
+    mInfo("mnode is cleaned up");
+  }
+}

source/server/vnode/src/vnodeReadMsg.c.orig

+/*
+ * 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 "tglobal.h"
+// #include "query.h"
+#include "vnodeStatus.h"
+#include "vnodeRead.h"
+#include "vnodeReadMsg.h"
+
+#if 0
+// notify connection(handle) that current qhandle is created, if current connection from
+// client is broken, the query needs to be killed immediately.
+static int32_t vnodeNotifyCurrentQhandle(void *handle, uint64_t qId, void *qhandle, int32_t vgId) {
+  SRetrieveTableMsg *pMsg = rpcMallocCont(sizeof(SRetrieveTableMsg));
+  pMsg->qId = htobe64(qId);
+  pMsg->header.vgId = htonl(vgId);
+  pMsg->header.contLen = htonl(sizeof(SRetrieveTableMsg));
+
+  vTrace("QInfo:0x%" PRIx64 "-%p register qhandle to connect:%p", qId, qhandle, handle);
+  return rpcReportProgress(handle, (char *)pMsg, sizeof(SRetrieveTableMsg));
+}
+
+/**
+ * @param pRet         response message object
+ * @param pVnode       the vnode object
+ * @param handle       qhandle for executing query
+ * @param freeHandle   free qhandle or not
+ * @param ahandle      sqlObj address at client side
+ * @return
+ */
+static int32_t vnodeDumpQueryResult(SVnRsp *pRet, void *pVnode, uint64_t qId, void **handle, bool *freeHandle,
+                                    void *ahandle) {
+  bool continueExec = false;
+
+  int32_t code = TSDB_CODE_SUCCESS;
+  if ((code = qDumpRetrieveResult(*handle, (SRetrieveTableRsp **)&pRet->rsp, &pRet->len, &continueExec)) ==
+      TSDB_CODE_SUCCESS) {
+    if (continueExec) {
+      *freeHandle = false;
+      code = vnodeReputPutToRQueue(pVnode, handle, ahandle);
+      if (code != TSDB_CODE_SUCCESS) {
+        *freeHandle = true;
+        return code;
+      } else {
+        pRet->qhandle = *handle;
+      }
+    } else {
+      *freeHandle = true;
+      vTrace("QInfo:0x%" PRIx64 "-%p exec completed, free handle:%d", qId, *handle, *freeHandle);
+    }
+  } else {
+    SRetrieveTableRsp *pRsp = (SRetrieveTableRsp *)rpcMallocCont(sizeof(SRetrieveTableRsp));
+    memset(pRsp, 0, sizeof(SRetrieveTableRsp));
+    pRsp->completed = true;
+
+    pRet->rsp = pRsp;
+    pRet->len = sizeof(SRetrieveTableRsp);
+    *freeHandle = true;
+  }
+
+  return code;
+}
+
+static void vnodeBuildNoResultQueryRsp(SVnRsp *pRet) {
+  pRet->rsp = (SRetrieveTableRsp *)rpcMallocCont(sizeof(SRetrieveTableRsp));
+  pRet->len = sizeof(SRetrieveTableRsp);
+
+  memset(pRet->rsp, 0, sizeof(SRetrieveTableRsp));
+  SRetrieveTableRsp *pRsp = pRet->rsp;
+
+  pRsp->completed = true;
+}
+#endif
+
+int32_t vnodeProcessQueryMsg(SVnode *pVnode, SReadMsg *pRead) {
+#if 0  
+  void *   pCont = pRead->pCont;
+  int32_t  contLen = pRead->contLen;
+  SVnRsp *pRet = &pRead->rspRet;
+
+  SQueryTableMsg *pQueryTableMsg = (SQueryTableMsg *)pCont;
+  memset(pRet, 0, sizeof(SVnRsp));
+
+  // qHandle needs to be freed correctly
+  if (pRead->code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
+    vError("error rpc msg in query, %s", tstrerror(pRead->code));
+  }
+
+  int32_t code = TSDB_CODE_SUCCESS;
+  void ** handle = NULL;
+
+  if (contLen != 0) {
+    qinfo_t  pQInfo = NULL;
+    uint64_t qId = genQueryId();
+    code = qCreateQueryInfo(pVnode->tsdb, pVnode->vgId, pQueryTableMsg, &pQInfo, qId);
+
+    SQueryTableRsp *pRsp = (SQueryTableRsp *)rpcMallocCont(sizeof(SQueryTableRsp));
+    pRsp->code = code;
+    pRsp->qId = 0;
+
+    pRet->len = sizeof(SQueryTableRsp);
+    pRet->rsp = pRsp;
+    int32_t vgId = pVnode->vgId;
+
+    // current connect is broken
+    if (code == TSDB_CODE_SUCCESS) {
+      handle = qRegisterQInfo(pVnode->qMgmt, qId, pQInfo);
+      if (handle == NULL) {  // failed to register qhandle
+        pRsp->code = terrno;
+        terrno = 0;
+
+        vError("vgId:%d, QInfo:0x%" PRIx64 "-%p register qhandle failed, return to app, code:%s,", pVnode->vgId, qId,
+               (void *)pQInfo, tstrerror(pRsp->code));
+        qDestroyQueryInfo(pQInfo);  // destroy it directly
+        return pRsp->code;
+      } else {
+        assert(*handle == pQInfo);
+        pRsp->qId = htobe64(qId);
+      }
+
+      if (handle != NULL &&
+          vnodeNotifyCurrentQhandle(pRead->rpcHandle, qId, *handle, pVnode->vgId) != TSDB_CODE_SUCCESS) {
+        vError("vgId:%d, QInfo:0x%" PRIx64 "-%p, query discarded since link is broken, %p", pVnode->vgId, qId, *handle,
+               pRead->rpcHandle);
+
+        pRsp->code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
+        qReleaseQInfo(pVnode->qMgmt, (void **)&handle, true);
+        return pRsp->code;
+      }
+
+    } else {
+      assert(pQInfo == NULL);
+    }
+
+    if (handle != NULL) {
+      vTrace("vgId:%d, QInfo:0x%" PRIx64 "-%p, query msg disposed, create qhandle and returns to app", vgId, qId,
+             *handle);
+      code = vnodeReputPutToRQueue(pVnode, handle, pRead->rpcHandle);
+      if (code != TSDB_CODE_SUCCESS) {
+        pRsp->code = code;
+        qReleaseQInfo(pVnode->qMgmt, (void **)&handle, true);
+        return pRsp->code;
+      }
+    }
+
+    int32_t remain = atomic_add_fetch_32(&pVnode->numOfExistQHandle, 1);
+    vTrace("vgId:%d, new qhandle created, total qhandle:%d", pVnode->vgId, remain);
+  } else {
+    assert(pCont != NULL);
+    void **  qhandle = (void **)pRead->qhandle;
+    uint64_t qId = 0;
+
+    vTrace("vgId:%d, QInfo:%p, continues to exec query", pVnode->vgId, *qhandle);
+
+    // In the retrieve blocking model, only 50% CPU will be used in query processing
+    if (tsRetrieveBlockingModel) {
+      qTableQuery(*qhandle, &qId);  // do execute query
+      qReleaseQInfo(pVnode->qMgmt, (void **)&qhandle, false);
+    } else {
+      bool freehandle = false;
+      bool buildRes = qTableQuery(*qhandle, &qId);  // do execute query
+
+      // build query rsp, the retrieve request has reached here already
+      if (buildRes) {
+        // update the connection info according to the retrieve connection
+        pRead->rpcHandle = qGetResultRetrieveMsg(*qhandle);
+        assert(pRead->rpcHandle != NULL);
+
+        vTrace("vgId:%d, QInfo:%p, start to build retrieval rsp after query paused, %p", pVnode->vgId, *qhandle,
+               pRead->rpcHandle);
+
+        // set the real rsp error code
+        pRead->code = vnodeDumpQueryResult(&pRead->rspRet, pVnode, qId, qhandle, &freehandle, pRead->rpcHandle);
+
+        // NOTE: set return code to be TSDB_CODE_QRY_HAS_RSP to notify dnode to return msg to client
+        code = TSDB_CODE_QRY_HAS_RSP;
+      } else {
+        // void *h1 = qGetResultRetrieveMsg(*qhandle);
+
+        /* remove this assert, one possible case that will cause h1 not NULL: query thread unlock pQInfo->lock, and then
+         * FETCH thread execute twice before query thread reach here */
+        // assert(h1 == NULL);
+
+        freehandle = qQueryCompleted(*qhandle);
+      }
+
+      // NOTE: if the qhandle is not put into vread queue or query is completed, free the qhandle.
+      // If the building of result is not required, simply free it. Otherwise, mandatorily free the qhandle
+      if (freehandle || (!buildRes)) {
+        if (freehandle) {
+          int32_t remain = atomic_sub_fetch_32(&pVnode->numOfExistQHandle, 1);
+          vTrace("vgId:%d, QInfo:%p, start to free qhandle, remain qhandle:%d", pVnode->vgId, *qhandle, remain);
+        }
+
+        qReleaseQInfo(pVnode->qMgmt, (void **)&qhandle, freehandle);
+      }
+    }
+  }
+
+  return code;
+#endif
+  return 0;  
+}
+
+//mq related
+<<<<<<< HEAD
+int32_t vnodeProcessConsumeMsg(SVnode *pVnode, SReadMsg *pRead) {
+  //parse message and optionally move offset
+  void* pMsg = pRead->pCont;
+  tmqConsumeReq *pConsumeMsg = (tmqConsumeReq*) pMsg;
+  tmqMsgHead msgHead = pConsumeMsg->head;
+  //extract head
+  STQ *pTq = pVnode->pTQ;
+  tqGroupHandle *pHandle = tqFindGHandleBycId(pTq, msgHead.clientId);
+  //return msg if offset not moved
+  if(pConsumeMsg->commitOffset == pHandle->consumeOffset) {
+    //return msg
+    return 0;
+  }
+  //or move offset
+  tqMoveOffsetToNext(pHandle);
+  //fetch or register context
+  tqFetchMsg(pHandle, pRead);
+  //judge mode, tail read or catch up read
+  //launch new query
+  return 0;
+}
+
+int32_t vnodeProcessTqQueryMsg(SVnode *pVnode, SReadMsg *pRead) {
+  //get operator tree from tq data structure
+  //execute operator tree
+  //put data into ringbuffer
+  //unref memory
+=======
+int32_t vnodeProcessConsumeMsg(SVnode *pVnode, SReadMsg *pRead){
+  return 0;
+}
+int32_t vnodeProcessTqQueryMsg(SVnode *pVnode, SReadMsg *pRead) {
+>>>>>>> 3.0
+  return 0;
+}
+//mq related end
+
+int32_t vnodeProcessFetchMsg(SVnode *pVnode, SReadMsg *pRead) {
+#if 0  
+  void *   pCont = pRead->pCont;
+  SVnRsp *pRet = &pRead->rspRet;
+
+  SRetrieveTableMsg *pRetrieve = pCont;
+  pRetrieve->free = htons(pRetrieve->free);
+  pRetrieve->qId = htobe64(pRetrieve->qId);
+
+  vTrace("vgId:%d, qId:0x%" PRIx64 ", retrieve msg is disposed, free:%d, conn:%p", pVnode->vgId, pRetrieve->qId,
+         pRetrieve->free, pRead->rpcHandle);
+
+  memset(pRet, 0, sizeof(SVnRsp));
+
+  terrno = TSDB_CODE_SUCCESS;
+  int32_t code = TSDB_CODE_SUCCESS;
+  void ** handle = qAcquireQInfo(pVnode->qMgmt, pRetrieve->qId);
+  if (handle == NULL) {
+    code = terrno;
+    terrno = TSDB_CODE_SUCCESS;
+  } else if (!checkQIdEqual(*handle, pRetrieve->qId)) {
+    code = TSDB_CODE_QRY_INVALID_QHANDLE;
+  }
+
+  if (code != TSDB_CODE_SUCCESS) {
+    vError("vgId:%d, invalid qId in retrieving result, code:%s, QInfo:%" PRIu64, pVnode->vgId, tstrerror(code),
+           pRetrieve->qId);
+    vnodeBuildNoResultQueryRsp(pRet);
+    return code;
+  }
+
+  // kill current query and free corresponding resources.
+  if (pRetrieve->free == 1) {
+    int32_t remain = atomic_sub_fetch_32(&pVnode->numOfExistQHandle, 1);
+    vWarn("vgId:%d, QInfo:%" PRIx64 "-%p, retrieve msg received to kill query and free qhandle, remain qhandle:%d",
+          pVnode->vgId, pRetrieve->qId, *handle, remain);
+
+    qKillQuery(*handle);
+    qReleaseQInfo(pVnode->qMgmt, (void **)&handle, true);
+
+    vnodeBuildNoResultQueryRsp(pRet);
+    code = TSDB_CODE_TSC_QUERY_CANCELLED;
+    return code;
+  }
+
+  // register the qhandle to connect to quit query immediate if connection is broken
+  if (vnodeNotifyCurrentQhandle(pRead->rpcHandle, pRetrieve->qId, *handle, pVnode->vgId) != TSDB_CODE_SUCCESS) {
+    int32_t remain = atomic_sub_fetch_32(&pVnode->numOfExistQHandle, 1);
+    vError("vgId:%d, QInfo:%" PRIu64 "-%p, retrieve discarded since link is broken, conn:%p, remain qhandle:%d",
+           pVnode->vgId, pRetrieve->qhandle, *handle, pRead->rpcHandle, remain);
+
+    code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
+    qKillQuery(*handle);
+    qReleaseQInfo(pVnode->qMgmt, (void **)&handle, true);
+    return code;
+  }
+
+  bool freeHandle = true;
+  bool buildRes = false;
+
+  code = qRetrieveQueryResultInfo(*handle, &buildRes, pRead->rpcHandle);
+  if (code != TSDB_CODE_SUCCESS) {
+    // TODO handle malloc failure
+    pRet->rsp = (SRetrieveTableRsp *)rpcMallocCont(sizeof(SRetrieveTableRsp));
+    pRet->len = sizeof(SRetrieveTableRsp);
+    memset(pRet->rsp, 0, sizeof(SRetrieveTableRsp));
+    freeHandle = true;
+  } else {  // result is not ready, return immediately
+    // Only affects the non-blocking model
+    if (!tsRetrieveBlockingModel) {
+      if (!buildRes) {
+        assert(pRead->rpcHandle != NULL);
+        qReleaseQInfo(pVnode->qMgmt, (void **)&handle, false);
+        return TSDB_CODE_QRY_NOT_READY;
+      }
+    }
+
+    // ahandle is the sqlObj pointer
+    code = vnodeDumpQueryResult(pRet, pVnode, pRetrieve->qId, handle, &freeHandle, pRead->rpcHandle);
+  }
+
+  // If qhandle is not added into vread queue, the query should be completed already or paused with error.
+  // Here free qhandle immediately
+  if (freeHandle) {
+    int32_t remain = atomic_sub_fetch_32(&pVnode->numOfExistQHandle, 1);
+    vTrace("vgId:%d, QInfo:%p, start to free qhandle, remain qhandle:%d", pVnode->vgId, *handle, remain);
+    qReleaseQInfo(pVnode->qMgmt, (void **)&handle, true);
+  }
+
+  return code;
+#endif 
+  return 0;
+}
+

source/util/src/terror.c

@@ -177,6 +177,10 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_PASS_FORMAT,      "Invalid password form
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_NO_USER_FROM_CONN,        "Can not get user from conn")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_USERS,           "Too many users")
 
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_MNODE_ALREADY_EXIST,       "Mnode already exists")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_MNODE_NOT_EXIST,           "Mnode not there")
+
+
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TABLE_ALREADY_EXIST,      "Table already exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_ID,         "Table name too long")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_NAME,       "Table does not exist")

source/util/src/tstep.c

@@ -18,7 +18,7 @@
 #include "ulog.h"
 #include "tstep.h"
 
-typedef struct SStepObj {
+typedef struct {
   char *    name;
   InitFp    initFp;
   CleanupFp cleanupFp;

source/util/src/tworker.c

@@ -76,7 +76,7 @@ static void *tWorkerThreadFp(SWorker *worker) {
     }
 
     code = (*pool->startFp)(ahandle, msg, qtype);
-    (*pool->endFp)(ahandle, msg, qtype, code);
+    if (pool->endFp) (*pool->endFp)(ahandle, msg, qtype, code);
   }
 
   return NULL;

src/mnode/CMakeLists.txt

-aux_source_directory(source MNODE_SRC)
-add_library(mnode ${MNODE_SRC})
-target_include_directories(
-    mnode
-    PUBLIC "${CMAKE_SOURCE_DIR}/include/mnode"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include"
-)
\ No newline at end of file

src/mnode/CMakeLists.txt.in

-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
-PROJECT(TDengine)
-
-INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
-INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/dnode/inc)
-
-INCLUDE_DIRECTORIES(inc)
-AUX_SOURCE_DIRECTORY(src SRC)
-
-ADD_LIBRARY(mnode ${SRC})

src/mnode/inc/mnodeAcct.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TDENGINE_MNODE_ACCT_H
-#define TDENGINE_MNODE_ACCT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "tacct.h"
-
-int32_t mnodeInitAccts();
-void    mnodeCleanupAccts();
-void    mnodeGetStatOfAllAcct(SAcctInfo* pAcctInfo);
-void *  mnodeGetAcct(char *acctName);
-void *  mnodeGetNextAcct(void *pIter, SAcctObj **pAcct);
-void    mnodeCancelGetNextAcct(void *pIter);
-void    mnodeIncAcctRef(SAcctObj *pAcct);
-void    mnodeDecAcctRef(SAcctObj *pAcct);
-void    mnodeAddDbToAcct(SAcctObj *pAcct, SDbObj *pDb);
-void    mnodeDropDbFromAcct(SAcctObj *pAcct, SDbObj *pDb);
-void    mnodeAddUserToAcct(SAcctObj *pAcct, SUserObj *pUser);
-void    mnodeDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser);
-
-int32_t mnodeCompactAccts();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mnodeDb.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef 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();
-int64_t mnodeGetDbNum();
-int32_t mnodeGetDbMaxReplica();
-SDbObj *mnodeGetDb(char *db);
-SDbObj *mnodeGetDbByTableName(char *db);
-void *  mnodeGetNextDb(void *pIter, SDbObj **pDb);
-void    mnodeCancelGetNextDb(void *pIter);
-void    mnodeIncDbRef(SDbObj *pDb);
-void    mnodeDecDbRef(SDbObj *pDb);
-bool    mnodeCheckIsMonitorDB(char *db, char *monitordb);
-void    mnodeDropAllDbs(SAcctObj *pAcct);
-int     mnodeInsertAlterDbRow(SDbObj *pDb, void *pMsg);
-
-int32_t mnodeCompactDbs();
-
-// util func
-void mnodeAddSuperTableIntoDb(SDbObj *pDb);
-void mnodeRemoveSuperTableFromDb(SDbObj *pDb);
-void mnodeAddTableIntoDb(SDbObj *pDb);
-void mnodeRemoveTableFromDb(SDbObj *pDb);
-void mnodeAddVgroupIntoDb(SVgObj *pVgroup);
-void mnodeRemoveVgroupFromDb(SVgObj *pVgroup);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mnodeDnode.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TDENGINE_MNODE_DNODE_H
-#define TDENGINE_MNODE_DNODE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
-  TAOS_DN_STATUS_OFFLINE,
-  TAOS_DN_STATUS_DROPPING,
-  TAOS_DN_STATUS_BALANCING,
-  TAOS_DN_STATUS_READY
-} EDnodeStatus;
-
-typedef enum {
-  TAOS_DN_ALTERNATIVE_ROLE_ANY,
-  TAOS_DN_ALTERNATIVE_ROLE_MNODE,
-  TAOS_DN_ALTERNATIVE_ROLE_VNODE
-} EDnodeAlternativeRole;
-
-typedef enum EDnodeOfflineReason {
-  TAOS_DN_OFF_ONLINE = 0,
-  TAOS_DN_OFF_STATUS_MSG_TIMEOUT,
-  TAOS_DN_OFF_STATUS_NOT_RECEIVED,
-  TAOS_DN_OFF_RESET_BY_MNODE,
-  TAOS_DN_OFF_VERSION_NOT_MATCH,
-  TAOS_DN_OFF_DNODE_ID_NOT_MATCH,
-  TAOS_DN_OFF_CLUSTER_ID_NOT_MATCH,
-  TAOS_DN_OFF_NUM_OF_MNODES_NOT_MATCH,
-  TAOS_DN_OFF_ENABLE_BALANCE_NOT_MATCH,
-  TAOS_DN_OFF_MN_EQUAL_VN_NOT_MATCH,
-  TAOS_DN_OFF_OFFLINE_THRESHOLD_NOT_MATCH,
-  TAOS_DN_OFF_STATUS_INTERVAL_NOT_MATCH,
-  TAOS_DN_OFF_MAX_TAB_PER_VN_NOT_MATCH,
-  TAOS_DN_OFF_MAX_VG_PER_DB_NOT_MATCH,
-  TAOS_DN_OFF_ARBITRATOR_NOT_MATCH,
-  TAOS_DN_OFF_TIME_ZONE_NOT_MATCH,
-  TAOS_DN_OFF_LOCALE_NOT_MATCH,
-  TAOS_DN_OFF_CHARSET_NOT_MATCH,
-  TAOS_DN_OFF_FLOW_CTRL_NOT_MATCH,
-  TAOS_DN_OFF_SLAVE_QUERY_NOT_MATCH,
-  TAOS_DN_OFF_ADJUST_MASTER_NOT_MATCH,
-  TAOS_DN_OFF_OTHERS
-} EDnodeOfflineReason;
-
-extern char* dnodeStatus[];
-extern char* dnodeRoles[];
-
-int32_t mnodeInitDnodes();
-void    mnodeCleanupDnodes();
-
-int32_t mnodeGetDnodesNum();
-int32_t mnodeGetOnlinDnodesCpuCoreNum();
-int32_t mnodeGetOnlineDnodesNum();
-void    mnodeGetOnlineAndTotalDnodesNum(int32_t *onlineNum, int32_t *totalNum);
-void *  mnodeGetNextDnode(void *pIter, SDnodeObj **pDnode);
-void    mnodeCancelGetNextDnode(void *pIter);
-void    mnodeIncDnodeRef(SDnodeObj *pDnode);
-void    mnodeDecDnodeRef(SDnodeObj *pDnode);
-void *  mnodeGetDnode(int32_t dnodeId);
-void *  mnodeGetDnodeByEp(char *ep);
-void    mnodeUpdateDnode(SDnodeObj *pDnode);
-int32_t mnodeDropDnode(SDnodeObj *pDnode, void *pMsg);
-
-int32_t mnodeCompactDnodes();
-extern int64_t tsAccessSquence;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mnodeInt.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TDENGINE_MNODE_LOG_H
-#define TDENGINE_MNODE_LOG_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "tlog.h"
-#include "monitor.h"
-
-extern int32_t mDebugFlag;
-extern int32_t sdbDebugFlag;
-
-// mnode log function
-#define mFatal(...) { if (mDebugFlag & DEBUG_FATAL) { taosPrintLog("MND FATAL ", 255, __VA_ARGS__); }}
-#define mError(...) { if (mDebugFlag & DEBUG_ERROR) { taosPrintLog("MND ERROR ", 255, __VA_ARGS__); }}
-#define mWarn(...)  { if (mDebugFlag & DEBUG_WARN)  { taosPrintLog("MND WARN ", 255, __VA_ARGS__); }}
-#define mInfo(...)  { if (mDebugFlag & DEBUG_INFO)  { taosPrintLog("MND ", 255, __VA_ARGS__); }}
-#define mDebug(...) { if (mDebugFlag & DEBUG_DEBUG) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
-#define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
-
-#define sdbFatal(...) { if (sdbDebugFlag & DEBUG_FATAL) { taosPrintLog("SDB FATAL ", 255, __VA_ARGS__); }}
-#define sdbError(...) { if (sdbDebugFlag & DEBUG_ERROR) { taosPrintLog("SDB ERROR ", 255, __VA_ARGS__); }}
-#define sdbWarn(...)  { if (sdbDebugFlag & DEBUG_WARN)  { taosPrintLog("SDB WARN ", 255, __VA_ARGS__); }}
-#define sdbInfo(...)  { if (sdbDebugFlag & DEBUG_INFO)  { taosPrintLog("SDB ", 255, __VA_ARGS__); }}
-#define sdbDebug(...) { if (sdbDebugFlag & DEBUG_DEBUG) { taosPrintLog("SDB ", sdbDebugFlag, __VA_ARGS__); }}
-#define sdbTrace(...) { if (sdbDebugFlag & DEBUG_TRACE) { taosPrintLog("SDB ", sdbDebugFlag, __VA_ARGS__); }}
-
-#define mLError(...) { monSaveLog(2, __VA_ARGS__); mError(__VA_ARGS__) }
-#define mLWarn(...)  { monSaveLog(1, __VA_ARGS__); mWarn(__VA_ARGS__)  }
-#define mLInfo(...)  { monSaveLog(0, __VA_ARGS__); mInfo(__VA_ARGS__) }
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mnodeMnode.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TDENGINE_MNODE_MNODE_H
-#define TDENGINE_MNODE_MNODE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct SMnodeObj;
-
-typedef enum {
-  TAOS_MN_STATUS_OFFLINE,
-  TAOS_MN_STATUS_DROPPING,
-  TAOS_MN_STATUS_READY
-} EMnodeStatus;
-
-int32_t mnodeInitMnodes();
-void    mnodeCleanupMnodes();
-
-void    mnodeCreateMnode(int32_t dnodeId, char *dnodeEp, bool needConfirm);
-int32_t mnodeDropMnode(int32_t dnodeId);
-void    mnodeDropMnodeLocal(int32_t dnodeId);
-
-void *  mnodeGetMnode(int32_t mnodeId);
-int32_t mnodeGetMnodesNum();
-void *  mnodeGetNextMnode(void *pIter, struct SMnodeObj **pMnode);
-void    mnodeCancelGetNextMnode(void *pIter);
-void    mnodeIncMnodeRef(struct SMnodeObj *pMnode);
-void    mnodeDecMnodeRef(struct SMnodeObj *pMnode);
-
-char *  mnodeGetMnodeRoleStr();
-void    mnodeGetMnodeEpSetForPeer(SRpcEpSet *epSet, bool redirect);
-void    mnodeGetMnodeEpSetForShell(SRpcEpSet *epSet, bool redirect);
-char*   mnodeGetMnodeMasterEp();
-
-void    mnodeGetMnodeInfos(void *mnodes);
-void    mnodeUpdateMnodeEpSet(SMInfos *pMnodes);
-
-int32_t mnodeCompactMnodes();
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mnodePeer.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef 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

-/*
- * 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_PROFILE_H
-#define TDENGINE_MNODE_PROFILE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "mnodeDef.h"
-
-typedef struct {
-  char     user[TSDB_USER_LEN];
-  char     appName[TSDB_APPNAME_LEN];  // app name that invokes taosc
-  uint32_t pid;                        // pid of app that invokes taosc
-  int8_t   killed;
-  uint16_t port;
-  uint32_t ip;
-  uint32_t connId;
-  uint64_t stime;
-  uint64_t lastAccess;
-  uint32_t queryId;
-  uint32_t streamId;
-  int32_t  numOfQueries;
-  int32_t  numOfStreams;
-  SStreamDesc *pStreams;
-  SQueryDesc * pQueries;
-} SConnObj;
-
-int32_t mnodeInitProfile();
-void    mnodeCleanupProfile();
-
-SConnObj *mnodeCreateConn(char *user, uint32_t ip, uint16_t port, int32_t pid, const char* app);
-SConnObj *mnodeAccquireConn(int32_t connId, char *user, uint32_t ip, uint16_t port);
-void      mnodeReleaseConn(SConnObj *pConn);
-int32_t   mnodeSaveQueryStreamList(SConnObj *pConn, SHeartBeatMsg *pHBMsg);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
\ No newline at end of file

src/mnode/inc/mnodeSdb.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TDENGINE_MNODE_SDB_H
-#define TDENGINE_MNODE_SDB_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "mnode.h"
-#include "twal.h"
-
-typedef enum {
-  SDB_TABLE_CLUSTER = 0,
-  SDB_TABLE_DNODE   = 1,
-  SDB_TABLE_MNODE   = 2,
-  SDB_TABLE_ACCOUNT = 3,
-  SDB_TABLE_USER    = 4,
-  SDB_TABLE_DB      = 5,
-  SDB_TABLE_VGROUP  = 6,
-  SDB_TABLE_STABLE  = 7,
-  SDB_TABLE_CTABLE  = 8,
-  SDB_TABLE_FUNC    = 9,
-  SDB_TABLE_MAX     = 10
-} ESdbTable;
-
-typedef enum {
-  SDB_KEY_STRING     = 0, 
-  SDB_KEY_INT        = 1,
-  SDB_KEY_AUTO       = 2,
-  SDB_KEY_VAR_STRING = 3,
-} ESdbKey;
-
-typedef enum {
-  SDB_OPER_GLOBAL = 0,
-  SDB_OPER_LOCAL  = 1
-} ESdbOper;
-
-typedef struct SSdbRow {
-  ESdbOper   type;
-  int32_t    processedCount;  // for sync fwd callback
-  int32_t    code;            // for callback in sdb queue
-  int32_t    rowSize;
-  void *     rowData;
-  void *     pObj;
-  void *     pTable;
-  SMnodeMsg *pMsg;
-  int32_t  (*fpReq)(SMnodeMsg *pMsg);
-  int32_t  (*fpRsp)(SMnodeMsg *pMsg, int32_t code);
-  char       reserveForSync[24];
-  SWalHead   pHead;
-} SSdbRow;
-
-typedef struct {
-  char *    name;
-  int32_t   hashSessions;
-  int32_t   maxRowSize;
-  int32_t   refCountPos;
-  ESdbTable id;
-  ESdbKey   keyType;
-  int32_t (*fpInsert)(SSdbRow *pRow);
-  int32_t (*fpDelete)(SSdbRow *pRow);
-  int32_t (*fpUpdate)(SSdbRow *pRow);
-  int32_t (*fpEncode)(SSdbRow *pRow);
-  int32_t (*fpDecode)(SSdbRow *pRow);  
-  int32_t (*fpDestroy)(SSdbRow *pRow);
-  int32_t (*fpRestored)();
-} SSdbTableDesc;
-
-int32_t sdbInitRef();
-void    sdbCleanUpRef();
-int32_t sdbInit();
-void    sdbCleanUp();
-int64_t sdbOpenTable(SSdbTableDesc *desc);
-void    sdbCloseTable(int64_t rid);
-void*   sdbGetTableByRid(int64_t rid);
-bool    sdbIsMaster();
-bool    sdbIsServing();
-void    sdbUpdateMnodeRoles();
-int32_t sdbGetReplicaNum();
-
-int32_t sdbInsertRow(SSdbRow *pRow);
-int32_t sdbInsertCompactRow(SSdbRow *pRow);
-int32_t sdbDeleteRow(SSdbRow *pRow);
-int32_t sdbUpdateRow(SSdbRow *pRow);
-int32_t sdbInsertRowToQueue(SSdbRow *pRow);
-
-void *   sdbGetRow(void *pTable, void *key);
-void *   sdbFetchRow(void *pTable, void *pIter, void **ppRow);
-void     sdbFreeIter(void *pTable, void *pIter);
-void     sdbIncRef(void *pTable, void *pRow);
-void     sdbDecRef(void *pTable, void *pRow);
-int64_t  sdbGetNumOfRows(void *pTable);
-int32_t  sdbGetId(void *pTable);
-uint64_t sdbGetVersion();
-bool     sdbCheckRowDeleted(void *pTable, void *pRow);
-
-int32_t mnodeCompactWal();
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mnodeShow.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef 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);
-typedef void    (*SShowFreeIterFp)(void *pIter);
-void mnodeAddShowMetaHandle(uint8_t showType, SShowMetaFp fp);
-void mnodeAddShowRetrieveHandle(uint8_t showType, SShowRetrieveFp fp);
-void mnodeAddShowFreeIterHandle(uint8_t msgType, SShowFreeIterFp fp);
-void mnodeVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_t capacity, SShowObj *pShow);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mnodeTable.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TBASE_MNODE_TABLE_H
-#define TBASE_MNODE_TABLE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "mnodeDef.h"
-
-int32_t mnodeInitTables();
-void    mnodeCleanupTables();
-int64_t mnodeGetSuperTableNum();
-int64_t mnodeGetChildTableNum();
-void *  mnodeGetTable(char *tableId);
-void    mnodeIncTableRef(void *pTable);
-void    mnodeDecTableRef(void *pTable);
-void *  mnodeGetNextChildTable(void *pIter, SCTableObj **pTable);
-void *  mnodeGetNextSuperTable(void *pIter, SSTableObj **pTable);
-void    mnodeCancelGetNextChildTable(void *pIter);
-void    mnodeCancelGetNextSuperTable(void *pIter);
-void    mnodeDropAllChildTables(SDbObj *pDropDb);
-void    mnodeDropAllSuperTables(SDbObj *pDropDb);
-void    mnodeDropAllChildTablesInVgroups(SVgObj *pVgroup);
-int32_t mnodeCompactTables();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mnodeUser.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef 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      mnodeCancelGetNextUser(void *pIter);
-void      mnodeIncUserRef(SUserObj *pUser);
-void      mnodeDecUserRef(SUserObj *pUser);
-SUserObj *mnodeGetUserFromConn(void *pConn);
-char *    mnodeGetUserFromMsg(void *pMnodeMsg);
-int32_t   mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass, void *pMsg);
-void      mnodeDropAllUsers(SAcctObj *pAcct);
-
-int32_t   mnodeCompactUsers();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/inc/mnodeVgroup.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TDENGINE_MNODE_VGROUP_H
-#define TDENGINE_MNODE_VGROUP_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct SMnodeMsg;
-
-int32_t mnodeInitVgroups();
-void    mnodeCleanupVgroups();
-int64_t mnodeGetVgroupNum();
-SVgObj *mnodeGetVgroup(int32_t vgId);
-void    mnodeIncVgroupRef(SVgObj *pVgroup);
-void    mnodeDecVgroupRef(SVgObj *pVgroup);
-void    mnodeDropAllDbVgroups(SDbObj *pDropDb);
-void    mnodeSendDropAllDbVgroupsMsg(SDbObj *pDropDb);
-void    mnodeDropAllDnodeVgroups(SDnodeObj *pDropDnode);
-//void  mnodeUpdateAllDbVgroups(SDbObj *pAlterDb);
-int32_t mnodeCompactVgroups();
-
-void *  mnodeGetNextVgroup(void *pIter, SVgObj **pVgroup);
-void    mnodeCancelGetNextVgroup(void *pIter);
-void    mnodeUpdateVgroup(SVgObj *pVgroup);
-void    mnodeUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVload);
-void    mnodeCheckUnCreatedVgroup(SDnodeObj *pDnode, SVnodeLoad *pVloads, int32_t openVnodes);
-
-int32_t mnodeCreateVgroup(struct SMnodeMsg *pMsg);
-void    mnodeDropVgroup(SVgObj *pVgroup, void *ahandle);
-void    mnodeAlterVgroup(SVgObj *pVgroup, void *ahandle);
-int32_t mnodeGetAvailableVgroup(struct SMnodeMsg *pMsg, SVgObj **pVgroup, int32_t *sid);
-
-int32_t mnodeAddTableIntoVgroup(SVgObj *pVgroup, SCTableObj *pTable, bool needCheck);
-void    mnodeRemoveTableFromVgroup(SVgObj *pVgroup, SCTableObj *pTable);
-void    mnodeSendDropVnodeMsg(int32_t vgId, SRpcEpSet *epSet, void *ahandle);
-void    mnodeSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle);
-void    mnodeSendAlterVgroupMsg(SVgObj *pVgroup,SMnodeMsg *pMsg);
-void    mnodeSendSyncVgroupMsg(SVgObj *pVgroup);
-void    mnodeSendCompactVgroupMsg(SVgObj *pVgroup);
-
-SRpcEpSet mnodeGetEpSetFromVgroup(SVgObj *pVgroup);
-SRpcEpSet mnodeGetEpSetFromIp(char *ep);
-
-int32_t mnodeGetVgidVer(int8_t *vver);
-void    mnodeSetVgidVer(int8_t *cver, uint64_t iver);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/mnode/src/mnodeAcct.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "tglobal.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeDb.h"
-#include "mnodeSdb.h"
-#include "mnodeUser.h"
-#include "mnodeVgroup.h"
-
-int64_t tsAcctRid = -1;
-void *  tsAcctSdb = NULL;
-static int32_t tsAcctUpdateSize;
-static int32_t mnodeCreateRootAcct();
-
-static int32_t mnodeAcctActionDestroy(SSdbRow *pRow) {
-  SAcctObj *pAcct = pRow->pObj;
-  pthread_mutex_destroy(&pAcct->mutex);
-  tfree(pRow->pObj);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionInsert(SSdbRow *pRow) {
-  SAcctObj *pAcct = pRow->pObj;
-  memset(&pAcct->acctInfo, 0, sizeof(SAcctInfo));
-  pAcct->acctInfo.accessState = TSDB_VN_ALL_ACCCESS;
-  pthread_mutex_init(&pAcct->mutex, NULL);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionDelete(SSdbRow *pRow) {
-  SAcctObj *pAcct = pRow->pObj;
-  mnodeDropAllUsers(pAcct);
-  mnodeDropAllDbs(pAcct);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionUpdate(SSdbRow *pRow) {
-  SAcctObj *pAcct = pRow->pObj;
-  SAcctObj *pSaved = mnodeGetAcct(pAcct->user);
-  if (pAcct != pSaved) {
-    memcpy(pSaved, pAcct, tsAcctUpdateSize);
-    free(pAcct);
-  }
-  mnodeDecAcctRef(pSaved);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionEncode(SSdbRow *pRow) {
-  SAcctObj *pAcct = pRow->pObj;
-  memcpy(pRow->rowData, pAcct, tsAcctUpdateSize);
-  pRow->rowSize = tsAcctUpdateSize;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionDecode(SSdbRow *pRow) {
-  SAcctObj *pAcct = (SAcctObj *) calloc(1, sizeof(SAcctObj));
-  if (pAcct == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
-  memcpy(pAcct, pRow->rowData, tsAcctUpdateSize);
-  pRow->pObj = pAcct;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionRestored() {
-  int64_t numOfRows = sdbGetNumOfRows(tsAcctSdb);
-  if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
-    mInfo("dnode first deploy, create root acct");
-    int32_t code = mnodeCreateRootAcct();
-    if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-      mError("failed to create root account, reason:%s", tstrerror(code));
-      return code;
-    }
-  }
-
-  acctInit();
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitAccts() {
-  SAcctObj tObj;
-  tsAcctUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
-  SSdbTableDesc desc = {
-    .id           = SDB_TABLE_ACCOUNT,
-    .name         = "accounts",
-    .hashSessions = TSDB_DEFAULT_ACCOUNTS_HASH_SIZE,
-    .maxRowSize   = tsAcctUpdateSize,
-    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
-    .keyType      = SDB_KEY_STRING,
-    .fpInsert     = mnodeAcctActionInsert,
-    .fpDelete     = mnodeAcctActionDelete,
-    .fpUpdate     = mnodeAcctActionUpdate,
-    .fpEncode     = mnodeAcctActionEncode,
-    .fpDecode     = mnodeAcctActionDecode,
-    .fpDestroy    = mnodeAcctActionDestroy,
-    .fpRestored   = mnodeAcctActionRestored
-  };
-
-  tsAcctRid = sdbOpenTable(&desc);
-  tsAcctSdb = sdbGetTableByRid(tsAcctRid);
-  if (tsAcctSdb == NULL) {
-    mError("table:%s, failed to create hash", desc.name);
-    return -1;
-  }
-
-  mDebug("table:%s, hash is created", desc.name);
-  return TSDB_CODE_SUCCESS;
-}
-
-void mnodeCleanupAccts() {
-  acctCleanUp();
-  sdbCloseTable(tsAcctRid);
-  tsAcctSdb = NULL;
-}
-
-void mnodeGetStatOfAllAcct(SAcctInfo* pAcctInfo) {
-  memset(pAcctInfo, 0, sizeof(*pAcctInfo));
-
-  void   *pIter = NULL;
-  SAcctObj *pAcct = NULL;
-  while (1) {
-    pIter = mnodeGetNextAcct(pIter, &pAcct);
-    if (pAcct == NULL) {
-      break;
-    }
-    pAcctInfo->numOfDbs += pAcct->acctInfo.numOfDbs;
-    pAcctInfo->numOfTimeSeries += pAcct->acctInfo.numOfTimeSeries;
-    mnodeDecAcctRef(pAcct);
-  }
-
-  SVgObj *pVgroup = NULL;
-  pIter = NULL;
-  while (1) {
-    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
-    if (pVgroup == NULL) {
-       break;
-    }
-    pAcctInfo->totalStorage += pVgroup->totalStorage;
-    pAcctInfo->compStorage += pVgroup->compStorage;
-    pAcctInfo->totalPoints += pVgroup->pointsWritten;
-    mnodeDecVgroupRef(pVgroup);
-  }
-}
-
-void *mnodeGetAcct(char *name) {
-  return sdbGetRow(tsAcctSdb, name);
-}
-
-void *mnodeGetNextAcct(void *pIter, SAcctObj **pAcct) {
-  return sdbFetchRow(tsAcctSdb, pIter, (void **)pAcct); 
-}
-
-void mnodeCancelGetNextAcct(void *pIter) {
-  sdbFreeIter(tsAcctSdb, pIter);
-}
-
-void mnodeIncAcctRef(SAcctObj *pAcct) {
-  sdbIncRef(tsAcctSdb, pAcct);
-}
-
-void mnodeDecAcctRef(SAcctObj *pAcct) {
-  sdbDecRef(tsAcctSdb, pAcct);
-}
-
-void mnodeAddDbToAcct(SAcctObj *pAcct, SDbObj *pDb) {
-  atomic_add_fetch_32(&pAcct->acctInfo.numOfDbs, 1);
-  pDb->pAcct = pAcct;
-  mnodeIncAcctRef(pAcct);
-}
-
-void mnodeDropDbFromAcct(SAcctObj *pAcct, SDbObj *pDb) {
-  atomic_sub_fetch_32(&pAcct->acctInfo.numOfDbs, 1);
-  pDb->pAcct = NULL;
-  mnodeDecAcctRef(pAcct);
-}
-
-void mnodeAddUserToAcct(SAcctObj *pAcct, SUserObj *pUser) {
-  atomic_add_fetch_32(&pAcct->acctInfo.numOfUsers, 1);
-  pUser->pAcct = pAcct;
-  mnodeIncAcctRef(pAcct);
-}
-
-void mnodeDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser) {
-  atomic_sub_fetch_32(&pAcct->acctInfo.numOfUsers, 1);
-  pUser->pAcct = NULL;
-  mnodeDecAcctRef(pAcct);
-}
-
-static int32_t mnodeCreateRootAcct() {
-  int64_t numOfAccts = sdbGetNumOfRows(tsAcctSdb);
-  if (numOfAccts != 0) return TSDB_CODE_SUCCESS;
-
-  SAcctObj *pAcct = malloc(sizeof(SAcctObj));
-  memset(pAcct, 0, sizeof(SAcctObj));
-  strcpy(pAcct->user, TSDB_DEFAULT_USER);
-  taosEncryptPass((uint8_t *)TSDB_DEFAULT_PASS, strlen(TSDB_DEFAULT_PASS), pAcct->pass);
-  pAcct->cfg = (SAcctCfg){
-    .maxUsers           = 128,
-    .maxDbs             = 128,
-    .maxTimeSeries      = INT32_MAX,
-    .maxConnections     = 1024,
-    .maxStreams         = 1000,
-    .maxPointsPerSecond = 10000000,
-    .maxStorage         = INT64_MAX,
-    .maxQueryTime       = INT64_MAX,
-    .maxInbound         = 0,
-    .maxOutbound        = 0,
-    .accessState        = TSDB_VN_ALL_ACCCESS
-  };
-  pAcct->acctId = sdbGetId(tsAcctSdb);
-  pAcct->createdTime = taosGetTimestampMs();
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsAcctSdb,
-    .pObj   = pAcct,
-  };
-
-  return sdbInsertRow(&row);
-}
-
-int32_t mnodeCompactAccts() {
-  void *pIter = NULL;
-  SAcctObj *pAcct = NULL;
-
-  mInfo("start to compact accts table...");
-
-  while (1) {
-    pIter = mnodeGetNextAcct(pIter, &pAcct);
-    if (pAcct == NULL) break;
-
-    SSdbRow row = {
-      .type   = SDB_OPER_GLOBAL,
-      .pTable = tsAcctSdb,
-      .pObj   = pAcct,
-    };
-
-    mInfo("compact accts %s", pAcct->user);
-    
-    sdbInsertCompactRow(&row);
-  }
-
-  mInfo("end to compact accts table...");
-
-  return 0;
-}
-
-#ifndef _ACCT
-
-int32_t acctInit() { return TSDB_CODE_SUCCESS; }
-void    acctCleanUp() {}
-int32_t acctCheck(void *pAcct, EAcctGrantType type) { return TSDB_CODE_SUCCESS; }
-
-#endif

src/mnode/src/mnodeCluster.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeCluster.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "tglobal.h"
-
-int64_t        tsClusterRid = -1;
-static void *  tsClusterSdb = NULL;
-static int32_t tsClusterUpdateSize;
-static char    tsClusterId[TSDB_CLUSTER_ID_LEN];
-static int32_t mnodeCreateCluster();
-
-static int32_t mnodeGetClusterMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveClusters(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void    mnodeCancelGetNextCluster(void *pIter);
-
-static int32_t mnodeClusterActionDestroy(SSdbRow *pRow) {
-  tfree(pRow->pObj);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionInsert(SSdbRow *pRow) {
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionDelete(SSdbRow *pRow) {
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionUpdate(SSdbRow *pRow) {
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionEncode(SSdbRow *pRow) {
-  SClusterObj *pCluster = pRow->pObj;
-  memcpy(pRow->rowData, pCluster, tsClusterUpdateSize);
-  pRow->rowSize = tsClusterUpdateSize;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionDecode(SSdbRow *pRow) {
-  SClusterObj *pCluster = (SClusterObj *) calloc(1, sizeof(SClusterObj));
-  if (pCluster == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
-  memcpy(pCluster, pRow->rowData, tsClusterUpdateSize);
-  pRow->pObj = pCluster;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionRestored() {
-  int64_t numOfRows = sdbGetNumOfRows(tsClusterSdb);
-  if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
-    mInfo("dnode first deploy, create cluster");
-    int32_t code = mnodeCreateCluster();
-    if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-      mError("failed to create cluster, reason:%s", tstrerror(code));
-      return code;
-    }
-  }
-
-  mnodeUpdateClusterId();
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitCluster() {
-  SClusterObj tObj;
-  tsClusterUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
-  SSdbTableDesc desc = {
-    .id           = SDB_TABLE_CLUSTER,
-    .name         = "cluster",
-    .hashSessions = TSDB_DEFAULT_CLUSTER_HASH_SIZE,
-    .maxRowSize   = tsClusterUpdateSize,
-    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
-    .keyType      = SDB_KEY_STRING,
-    .fpInsert     = mnodeClusterActionInsert,
-    .fpDelete     = mnodeClusterActionDelete,
-    .fpUpdate     = mnodeClusterActionUpdate,
-    .fpEncode     = mnodeClusterActionEncode,
-    .fpDecode     = mnodeClusterActionDecode,
-    .fpDestroy    = mnodeClusterActionDestroy,
-    .fpRestored   = mnodeClusterActionRestored
-  };
-
-  tsClusterRid = sdbOpenTable(&desc);
-  tsClusterSdb = sdbGetTableByRid(tsClusterRid);
-  if (tsClusterSdb == NULL) {
-    mError("table:%s, rid:%" PRId64 ", failed to create hash", desc.name, tsClusterRid);
-    return -1;
-  }
-
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CLUSTER, mnodeGetClusterMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CLUSTER, mnodeRetrieveClusters);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_CLUSTER, mnodeCancelGetNextCluster);
-
-  mDebug("table:%s, hash is created", desc.name);
-  return TSDB_CODE_SUCCESS;
-}
-
-void mnodeCleanupCluster() {
-  sdbCloseTable(tsClusterRid);
-  tsClusterSdb = NULL;
-}
-
-void *mnodeGetNextCluster(void *pIter, SClusterObj **pCluster) {
-  return sdbFetchRow(tsClusterSdb, pIter, (void **)pCluster); 
-}
-
-void mnodeCancelGetNextCluster(void *pIter) {
-  sdbFreeIter(tsClusterSdb, pIter);
-}
-
-void mnodeIncClusterRef(SClusterObj *pCluster) {
-  sdbIncRef(tsClusterSdb, pCluster);
-}
-
-void mnodeDecClusterRef(SClusterObj *pCluster) {
-  sdbDecRef(tsClusterSdb, pCluster);
-}
-
-static int32_t mnodeCreateCluster() {
-  int64_t numOfClusters = sdbGetNumOfRows(tsClusterSdb);
-  if (numOfClusters != 0) return TSDB_CODE_SUCCESS;
-
-  SClusterObj *pCluster = malloc(sizeof(SClusterObj));
-  memset(pCluster, 0, sizeof(SClusterObj));
-  pCluster->createdTime = taosGetTimestampMs();
-  bool getuid = taosGetSystemUid(pCluster->uid);
-  if (!getuid) {
-    strcpy(pCluster->uid, "tdengine2.0");
-    mError("failed to get uid from system, set to default val %s", pCluster->uid);
-  } else {
-    mDebug("uid is %s", pCluster->uid);
-  }
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsClusterSdb,
-    .pObj   = pCluster,
-  };
-
-  return sdbInsertRow(&row);
-}
-
-const char* mnodeGetClusterId() {
-  return tsClusterId;
-}
-
-void mnodeUpdateClusterId() {
-  SClusterObj *pCluster = NULL;
-  void *pIter = mnodeGetNextCluster(NULL, &pCluster);
-  if (pCluster != NULL) {
-    tstrncpy(tsClusterId, pCluster->uid, TSDB_CLUSTER_ID_LEN);
-    mDebug("cluster id is set to %s", tsClusterId);
-  }
-
-  mnodeDecClusterRef(pCluster);
-  mnodeCancelGetNextCluster(pIter);
-}
-
-static int32_t mnodeGetClusterMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  int32_t cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = TSDB_CLUSTER_ID_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "clusterId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "create_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pMeta->numOfColumns = htons(cols);
-  strcpy(pMeta->tableFname, "show cluster");
-  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 = 1;
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  return 0;
-}
-
-static int32_t mnodeRetrieveClusters(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  int32_t numOfRows = 0;
-  int32_t cols = 0;
-  char *  pWrite;
-  SClusterObj *pCluster = NULL;
-
-  while (numOfRows < rows) {
-    pShow->pIter = mnodeGetNextCluster(pShow->pIter, &pCluster);
-    if (pCluster == NULL) break;
-    
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pCluster->uid, TSDB_CLUSTER_ID_LEN);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *) pWrite = pCluster->createdTime;
-    cols++;
-
-    mnodeDecClusterRef(pCluster);
-    numOfRows++;
-  }
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  pShow->numOfReads += numOfRows;
-  return numOfRows;
-}
-
-int32_t mnodeCompactCluster() {
-  SClusterObj *pCluster = NULL;
-  void *pIter;
-  
-  mInfo("start to compact cluster table...");
-
-  pIter = mnodeGetNextCluster(NULL, &pCluster);
-  while (pCluster) {
-    SSdbRow row = {
-      .type   = SDB_OPER_GLOBAL,
-      .pTable = tsClusterSdb,
-      .pObj   = pCluster,      
-    };
-
-    sdbInsertCompactRow(&row);
-
-    pIter = mnodeGetNextCluster(pIter, &pCluster);
-  }
-
-  mInfo("end to compact cluster table...");
-
-  return 0;
-}
\ No newline at end of file

src/mnode/src/mnodeDb.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "tutil.h"
-#include "tgrant.h"
-#include "tglobal.h"
-#include "tname.h"
-#include "tbn.h"
-#include "tdataformat.h"
-#include "tp.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 "mnodePeer.h"
-#include "mnodeProfile.h"
-#include "mnodeWrite.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeTable.h"
-#include "mnodeUser.h"
-#include "mnodeVgroup.h"
-
-#define VG_LIST_SIZE 8
-int64_t tsDbRid = -1;
-void *  tsDbSdb = NULL;
-static int32_t tsDbUpdateSize;
-
-static int32_t mnodeCreateDb(SAcctObj *pAcct, SCreateDbMsg *pCreate, SMnodeMsg *pMsg);
-static int32_t mnodeDropDb(SMnodeMsg *newMsg);
-static int32_t mnodeSetDbDropping(SDbObj *pDb);
-static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessSyncDbMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessCompactMsg(SMnodeMsg *pMsg);
-int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg);
-
-#ifndef _TOPIC
-int32_t tpInit() { return 0; }
-void    tpCleanUp() {}
-void    tpUpdateTs(int32_t vgId, int64_t *seq, void *pMsg) {}
-#endif
-
-static void mnodeDestroyDb(SDbObj *pDb) {
-  pthread_mutex_destroy(&pDb->mutex);
-  tfree(pDb->vgList);
-  tfree(pDb);
-}
-
-static int32_t mnodeDbActionDestroy(SSdbRow *pRow) {
-  mnodeDestroyDb(pRow->pObj);
-  return TSDB_CODE_SUCCESS;
-}
-
-int64_t mnodeGetDbNum() {
-  return sdbGetNumOfRows(tsDbSdb);
-}
-
-int32_t mnodeGetDbMaxReplica() {
-  int32_t maxReplica = 0;
-  SDbObj *pDb = NULL;
-  void   *pIter = NULL;
-
-  while (1) {
-    pIter = mnodeGetNextDb(pIter, &pDb);
-    if (pDb == NULL) break;
-
-    if (pDb->cfg.replications > maxReplica)
-      maxReplica = pDb->cfg.replications;
-
-    mnodeDecDbRef(pDb);
-  }
-
-  return maxReplica;
-}
-
-static int32_t mnodeDbActionInsert(SSdbRow *pRow) {
-  SDbObj *pDb = pRow->pObj;
-  SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
-
-  pthread_mutex_init(&pDb->mutex, NULL);
-  pthread_mutex_lock(&pDb->mutex);
-  pDb->vgListSize = VG_LIST_SIZE;
-  pDb->vgList = calloc(pDb->vgListSize, sizeof(SVgObj *));
-  pDb->numOfVgroups = 0;
-  pthread_mutex_unlock(&pDb->mutex);
-
-  pDb->numOfTables = 0;
-  pDb->numOfSuperTables = 0;
-
-  if (pAcct != NULL) {
-    mnodeAddDbToAcct(pAcct, pDb);
-    mnodeDecAcctRef(pAcct);
-  }
-  else {
-    mError("db:%s, acct:%s info not exist in sdb", pDb->name, pDb->acct);
-    return TSDB_CODE_MND_INVALID_ACCT;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDbActionDelete(SSdbRow *pRow) {
-  SDbObj *pDb = pRow->pObj;
-  SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
-
-  mnodeDropAllChildTables(pDb);
-  mnodeDropAllSuperTables(pDb);
-  mnodeDropAllDbVgroups(pDb);
-
-  if (pAcct) {
-    mnodeDropDbFromAcct(pAcct, pDb);
-    mnodeDecAcctRef(pAcct);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDbActionUpdate(SSdbRow *pRow) {
-  SDbObj *pNew = pRow->pObj;
-  SDbObj *pDb = mnodeGetDb(pNew->name);
-  if (pDb != NULL && pNew != pDb) {
-    memcpy(pDb, pNew, pRow->rowSize);
-    free(pNew->vgList);
-    free(pNew);
-  }
-  //mnodeUpdateAllDbVgroups(pDb);
-  mnodeDecDbRef(pDb);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDbActionEncode(SSdbRow *pRow) {
-  SDbObj *pDb = pRow->pObj;
-  memcpy(pRow->rowData, pDb, tsDbUpdateSize);
-  pRow->rowSize = tsDbUpdateSize;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDbActionDecode(SSdbRow *pRow) {
-  SDbObj *pDb = (SDbObj *) calloc(1, sizeof(SDbObj));
-  if (pDb == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-  
-  memcpy(pDb, pRow->rowData, tsDbUpdateSize);
-  pRow->pObj = pDb;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDbActionRestored() {
-  return 0;
-}
-
-int32_t mnodeInitDbs() {
-  SDbObj tObj;
-  tsDbUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
-  SSdbTableDesc desc = {
-    .id           = SDB_TABLE_DB,
-    .name         = "dbs",
-    .hashSessions = TSDB_DEFAULT_DBS_HASH_SIZE,
-    .maxRowSize   = tsDbUpdateSize,
-    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
-    .keyType      = SDB_KEY_STRING,
-    .fpInsert     = mnodeDbActionInsert,
-    .fpDelete     = mnodeDbActionDelete,
-    .fpUpdate     = mnodeDbActionUpdate,
-    .fpEncode     = mnodeDbActionEncode,
-    .fpDecode     = mnodeDbActionDecode,
-    .fpDestroy    = mnodeDbActionDestroy,
-    .fpRestored   = mnodeDbActionRestored
-  };
-
-  tsDbRid = sdbOpenTable(&desc);
-  tsDbSdb = sdbGetTableByRid(tsDbRid);
-  if (tsDbSdb == NULL) {
-    mError("failed to init db data");
-    return -1;
-  }
-
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DB, mnodeProcessCreateDbMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_ALTER_DB, mnodeProcessAlterDbMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_DB, mnodeProcessDropDbMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_SYNC_DB, mnodeProcessSyncDbMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_COMPACT_VNODE, mnodeProcessCompactMsg);
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DB, mnodeGetDbMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DB, mnodeRetrieveDbs);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_DB, mnodeCancelGetNextDb);
-  
-  
-  mDebug("table:dbs table is created");
-  return tpInit();
-}
-
-void *mnodeGetNextDb(void *pIter, SDbObj **pDb) {
-  return sdbFetchRow(tsDbSdb, pIter, (void **)pDb);
-}
-
-void mnodeCancelGetNextDb(void *pIter) {
-  sdbFreeIter(tsDbSdb, pIter);
-}
-
-SDbObj *mnodeGetDb(char *db) {
-  return (SDbObj *)sdbGetRow(tsDbSdb, db);
-}
-
-void mnodeIncDbRef(SDbObj *pDb) {
-  sdbIncRef(tsDbSdb, pDb); 
-}
-
-void mnodeDecDbRef(SDbObj *pDb) { 
-  sdbDecRef(tsDbSdb, pDb); 
-}
-
-SDbObj *mnodeGetDbByTableName(char *tableName) {
-  SName name = {0};
-  tNameFromString(&name, tableName, T_NAME_ACCT|T_NAME_DB|T_NAME_TABLE);
-
-  // validate the tableName?
-  char db[TSDB_TABLE_FNAME_LEN] = {0};
-  tNameGetFullDbName(&name, db);
-
-  return mnodeGetDb(db);
-}
-
-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);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->totalBlocks < TSDB_MIN_TOTAL_BLOCKS || pCfg->totalBlocks > TSDB_MAX_TOTAL_BLOCKS) {
-    mError("invalid db option totalBlocks:%d valid range: [%d, %d]", pCfg->totalBlocks, TSDB_MIN_TOTAL_BLOCKS,
-           TSDB_MAX_TOTAL_BLOCKS);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->maxTables < TSDB_MIN_TABLES || pCfg->maxTables > TSDB_MAX_TABLES) {
-    mError("invalid db option maxTables:%d valid range: [%d, %d]", pCfg->maxTables, TSDB_MIN_TABLES, TSDB_MAX_TABLES);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) {
-    mError("invalid db option daysPerFile:%d valid range: [%d, %d]", pCfg->daysPerFile, TSDB_MIN_DAYS_PER_FILE,
-           TSDB_MAX_DAYS_PER_FILE);
-    return TSDB_CODE_MND_INVALID_DB_OPTION_DAYS;
-  }
-
-  if (pCfg->daysToKeep0 < TSDB_MIN_KEEP || pCfg->daysToKeep0 > TSDB_MAX_KEEP) {
-    mError("invalid db option daysToKeep:%d valid range: [%d, %d]", pCfg->daysToKeep0, TSDB_MIN_KEEP, TSDB_MAX_KEEP);
-    return TSDB_CODE_MND_INVALID_DB_OPTION_KEEP;
-  }
-
-  if (pCfg->daysToKeep0 < pCfg->daysPerFile) {
-    mError("invalid db option daysToKeep:%d should larger than daysPerFile:%d", pCfg->daysToKeep0, pCfg->daysPerFile);
-    return TSDB_CODE_MND_INVALID_DB_OPTION_KEEP;
-  }
-
-  if (pCfg->daysToKeep1 < pCfg->daysToKeep0 || pCfg->daysToKeep1 > TSDB_MAX_KEEP) {
-    mError("invalid db option daysToKeep1:%d valid range: [%d, %d]", pCfg->daysToKeep1, pCfg->daysToKeep0, TSDB_MAX_KEEP);
-    return TSDB_CODE_MND_INVALID_DB_OPTION_KEEP;
-  }
-
-  if (pCfg->daysToKeep2 < pCfg->daysToKeep1 || pCfg->daysToKeep2 > TSDB_MAX_KEEP) {
-    mError("invalid db option daysToKeep2:%d valid range: [%d, %d]", pCfg->daysToKeep2, pCfg->daysToKeep1, TSDB_MAX_KEEP);
-    return TSDB_CODE_MND_INVALID_DB_OPTION_KEEP;
-  }
-
-
-  if (pCfg->maxRowsPerFileBlock < TSDB_MIN_MAX_ROW_FBLOCK || pCfg->maxRowsPerFileBlock > TSDB_MAX_MAX_ROW_FBLOCK) {
-    mError("invalid db option maxRowsPerFileBlock:%d valid range: [%d, %d]", pCfg->maxRowsPerFileBlock,
-           TSDB_MIN_MAX_ROW_FBLOCK, TSDB_MAX_MAX_ROW_FBLOCK);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->minRowsPerFileBlock < TSDB_MIN_MIN_ROW_FBLOCK || pCfg->minRowsPerFileBlock > TSDB_MAX_MIN_ROW_FBLOCK) {
-    mError("invalid db option minRowsPerFileBlock:%d valid range: [%d, %d]", pCfg->minRowsPerFileBlock,
-           TSDB_MIN_MIN_ROW_FBLOCK, TSDB_MAX_MIN_ROW_FBLOCK);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->minRowsPerFileBlock > pCfg->maxRowsPerFileBlock) {
-    mError("invalid db option minRowsPerFileBlock:%d should smaller than maxRowsPerFileBlock:%d",
-           pCfg->minRowsPerFileBlock, pCfg->maxRowsPerFileBlock);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->commitTime < TSDB_MIN_COMMIT_TIME || pCfg->commitTime > TSDB_MAX_COMMIT_TIME) {
-    mError("invalid db option commitTime:%d valid range: [%d, %d]", pCfg->commitTime, TSDB_MIN_COMMIT_TIME,
-           TSDB_MAX_COMMIT_TIME);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) {
-    mError("invalid db option timePrecision:%d valid value: [%d, %d]", pCfg->precision, TSDB_MIN_PRECISION,
-           TSDB_MAX_PRECISION);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) {
-    mError("invalid db option compression:%d valid range: [%d, %d]", pCfg->compression, TSDB_MIN_COMP_LEVEL,
-           TSDB_MAX_COMP_LEVEL);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) {
-    mError("invalid db option walLevel:%d, valid range: [%d, %d]", pCfg->walLevel, TSDB_MIN_WAL_LEVEL, TSDB_MAX_WAL_LEVEL);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->fsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->fsyncPeriod > TSDB_MAX_FSYNC_PERIOD) {
-    mError("invalid db option fsyncPeriod:%d, valid range: [%d, %d]", pCfg->fsyncPeriod, TSDB_MIN_FSYNC_PERIOD, TSDB_MAX_FSYNC_PERIOD);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->replications < TSDB_MIN_DB_REPLICA_OPTION || pCfg->replications > TSDB_MAX_DB_REPLICA_OPTION) {
-    mError("invalid db option replications:%d valid range: [%d, %d]", pCfg->replications, TSDB_MIN_DB_REPLICA_OPTION,
-           TSDB_MAX_DB_REPLICA_OPTION);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->replications > mnodeGetDnodesNum()) {
-    mError("no enough dnode to config replica: %d, #dnodes: %d", pCfg->replications, mnodeGetDnodesNum());
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->quorum > pCfg->replications) {
-    mError("invalid db option quorum:%d larger than replica:%d", pCfg->quorum, pCfg->replications);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->quorum < TSDB_MIN_DB_QUORUM_OPTION || pCfg->quorum > TSDB_MAX_DB_QUORUM_OPTION) {
-    mError("invalid db option quorum:%d valid range: [%d, %d]", pCfg->quorum, TSDB_MIN_DB_QUORUM_OPTION,
-           TSDB_MAX_DB_QUORUM_OPTION);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->update < TSDB_MIN_DB_UPDATE || pCfg->update > TSDB_MAX_DB_UPDATE) {
-    mError("invalid db option update:%d valid range: [%d, %d]", pCfg->update, TSDB_MIN_DB_UPDATE, TSDB_MAX_DB_UPDATE);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->cacheLastRow < TSDB_MIN_DB_CACHE_LAST_ROW || pCfg->cacheLastRow > TSDB_MAX_DB_CACHE_LAST_ROW) {
-    mError("invalid db option cacheLastRow:%d valid range: [%d, %d]", pCfg->cacheLastRow, TSDB_MIN_DB_CACHE_LAST_ROW, TSDB_MAX_DB_CACHE_LAST_ROW);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->dbType < 0 || pCfg->dbType > 1) {
-    mError("invalid db option dbType:%d valid range: [%d, %d]", pCfg->dbType, 0, 1);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (pCfg->partitions < TSDB_MIN_DB_PARTITON_OPTION || pCfg->partitions > TSDB_MAX_DB_PARTITON_OPTION) {
-    mError("invalid db option partitions:%d valid range: [%d, %d]", pCfg->partitions, TSDB_MIN_DB_PARTITON_OPTION,
-           TSDB_MAX_DB_PARTITON_OPTION);
-    return TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-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;
-  if (pCfg->daysPerFile < 0) pCfg->daysPerFile = tsDaysPerFile;
-  if (pCfg->daysToKeep2 < 0) pCfg->daysToKeep2 = tsDaysToKeep;
-  if (pCfg->daysToKeep1 < 0) pCfg->daysToKeep1 = pCfg->daysToKeep2;
-  if (pCfg->daysToKeep0 < 0) pCfg->daysToKeep0 = pCfg->daysToKeep1;
-  if (pCfg->minRowsPerFileBlock < 0) pCfg->minRowsPerFileBlock = tsMinRowsInFileBlock;
-  if (pCfg->maxRowsPerFileBlock < 0) pCfg->maxRowsPerFileBlock = tsMaxRowsInFileBlock;
-  if (pCfg->fsyncPeriod <0) pCfg->fsyncPeriod = tsFsyncPeriod;
-  if (pCfg->commitTime < 0) pCfg->commitTime = tsCommitTime;
-  if (pCfg->precision < 0) pCfg->precision = tsTimePrecision;
-  if (pCfg->compression < 0) pCfg->compression = tsCompression;
-  if (pCfg->walLevel < 0) pCfg->walLevel = tsWAL;
-  if (pCfg->replications < 0) pCfg->replications = tsReplications;
-  if (pCfg->quorum < 0) pCfg->quorum = MIN(tsQuorum, pCfg->replications);
-  if (pCfg->update < 0) pCfg->update = tsUpdate;
-  if (pCfg->cacheLastRow < 0) pCfg->cacheLastRow = tsCacheLastRow;
-  if (pCfg->dbType < 0) pCfg->dbType = 0;
-  if (pCfg->partitions < 0) pCfg->partitions = tsPartitons;
-}
-
-static int32_t mnodeCreateDbCb(SMnodeMsg *pMsg, int32_t code) {
-  SDbObj *pDb = pMsg->pDb;
-  if (code == TSDB_CODE_SUCCESS) {
-    mLInfo("db:%s, is created by %s", pDb->name, mnodeGetUserFromMsg(pMsg));
-  } else {
-    mError("db:%s, failed to create by %s, reason:%s", pDb->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
-  }
-
-  return code;
-}
-
-static int32_t mnodeCreateDb(SAcctObj *pAcct, SCreateDbMsg *pCreate, SMnodeMsg *pMsg) {
-  int32_t code = acctCheck(pAcct, ACCT_GRANT_DB);
-  if (code != 0) return code;
-
-  SDbObj *pDb = mnodeGetDb(pCreate->db);
-  if (pDb != NULL) {
-    mnodeDecDbRef(pDb); 
-    if (pCreate->ignoreExist) {
-      mDebug("db:%s, already exist, ignore exist is set", pCreate->db);
-      return TSDB_CODE_SUCCESS;
-    } else {
-      mError("db:%s, already exist, ignore exist not set", pCreate->db);
-      return TSDB_CODE_MND_DB_ALREADY_EXIST;
-    }
-  }
-
-  code = grantCheck(TSDB_GRANT_DB);
-  if (code != 0) return code;
-
-  pDb = calloc(1, sizeof(SDbObj));
-  tstrncpy(pDb->name, pCreate->db, sizeof(pDb->name));
-  tstrncpy(pDb->acct, pAcct->user, sizeof(pDb->acct)); 
-  pDb->createdTime = taosGetTimestampMs(); 
-  pDb->cfg = (SDbCfg) {
-    .cacheBlockSize      = pCreate->cacheBlockSize,
-    .totalBlocks         = pCreate->totalBlocks,
-    .maxTables           = pCreate->maxTables,
-    .daysPerFile         = pCreate->daysPerFile,
-    .daysToKeep0         = pCreate->daysToKeep0,
-    .daysToKeep1         = pCreate->daysToKeep1,
-    .daysToKeep2         = pCreate->daysToKeep2,
-    .minRowsPerFileBlock = pCreate->minRowsPerFileBlock,
-    .maxRowsPerFileBlock = pCreate->maxRowsPerFileBlock,
-    .fsyncPeriod         = pCreate->fsyncPeriod,
-    .commitTime          = pCreate->commitTime,
-    .precision           = pCreate->precision,
-    .compression         = pCreate->compression,
-    .walLevel            = pCreate->walLevel,
-    .replications        = pCreate->replications,
-    .quorum              = pCreate->quorum,
-    .update              = pCreate->update,
-    .cacheLastRow        = pCreate->cacheLastRow,
-    .dbType              = pCreate->dbType,
-    .partitions          = pCreate->partitions
-  };
-
-  mnodeSetDefaultDbCfg(&pDb->cfg);
-
-  code = mnodeCheckDbCfg(&pDb->cfg);
-  if (code != TSDB_CODE_SUCCESS) {
-    tfree(pDb);
-    return code;
-  }
-
-  pMsg->pDb = pDb;
-  mnodeIncDbRef(pDb);
-
-  SSdbRow row = {
-    .type     = SDB_OPER_GLOBAL,
-    .pTable   = tsDbSdb,
-    .pObj     = pDb,
-    .rowSize  = sizeof(SDbObj),
-    .pMsg     = pMsg,
-    .fpRsp    = mnodeCreateDbCb
-  };
-
-  code = sdbInsertRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("db:%s, failed to create, reason:%s", pDb->name, tstrerror(code));
-    pMsg->pDb = NULL;
-    mnodeDestroyDb(pDb);
-  }
-
-  return code;
-}
-
-bool mnodeCheckIsMonitorDB(char *db, char *monitordb) {
-  char dbName[TSDB_DB_NAME_LEN] = {0};
-  extractDBName(db, dbName);
-
-  size_t len = strlen(dbName);
-  return (strncasecmp(dbName, monitordb, len) == 0 && len == strlen(monitordb));
-}
-
-#if 0
-void mnodePrintVgroups(SDbObj *pDb, char *row) {
-  mInfo("db:%s, vgroup link from head, row:%s", pDb->name, row);  
-  SVgObj *pVgroup = pDb->pHead;
-  while (pVgroup != NULL) {
-    mInfo("vgId:%d", pVgroup->vgId);
-    pVgroup = pVgroup->next;
-  }
-
-  mInfo("db:%s, vgroup link from tail", pDb->name, pDb->numOfVgroups);
-  pVgroup = pDb->pTail;
-  while (pVgroup != NULL) {
-    mInfo("vgId:%d", pVgroup->vgId);
-    pVgroup = pVgroup->prev;
-  }
-}
-#endif
-
-void mnodeAddVgroupIntoDb(SVgObj *pVgroup) {
-  SDbObj *pDb = pVgroup->pDb;
-
-  pthread_mutex_lock(&pDb->mutex);
-  int32_t vgPos = pDb->numOfVgroups++;
-  if (vgPos >= pDb->vgListSize) {
-    pDb->vgList = realloc(pDb->vgList, pDb->vgListSize * 2 * sizeof(SVgObj *));
-    memset(pDb->vgList + pDb->vgListSize, 0, pDb->vgListSize * sizeof(SVgObj *));
-    pDb->vgListSize *= 2;
-  }
-
-  pDb->vgList[vgPos] = pVgroup;
-  pthread_mutex_unlock(&pDb->mutex);
-}
-
-void mnodeRemoveVgroupFromDb(SVgObj *pVgroup) {
-  SDbObj *pDb = pVgroup->pDb;
-
-  pthread_mutex_lock(&pDb->mutex);
-  for (int32_t v1 = 0; v1 < pDb->numOfVgroups; ++v1) {
-    if (pDb->vgList[v1] == pVgroup) {
-      for (int32_t v2 = v1; v2 < pDb->numOfVgroups - 1; ++v2) {
-        pDb->vgList[v2] = pDb->vgList[v2 + 1];
-      }
-      pDb->numOfVgroups--;
-      pDb->vgList[pDb->numOfVgroups] = NULL;
-      break;
-    }
-  }
-
-  pthread_mutex_unlock(&pDb->mutex);
-}
-
-void mnodeCleanupDbs() {
-  tpCleanUp();
-  sdbCloseTable(tsDbRid);
-  tsDbSdb = NULL;
-}
-
-
-
-
-static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  int32_t cols = 0;
-
-  SSchema *pSchema = pMeta->schema;
-  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) return 0;
-
-  pShow->bytes[cols] = (TSDB_DB_NAME_LEN - 1) + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "name");
-  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] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "ntables");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-#ifndef __CLOUD_VERSION__
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
-    pShow->bytes[cols] = 4;
-    pSchema[cols].type = TSDB_DATA_TYPE_INT;
-    strcpy(pSchema[cols].name, "vgroups");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-#ifndef __CLOUD_VERSION__
-  }
-#endif
-
-#ifndef __CLOUD_VERSION__
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
-    pShow->bytes[cols] = 2;
-    pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-    strcpy(pSchema[cols].name, "replica");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-
-    pShow->bytes[cols] = 2;
-    pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-    strcpy(pSchema[cols].name, "quorum");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-
-    pShow->bytes[cols] = 2;
-    pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-    strcpy(pSchema[cols].name, "days");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-#ifndef __CLOUD_VERSION__
-  }
-#endif
-
-  pShow->bytes[cols] = 24 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-
-#ifdef _STORAGE  
-  strcpy(pSchema[cols].name, "keep0,keep1,keep2");
-#else
-  strcpy(pSchema[cols].name, "keep");
-#endif
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-#ifndef __CLOUD_VERSION__
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
-
-    pShow->bytes[cols] = 4;
-    pSchema[cols].type = TSDB_DATA_TYPE_INT;
-    strcpy(pSchema[cols].name, "cache(MB)");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-    
-    pShow->bytes[cols] = 4;
-    pSchema[cols].type = TSDB_DATA_TYPE_INT;
-    strcpy(pSchema[cols].name, "blocks");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-    
-    pShow->bytes[cols] = 4;
-    pSchema[cols].type = TSDB_DATA_TYPE_INT;
-    strcpy(pSchema[cols].name, "minrows");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-
-    pShow->bytes[cols] = 4;
-    pSchema[cols].type = TSDB_DATA_TYPE_INT;
-    strcpy(pSchema[cols].name, "maxrows");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-
-    pShow->bytes[cols] = 1;
-    pSchema[cols].type = TSDB_DATA_TYPE_TINYINT;
-    strcpy(pSchema[cols].name, "wallevel");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-
-    pShow->bytes[cols] = 4;
-    pSchema[cols].type = TSDB_DATA_TYPE_INT;
-    strcpy(pSchema[cols].name, "fsync");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-
-    pShow->bytes[cols] = 1;
-    pSchema[cols].type = TSDB_DATA_TYPE_TINYINT;
-    strcpy(pSchema[cols].name, "comp");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-
-    pShow->bytes[cols] = 1;
-    pSchema[cols].type = TSDB_DATA_TYPE_TINYINT;
-    strcpy(pSchema[cols].name, "cachelast");
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-#ifndef __CLOUD_VERSION__
-  }
-#endif
-
-  pShow->bytes[cols] = 3 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "precision");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 1;
-  pSchema[cols].type = TSDB_DATA_TYPE_TINYINT;
-  strcpy(pSchema[cols].name, "update");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 10 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "status");
-  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->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-  pShow->numOfRows = pUser->pAcct->acctInfo.numOfDbs;
-
-  mnodeDecUserRef(pUser);
-  return 0;
-}
-
-char *mnodeGetDbStr(char *src) {
-  char *pos = strstr(src, TS_PATH_DELIMITER);
-  if (pos != NULL) ++pos;
-
-  return pos;
-}
-
-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 = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) return 0;
-
-  while (numOfRows < rows) {
-    pShow->pIter = mnodeGetNextDb(pShow->pIter, &pDb);
-
-    if (pDb == NULL) break;
-    if (pDb->pAcct != pUser->pAcct || pDb->status != TSDB_DB_STATUS_READY) {
-      mnodeDecDbRef(pDb);
-      continue;
-    }
-
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;  
-    char* name = mnodeGetDbStr(pDb->name);
-    if (name != NULL) {
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, name, pShow->bytes[cols]);
-    } else {
-      STR_TO_VARSTR(pWrite, "NULL");
-    }
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pDb->createdTime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *)pWrite = pDb->numOfTables;
-    cols++;
-
-#ifndef __CLOUD_VERSION__
-    if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int32_t *)pWrite = pDb->numOfVgroups;
-      cols++;
-#ifndef __CLOUD_VERSION__
-    }
-#endif
-
-#ifndef __CLOUD_VERSION__
-    if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int16_t *)pWrite = pDb->cfg.replications;
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int16_t *)pWrite = pDb->cfg.quorum;
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int16_t *)pWrite = pDb->cfg.daysPerFile;
-      cols++;
-#ifndef __CLOUD_VERSION__
-    }
-#endif
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    
-    char tmp[128] = {0};
-#ifdef _STORAGE      
-    if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) { 
-      sprintf(tmp, "%d,%d,%d", pDb->cfg.daysToKeep1, pDb->cfg.daysToKeep2, pDb->cfg.daysToKeep0);
-    } else {
-      sprintf(tmp, "%d,%d,%d", pDb->cfg.daysToKeep0, pDb->cfg.daysToKeep1, pDb->cfg.daysToKeep2);
-    }
-#else
-    sprintf(tmp, "%d", pDb->cfg.daysToKeep2);
-#endif
-    STR_WITH_SIZE_TO_VARSTR(pWrite, tmp, strlen(tmp));
-    cols++;
-
-#ifndef __CLOUD_VERSION__
-    if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int32_t *)pWrite = pDb->cfg.cacheBlockSize;
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int32_t *)pWrite = pDb->cfg.totalBlocks;
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int32_t *)pWrite = pDb->cfg.minRowsPerFileBlock;
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int32_t *)pWrite = pDb->cfg.maxRowsPerFileBlock;
-      cols++;
-      
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int8_t *)pWrite = pDb->cfg.walLevel;
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int32_t *)pWrite = pDb->cfg.fsyncPeriod;
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int8_t *)pWrite = pDb->cfg.compression;
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int8_t *)pWrite = pDb->cfg.cacheLastRow;
-      cols++;
-#ifndef __CLOUD_VERSION__
-    }
-#endif
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    char *prec = NULL;
-    switch (pDb->cfg.precision) {
-      case TSDB_TIME_PRECISION_MILLI: prec = TSDB_TIME_PRECISION_MILLI_STR; break;
-      case TSDB_TIME_PRECISION_MICRO: prec = TSDB_TIME_PRECISION_MICRO_STR; break;
-      case TSDB_TIME_PRECISION_NANO:  prec = TSDB_TIME_PRECISION_NANO_STR;  break;
-      default: assert(false); break;
-    }
-    STR_WITH_SIZE_TO_VARSTR(pWrite, prec, 2);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int8_t *)pWrite = pDb->cfg.update;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    if (pDb->status == TSDB_DB_STATUS_READY) {
-      const char *src = "ready";
-      STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
-    } else {
-      const char *src = "dropping";
-      STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
-    }
-    cols++;
-
-    numOfRows++;
-    mnodeDecDbRef(pDb);
-  }
-
-  pShow->numOfReads += numOfRows;
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-
-  mnodeDecUserRef(pUser);
-  return numOfRows;
-}
-
-void mnodeAddSuperTableIntoDb(SDbObj *pDb) {
-  atomic_add_fetch_32(&pDb->numOfSuperTables, 1);
-}
-
-void mnodeRemoveSuperTableFromDb(SDbObj *pDb) {
-  atomic_add_fetch_32(&pDb->numOfSuperTables, -1);
-}
-
-void mnodeAddTableIntoDb(SDbObj *pDb) {
-  atomic_add_fetch_32(&pDb->numOfTables, 1);
-}
-
-void mnodeRemoveTableFromDb(SDbObj *pDb) {
-  atomic_add_fetch_32(&pDb->numOfTables, -1);
-}
-
-static int32_t mnodeSetDbDropping(SDbObj *pDb) {
-  if (pDb->status) return TSDB_CODE_SUCCESS;
-
-  pDb->status = true;
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsDbSdb,
-    .pObj   = pDb
-  };
-
-  int32_t code = sdbUpdateRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("db:%s, failed to set dropping state, reason:%s", pDb->name, tstrerror(code));
-  }
-
-  return code;
-}
-
-static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg) {
-  SCreateDbMsg *pCreate    = pMsg->rpcMsg.pCont;  
-  pCreate->maxTables       = htonl(pCreate->maxTables);
-  pCreate->cacheBlockSize  = htonl(pCreate->cacheBlockSize);
-  pCreate->totalBlocks     = htonl(pCreate->totalBlocks);
-  pCreate->daysPerFile     = htonl(pCreate->daysPerFile);
-  pCreate->daysToKeep0     = htonl(pCreate->daysToKeep0);
-  pCreate->daysToKeep1     = htonl(pCreate->daysToKeep1);
-  pCreate->daysToKeep2     = htonl(pCreate->daysToKeep2);
-  pCreate->commitTime      = htonl(pCreate->commitTime);
-  pCreate->fsyncPeriod     = htonl(pCreate->fsyncPeriod);
-  pCreate->partitions      = htons(pCreate->partitions);
-  pCreate->minRowsPerFileBlock = htonl(pCreate->minRowsPerFileBlock);
-  pCreate->maxRowsPerFileBlock = htonl(pCreate->maxRowsPerFileBlock);
-  
-  int32_t code;
-  if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
-    code = TSDB_CODE_GRANT_EXPIRED;
-  } else if (!pMsg->pUser->writeAuth) {
-    code = TSDB_CODE_MND_NO_RIGHTS;
-  } else {
-    code = mnodeCreateDb(pMsg->pUser->pAcct, pCreate, pMsg);
-  }
-
-  return code;
-}
-
-static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SAlterDbMsg *pAlter) {
-  SDbCfg  newCfg = pDb->cfg;
-  int32_t maxTables      = htonl(pAlter->maxTables);
-  int32_t cacheBlockSize = htonl(pAlter->cacheBlockSize);
-  int32_t totalBlocks    = htonl(pAlter->totalBlocks);
-  int32_t daysPerFile    = htonl(pAlter->daysPerFile);
-  int32_t daysToKeep0    = htonl(pAlter->daysToKeep0);
-  int32_t daysToKeep1    = htonl(pAlter->daysToKeep1);
-  int32_t daysToKeep2    = htonl(pAlter->daysToKeep2);
-  int32_t minRows        = htonl(pAlter->minRowsPerFileBlock);
-  int32_t maxRows        = htonl(pAlter->maxRowsPerFileBlock);
-  int32_t commitTime     = htonl(pAlter->commitTime);
-  int32_t fsyncPeriod    = htonl(pAlter->fsyncPeriod);
-  int8_t  compression    = pAlter->compression;
-  int8_t  walLevel       = pAlter->walLevel;
-  int8_t  replications   = pAlter->replications;
-  int8_t  quorum         = pAlter->quorum;
-  int8_t  precision      = pAlter->precision;
-  int8_t  update         = pAlter->update;
-  int8_t  cacheLastRow   = pAlter->cacheLastRow;
-  int8_t  dbType         = pAlter->dbType;
-  int16_t partitions     = htons(pAlter->partitions);
-  
-  terrno = TSDB_CODE_SUCCESS;
-
-  //UPGRATE FROM LOW VERSION, reorder it
-  if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {
-    int32_t t = pDb->cfg.daysToKeep0;
-    newCfg.daysToKeep0 = pDb->cfg.daysToKeep1;
-    newCfg.daysToKeep1 = pDb->cfg.daysToKeep2;
-    newCfg.daysToKeep2 = t;
-  }
-
-  if (cacheBlockSize > 0 && cacheBlockSize != pDb->cfg.cacheBlockSize) {
-    mError("db:%s, can't alter cache option", pDb->name);
-    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (totalBlocks > 0 && totalBlocks != pDb->cfg.totalBlocks) {
-    mInfo("db:%s, blocks:%d change to %d", pDb->name, pDb->cfg.totalBlocks, totalBlocks);
-    newCfg.totalBlocks = totalBlocks;
-  }
-
-  if (maxTables > 0) {
-    mInfo("db:%s, maxTables:%d change to %d", pDb->name, pDb->cfg.maxTables, maxTables);
-    newCfg.maxTables = maxTables;
-    if (newCfg.maxTables < pDb->cfg.maxTables) {
-      mError("db:%s, tables:%d should larger than origin:%d", pDb->name, newCfg.maxTables, pDb->cfg.maxTables);
-      terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-    }
-  }
-
-  if (daysPerFile > 0 && daysPerFile != pDb->cfg.daysPerFile) {
-    mError("db:%s, can't alter days option", pDb->name);
-    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (daysToKeep0 > 0 && (daysToKeep0 != pDb->cfg.daysToKeep0 || newCfg.daysToKeep0 != pDb->cfg.daysToKeep0)) {
-    mDebug("db:%s, daysToKeep:%d change to %d", pDb->name, pDb->cfg.daysToKeep0, daysToKeep0);
-    newCfg.daysToKeep0 = daysToKeep0;
-  }
-
-  if (daysToKeep1 > 0 && (daysToKeep1 != pDb->cfg.daysToKeep1 || newCfg.daysToKeep1 != pDb->cfg.daysToKeep1)) {
-    mDebug("db:%s, daysToKeep1:%d change to %d", pDb->name, pDb->cfg.daysToKeep1, daysToKeep1);
-    newCfg.daysToKeep1 = daysToKeep1;
-  }
-
-  if (daysToKeep2 > 0 && (daysToKeep2 != pDb->cfg.daysToKeep2 || newCfg.daysToKeep2 != pDb->cfg.daysToKeep2)) {
-    mDebug("db:%s, daysToKeep2:%d change to %d", pDb->name, pDb->cfg.daysToKeep2, daysToKeep2);
-    newCfg.daysToKeep2 = daysToKeep2;
-  }
-
-  if (minRows > 0 && minRows != pDb->cfg.minRowsPerFileBlock) {
-    mError("db:%s, can't alter minRows option", pDb->name);
-    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (maxRows > 0 && maxRows != pDb->cfg.maxRowsPerFileBlock) {
-    mError("db:%s, can't alter maxRows option", pDb->name);
-    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (commitTime > 0 && commitTime != pDb->cfg.commitTime) {
-    mError("db:%s, can't alter commitTime option", pDb->name);
-    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (precision > 0 && precision != pDb->cfg.precision) {
-    mError("db:%s, can't alter precision option", pDb->name);
-    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-  }
-
-  if (compression >= 0 && compression != pDb->cfg.compression) {
-    mDebug("db:%s, compression:%d change to %d", pDb->name, pDb->cfg.compression, compression);
-    newCfg.compression = compression;
-  }
-
-  if (walLevel > 0 && walLevel != pDb->cfg.walLevel) {
-    mDebug("db:%s, walLevel:%d change to %d", pDb->name, pDb->cfg.walLevel, walLevel);
-    newCfg.walLevel = walLevel;
-  }
-
-  if (fsyncPeriod >= 0 && fsyncPeriod != pDb->cfg.fsyncPeriod) {
-    mDebug("db:%s, fsyncPeriod:%d change to %d", pDb->name, pDb->cfg.fsyncPeriod, fsyncPeriod);
-    newCfg.fsyncPeriod = fsyncPeriod;
-  }
-
-  if (replications > 0 && replications != pDb->cfg.replications) {
-    mDebug("db:%s, replications:%d change to %d", pDb->name, pDb->cfg.replications, replications);
-    newCfg.replications = replications;
-
-    if (pDb->cfg.walLevel < TSDB_MIN_WAL_LEVEL) {
-      mError("db:%s, walLevel:%d must be greater than 0", pDb->name, pDb->cfg.walLevel);
-      terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-    }
-
-    if (replications > mnodeGetDnodesNum()) {
-      mError("db:%s, no enough dnode to change replica:%d", pDb->name, replications);
-      terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
-    }
-
-    if (pDb->cfg.replications - replications >= 2) {
-      mError("db:%s, replica number can't change from %d to %d", pDb->name, pDb->cfg.replications, replications);
-      terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-    }
-  }
-
-  if (quorum >= 0 && quorum != pDb->cfg.quorum) {
-    mDebug("db:%s, quorum:%d change to %d", pDb->name, pDb->cfg.quorum, quorum);
-    newCfg.quorum = quorum;
-  }
-
-  if (update >= 0 && update != pDb->cfg.update) {
-#if 0
-    mDebug("db:%s, update:%d change to %d", pDb->name, pDb->cfg.update, update);
-    newCfg.update = update;
-#else
-    mError("db:%s, can't alter update option", pDb->name);
-    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-#endif
-  }
-
-  if (cacheLastRow >= 0 && cacheLastRow != pDb->cfg.cacheLastRow) {
-    mDebug("db:%s, cacheLastRow:%d change to %d", pDb->name, pDb->cfg.cacheLastRow, cacheLastRow);
-    newCfg.cacheLastRow = cacheLastRow;
-  }
-
-  if (dbType >= 0 && dbType != pDb->cfg.dbType) {
-    mDebug("db:%s, dbType:%d change to %d", pDb->name, pDb->cfg.dbType, dbType);
-    newCfg.dbType = dbType;
-  }
-
-  if (partitions >= 0 && partitions != pDb->cfg.partitions) {
-    mDebug("db:%s, partitions:%d change to %d", pDb->name, pDb->cfg.partitions, partitions);
-    newCfg.partitions = partitions;
-  }
-
-// community version can only change daysToKeep
-// but enterprise version can change all daysToKeep options
-#ifndef _STORAGE
-  newCfg.daysToKeep1 = newCfg.daysToKeep0;
-  newCfg.daysToKeep2 = newCfg.daysToKeep0;
-#endif
-
-  return newCfg;
-}
-
-static int32_t mnodeAlterDbFp(SMnodeMsg *pMsg) {
-  SDbObj *pDb = pMsg->pDb;
-
-  void *pIter = NULL;
-  SVgObj *pVgroup = NULL;
-  pMsg->expected = 0;
-  while (1) {
-    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
-    if (pVgroup == NULL) break;
-    if (pVgroup->pDb == pDb) {
-      pMsg->expected += pVgroup->numOfVnodes;
-      mnodeSendAlterVgroupMsg(pVgroup,pMsg);
-    }
-    mnodeDecVgroupRef(pVgroup);
-  }
-
-  mDebug("db:%s, all vgroups is altered", pDb->name);
-  mLInfo("db:%s, is alterd by %s", pDb->name, mnodeGetUserFromMsg(pMsg));
-
-  // in case there is no vnode for this db currently(no table in db,etc.)
-  if (pMsg->expected == 0) {
-    SSdbRow row = {
-      .type    = SDB_OPER_GLOBAL,
-      .pTable  = tsDbSdb,
-      .pObj    = pDb,
-      .pMsg    = pMsg,
-    };
-
-    return sdbUpdateRow(&row);
-  }
-
-  //bnNotify();
-
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-int mnodeInsertAlterDbRow(SDbObj *pDb, void *pMsg) {
-  SSdbRow desc = {
-    .type    = SDB_OPER_GLOBAL,
-    .pTable  = tsDbSdb,
-    .pObj    = pDb,
-    .pMsg    = pMsg,
-  };
-
-  return sdbUpdateRow(&desc);
-}
-
-static int32_t mnodeAlterDb(SDbObj *pDb, SAlterDbMsg *pAlter, void *pMsg) {
-  mDebug("db:%s, type:%d do alter operation", pDb->name, pDb->cfg.dbType);
-
-  SDbCfg newCfg = mnodeGetAlterDbOption(pDb, pAlter);
-  if (terrno != TSDB_CODE_SUCCESS) {
-    return terrno;
-  }
-
-  int32_t code = mnodeCheckDbCfg(&newCfg);
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  if (memcmp(&newCfg, &pDb->cfg, sizeof(SDbCfg)) != 0) {
-    pDb->cfg = newCfg;
-    pDb->dbCfgVersion++;
-    SSdbRow row = {
-      .type    = SDB_OPER_GLOBAL,
-      .pTable  = tsDbSdb,
-      .pObj    = pDb,
-      .pMsg    = pMsg,
-      .fpReq   = mnodeAlterDbFp
-    };
-
-    code = sdbUpdateRow(&row);
-    if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-      mError("db:%s, failed to alter, reason:%s", pDb->name, tstrerror(code));
-    }
-}
-
-  return code;
-}
-
-int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg) {
-  SAlterDbMsg *pAlter = pMsg->rpcMsg.pCont;
-  mDebug("db:%s, alter db msg is received from thandle:%p, dbType:%d", pAlter->db, pMsg->rpcMsg.handle, pAlter->dbType);
-
-  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pAlter->db);
-  if (pMsg->pDb == NULL) {
-    mError("db:%s, failed to alter, invalid db", pAlter->db);
-    return TSDB_CODE_MND_INVALID_DB;
-  }
-  
-  if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pAlter->db, pMsg->pDb->status);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-  return mnodeAlterDb(pMsg->pDb, pAlter, pMsg);
-}
-
-static int32_t mnodeDropDbCb(SMnodeMsg *pMsg, int32_t code) {
-  SDbObj *pDb = pMsg->pDb;
-  if (code != TSDB_CODE_SUCCESS) {
-    mError("db:%s, failed to drop from sdb, reason:%s", pDb->name, tstrerror(code));
-  } else {
-    mLInfo("db:%s, is dropped by %s", pDb->name, mnodeGetUserFromMsg(pMsg));
-  }
-
-  return code;
-}
-
-static int32_t mnodeDropDb(SMnodeMsg *pMsg) {
-  if (pMsg == NULL) return TSDB_CODE_MND_APP_ERROR;
-  
-  SDbObj *pDb = pMsg->pDb;
-  mInfo("db:%s, drop db from sdb", pDb->name);
-
-  SSdbRow row = {
-    .type    = SDB_OPER_GLOBAL,
-    .pTable  = tsDbSdb,
-    .pObj    = pDb,
-    .pMsg    = pMsg,
-    .fpRsp   = mnodeDropDbCb
-  };
-
-  int32_t code = sdbDeleteRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("db:%s, failed to drop, reason:%s", pDb->name, tstrerror(code));
-  }
-
-  return code;
-}
-
-static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg) {
-  SDropDbMsg *pDrop = pMsg->rpcMsg.pCont;
-  mDebug("db:%s, drop db msg is received from thandle:%p", pDrop->db, pMsg->rpcMsg.handle);
-
-  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pDrop->db);
-  if (pMsg->pDb == NULL) {
-    if (pDrop->ignoreNotExists) {
-      mDebug("db:%s, db is not exist, treat as success", pDrop->db);
-      return TSDB_CODE_SUCCESS;
-    } else {
-      mError("db:%s, failed to drop, invalid db", pDrop->db);
-      return TSDB_CODE_MND_INVALID_DB;
-    }
-  }
-
-#if 0
-  if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) {
-    mError("db:%s, can't drop monitor database", pDrop->db);
-    return TSDB_CODE_MND_MONITOR_DB_FORBIDDEN;
-  }
-#endif   
-
-  int32_t code = mnodeSetDbDropping(pMsg->pDb);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("db:%s, failed to drop, reason:%s", pDrop->db, tstrerror(code));
-    return code;
-  }
-
-  mnodeSendDropAllDbVgroupsMsg(pMsg->pDb);
-
-  mDebug("db:%s, all vgroups is dropped", pMsg->pDb->name);
-  return mnodeDropDb(pMsg);
-}
-
-static int32_t mnodeSyncDb(SDbObj *pDb, SMnodeMsg *pMsg) {
-  void *pIter = NULL;
-  SVgObj *pVgroup = NULL;
-  while (1) {
-    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
-    if (pVgroup == NULL) break;
-    if (pVgroup->pDb == pDb) {
-      mnodeSendSyncVgroupMsg(pVgroup);
-    }
-    mnodeDecVgroupRef(pVgroup);
-  }
-
-  mLInfo("db:%s, is synced by %s", pDb->name, mnodeGetUserFromMsg(pMsg));
-
-  return TSDB_CODE_SUCCESS;
-}
-
-
-static int32_t mnodeCompact(SDbObj *pDb, SCompactMsg *pCompactMsg) {
-  int32_t count = ntohs(pCompactMsg->numOfVgroup);  
-  int32_t *buf  = malloc(sizeof(int32_t) * count); 
-  if (buf == NULL) {
-    return  TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-  for (int32_t i = 0; i < count; i++) {
-    buf[i] = ntohs(pCompactMsg->vgid[i]);
-  }
-   
-  // copy from mnodeSyncDb, so ugly
-  for (int32_t i = 0; i < count; i++) {
-    SVgObj *pVgroup = NULL;
-    void *pIter = NULL;
-    bool  valid = false;
-    while (1) {
-      pIter = mnodeGetNextVgroup(pIter, &pVgroup);
-      if (pVgroup == NULL) break;
-      if (pVgroup->pDb == pDb && pVgroup->vgId == buf[i]) {
-        mnodeSendCompactVgroupMsg(pVgroup);
-        mnodeDecVgroupRef(pVgroup);
-        valid = true; 
-        break;
-      }
-      mnodeDecVgroupRef(pVgroup);
-    }
-    if (valid == false) {
-      mLError("db:%s, cannot find valid vgId: %d", pDb->name, buf[i]);
-    }
-  }
-  free(buf); 
-
-  mLInfo("db:%s, trigger compact", pDb->name);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeProcessSyncDbMsg(SMnodeMsg *pMsg) {
-  SSyncDbMsg *pSyncDb = pMsg->rpcMsg.pCont;
-  mDebug("db:%s, syncdb is received from thandle:%p, ignore:%d", pSyncDb->db, pMsg->rpcMsg.handle, pSyncDb->ignoreNotExists);
-
-  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pSyncDb->db);
-  if (pMsg->pDb == NULL) {
-        if (pSyncDb->ignoreNotExists) {
-          mDebug("db:%s, db is not exist, treat as success", pSyncDb->db);
-          return TSDB_CODE_SUCCESS;
-        } else {
-          mError("db:%s, failed to sync, invalid db", pSyncDb->db);
-          return TSDB_CODE_MND_INVALID_DB;
-        }
-  }
-
-  if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pSyncDb->db, pMsg->pDb->status);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-  return mnodeSyncDb(pMsg->pDb, pMsg);
-}
-static int32_t mnodeProcessCompactMsg(SMnodeMsg *pMsg) {
-  SCompactMsg *pCompact = pMsg->rpcMsg.pCont;
-  mDebug("db:%s, compact is received from thandle:%p", pCompact->db, pMsg->rpcMsg.handle);
-  
-  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pCompact->db);
-  if (pMsg->pDb == NULL) return TSDB_CODE_MND_DB_NOT_SELECTED;
-  
-  if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping, ignore compact request", pCompact->db, pMsg->pDb->status);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  } 
-
-  return mnodeCompact(pMsg->pDb, pCompact);
-}
-
-void  mnodeDropAllDbs(SAcctObj *pAcct)  {
-  int32_t numOfDbs = 0;
-  SDbObj *pDb = NULL;
-  void *  pIter = NULL;
-
-  mInfo("acct:%s, all dbs will be dropped from sdb", pAcct->user);
-
-  while (1) {
-    pIter = mnodeGetNextDb(pIter, &pDb);
-    if (pDb == NULL) break;
-
-    if (pDb->pAcct == pAcct) {
-      mInfo("db:%s, drop db from sdb for acct:%s is dropped", pDb->name, pAcct->user);
-      SSdbRow row = {
-        .type   = SDB_OPER_LOCAL,
-        .pTable = tsDbSdb,
-        .pObj   = pDb
-      };
-      
-      sdbDeleteRow(&row);
-      numOfDbs++;
-    }
-    mnodeDecDbRef(pDb);
-  }
-
-  mInfo("acct:%s, all dbs:%d is dropped from sdb", pAcct->user, numOfDbs);
-}
-
-int32_t mnodeCompactDbs() {
-  void *pIter = NULL;
-  SDbObj *pDb = NULL;
-
-  mInfo("start to compact dbs table...");
-
-  while (1) {
-    pIter = mnodeGetNextDb(pIter, &pDb);
-    if (pDb == NULL) break;
-
-    SSdbRow row = {
-      .type     = SDB_OPER_GLOBAL,
-      .pTable   = tsDbSdb,
-      .pObj     = pDb,
-      .rowSize  = sizeof(SDbObj),
-    };
-
-    mInfo("compact dbs %s", pDb->name);
-    
-    sdbInsertCompactRow(&row);
-  }
-
-  mInfo("end to compact dbs table...");
-
-  return 0; 
-}

src/mnode/src/mnodeDnode.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "tgrant.h"
-#include "tglobal.h"
-#include "tconfig.h"
-#include "tutil.h"
-#include "tsocket.h"
-#include "tbn.h"
-#include "tsync.h"
-#include "tdataformat.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeDnode.h"
-#include "mnodeDb.h"
-#include "mnodeMnode.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeUser.h"
-#include "mnodeVgroup.h"
-#include "mnodeWrite.h"
-#include "mnodePeer.h"
-#include "mnodeCluster.h"
-
-int64_t        tsAccessSquence = 0;
-int64_t        tsDnodeRid = -1;
-static void *  tsDnodeSdb = NULL;
-static int32_t tsDnodeUpdateSize = 0;
-extern void *  tsMnodeSdb;
-extern void *  tsVgroupSdb;
-
-static SDnodeEps*tsDnodeEps;
-static int32_t   tsDnodeEpsSize;
-static pthread_mutex_t tsDnodeEpsMutex;
-
-static int32_t mnodeCreateDnode(char *ep, SMnodeMsg *pMsg);
-static int32_t mnodeProcessCreateDnodeMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessDropDnodeMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessCfgDnodeMsg(SMnodeMsg *pMsg);
-static void    mnodeProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) ;
-static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg);
-static int32_t mnodeGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void    mnodeUpdateDnodeEps();
-
-static char* offlineReason[] = {
-  "",
-  "status msg timeout",
-  "status not received",
-  "status reset by mnode",
-  "version not match",
-  "dnodeId not match",
-  "clusterId not match",
-  "numOfMnodes not match",
-  "balance not match",
-  "mnEqualVn not match",
-  "offThreshold not match",
-  "interval not match",
-  "maxTabPerVn not match",
-  "maxVgPerDb not match",
-  "arbitrator not match",
-  "timezone not match",
-  "locale not match",
-  "charset not match",
-  "unknown",
-};
-
-static int32_t mnodeDnodeActionDestroy(SSdbRow *pRow) {
-  tfree(pRow->pObj);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionInsert(SSdbRow *pRow) {
-  SDnodeObj *pDnode = pRow->pObj;
-  if (pDnode->status != TAOS_DN_STATUS_DROPPING) {
-    pDnode->status = TAOS_DN_STATUS_OFFLINE;
-    pDnode->lastAccess = tsAccessSquence;
-    pDnode->offlineReason = TAOS_DN_OFF_STATUS_NOT_RECEIVED;
-  }
-
-  pDnode->customScore = 0;
-
-  dnodeUpdateEp(pDnode->dnodeId, pDnode->dnodeEp, pDnode->dnodeFqdn, &pDnode->dnodePort);
-  mnodeUpdateDnodeEps();
-
-  mInfo("dnode:%d, fqdn:%s ep:%s port:%d is created", pDnode->dnodeId, pDnode->dnodeFqdn, pDnode->dnodeEp, pDnode->dnodePort);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionDelete(SSdbRow *pRow) {
-  SDnodeObj *pDnode = pRow->pObj;
- 
-  mnodeDropMnodeLocal(pDnode->dnodeId);
-  bnNotify();
-  mnodeUpdateDnodeEps();
-
-  mDebug("dnode:%d, all vgroups is dropped from sdb", pDnode->dnodeId);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionUpdate(SSdbRow *pRow) {
-  SDnodeObj *pNew = pRow->pObj;
-  SDnodeObj *pDnode = mnodeGetDnode(pNew->dnodeId);
-  if (pDnode != NULL && pNew != pDnode) {
-    memcpy(pDnode, pNew, pRow->rowSize);
-    free(pNew);
-  }
-  mnodeDecDnodeRef(pDnode);
-
-  mnodeUpdateDnodeEps();
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionEncode(SSdbRow *pRow) {
-  SDnodeObj *pDnode = pRow->pObj;
-  memcpy(pRow->rowData, pDnode, tsDnodeUpdateSize);
-  pRow->rowSize = tsDnodeUpdateSize;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionDecode(SSdbRow *pRow) {
-  SDnodeObj *pDnode = (SDnodeObj *) calloc(1, sizeof(SDnodeObj));
-  if (pDnode == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
-  memcpy(pDnode, pRow->rowData, tsDnodeUpdateSize);
-  pRow->pObj = pDnode;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionRestored() {
-  int64_t numOfRows = sdbGetNumOfRows(tsDnodeSdb);
-  if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
-    mInfo("dnode first deploy, create dnode:%s", tsLocalEp);
-    mnodeCreateDnode(tsLocalEp, NULL);
-    SDnodeObj *pDnode = mnodeGetDnodeByEp(tsLocalEp);
-    if (pDnode != NULL) {
-      mnodeCreateMnode(pDnode->dnodeId, pDnode->dnodeEp, false);
-      mnodeDecDnodeRef(pDnode);
-    }
-  }
-
-  mnodeUpdateDnodeEps();
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitDnodes() {
-  SDnodeObj tObj;
-  tsDnodeUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-  pthread_mutex_init(&tsDnodeEpsMutex, NULL);
-
-  SSdbTableDesc desc = {
-    .id           = SDB_TABLE_DNODE,
-    .name         = "dnodes",
-    .hashSessions = TSDB_DEFAULT_DNODES_HASH_SIZE,
-    .maxRowSize   = tsDnodeUpdateSize,
-    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
-    .keyType      = SDB_KEY_AUTO,
-    .fpInsert     = mnodeDnodeActionInsert,
-    .fpDelete     = mnodeDnodeActionDelete,
-    .fpUpdate     = mnodeDnodeActionUpdate,
-    .fpEncode     = mnodeDnodeActionEncode,
-    .fpDecode     = mnodeDnodeActionDecode,
-    .fpDestroy    = mnodeDnodeActionDestroy,
-    .fpRestored   = mnodeDnodeActionRestored
-  };
-
-  tsDnodeRid = sdbOpenTable(&desc);
-  tsDnodeSdb = sdbGetTableByRid(tsDnodeRid);
-  if (tsDnodeSdb == NULL) {
-    mError("failed to init dnodes data");
-    return -1;
-  }
-
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DNODE, mnodeProcessCreateDnodeMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_DNODE, mnodeProcessDropDnodeMsg); 
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CONFIG_DNODE, mnodeProcessCfgDnodeMsg);
-
-  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP, mnodeProcessCfgDnodeMsgRsp);
-  mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_STATUS, mnodeProcessDnodeStatusMsg);
-
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_MODULE, mnodeGetModuleMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_MODULE, mnodeRetrieveModules);
-
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VARIABLES, mnodeGetConfigMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VARIABLES, mnodeRetrieveConfigs);
-
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VNODES, mnodeGetVnodeMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VNODES, mnodeRetrieveVnodes);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_VNODES, mnodeCancelGetNextVgroup);
-
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DNODE, mnodeGetDnodeMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DNODE, mnodeRetrieveDnodes);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_DNODE, mnodeCancelGetNextDnode);
- 
-  mDebug("table:dnodes table is created");
-  return 0;
-}
-
-void mnodeCleanupDnodes() {
-  sdbCloseTable(tsDnodeRid);
-  pthread_mutex_destroy(&tsDnodeEpsMutex);
-  free(tsDnodeEps);
-  tsDnodeEps = NULL;
-  tsDnodeSdb = NULL;
-}
-
-void *mnodeGetNextDnode(void *pIter, SDnodeObj **pDnode) { 
-  return sdbFetchRow(tsDnodeSdb, pIter, (void **)pDnode); 
-}
-
-void mnodeCancelGetNextDnode(void *pIter) {
-  sdbFreeIter(tsDnodeSdb, pIter);
-}
-
-int32_t mnodeGetDnodesNum() {
-  return (int32_t)sdbGetNumOfRows(tsDnodeSdb);
-}
-
-int32_t mnodeGetOnlinDnodesCpuCoreNum() {
-  SDnodeObj *pDnode = NULL;
-  void *     pIter = NULL;
-  int32_t    cpuCores = 0;
-
-  while (1) {
-    pIter = mnodeGetNextDnode(pIter, &pDnode);
-    if (pDnode == NULL) break;
-    if (pDnode->status != TAOS_DN_STATUS_OFFLINE) {
-      cpuCores += pDnode->numOfCores;
-    }
-    mnodeDecDnodeRef(pDnode);
-  }
-
-  if (cpuCores < 2) cpuCores = 2;
-  return cpuCores;
-}
-
-int32_t mnodeGetOnlineDnodesNum() {
-  SDnodeObj *pDnode = NULL;
-  void *     pIter = NULL;
-  int32_t    onlineDnodes = 0;
-
-  while (1) {
-    pIter = mnodeGetNextDnode(pIter, &pDnode);
-    if (pDnode == NULL) break;
-    if (pDnode->status != TAOS_DN_STATUS_OFFLINE) onlineDnodes++;
-    mnodeDecDnodeRef(pDnode);
-  }
-
-  return onlineDnodes;
-}
-
-void mnodeGetOnlineAndTotalDnodesNum(int32_t *onlineNum, int32_t *totalNum) {
-  SDnodeObj *pDnode = NULL;
-  void *     pIter = NULL;
-  int32_t    onlineDnodes = 0, totalDnodes = 0;
-
-  while (1) {
-    pIter = mnodeGetNextDnode(pIter, &pDnode);
-    if (pDnode == NULL) break;
-    if (pDnode->status != TAOS_DN_STATUS_OFFLINE) ++onlineDnodes;
-    ++totalDnodes;
-    mnodeDecDnodeRef(pDnode);
-  }
-
-  if (onlineNum) {
-    *onlineNum = onlineDnodes;
-  }
-
-  if (totalNum) {
-    *totalNum = totalDnodes;
-  }
-}
-
-void *mnodeGetDnode(int32_t dnodeId) {
-  return sdbGetRow(tsDnodeSdb, &dnodeId);
-}
-
-void *mnodeGetDnodeByEp(char *ep) {
-  SDnodeObj *pDnode = NULL;
-  void *     pIter = NULL;
-
-  while (1) {
-    pIter = mnodeGetNextDnode(pIter, &pDnode);
-    if (pDnode == NULL) break;
-    if (strncasecmp(ep, pDnode->dnodeEp, TSDB_EP_LEN) == 0) {
-      mnodeCancelGetNextDnode(pIter);
-      return pDnode;
-    }
-    mnodeDecDnodeRef(pDnode);
-  }
-
-
-  return NULL;
-}
-
-void mnodeIncDnodeRef(SDnodeObj *pDnode) {
-  sdbIncRef(tsDnodeSdb, pDnode);
-}
-
-void mnodeDecDnodeRef(SDnodeObj *pDnode) {
-  sdbDecRef(tsDnodeSdb, pDnode);
-}
-
-void mnodeUpdateDnode(SDnodeObj *pDnode) {
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsDnodeSdb,
-    .pObj   = pDnode
-  };
-
-  int32_t code = sdbUpdateRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("dnode:%d, failed update", pDnode->dnodeId);
-  }
-}
-
-static int32_t mnodeProcessCfgDnodeMsg(SMnodeMsg *pMsg) {
-  if (strcmp(pMsg->pUser->user, TSDB_DEFAULT_USER) != 0) {
-    mError("failed to cfg dnode, no rights");
-    return TSDB_CODE_MND_NO_RIGHTS;
-  }
-  
-  SCfgDnodeMsg *pCmCfgDnode = pMsg->rpcMsg.pCont;
-  if (pCmCfgDnode->ep[0] == 0) {
-    tstrncpy(pCmCfgDnode->ep, tsLocalEp, TSDB_EP_LEN);
-  }
-
-  SDnodeObj *pDnode = mnodeGetDnodeByEp(pCmCfgDnode->ep);
-  if (pDnode == NULL) {
-    int32_t dnodeId = strtol(pCmCfgDnode->ep, NULL, 10);
-    if (dnodeId <= 0 || dnodeId > 65536) {
-      mError("failed to cfg dnode, invalid dnodeEp:%s", pCmCfgDnode->ep);
-      return TSDB_CODE_MND_DNODE_NOT_EXIST;
-    }
-
-    pDnode = mnodeGetDnode(dnodeId);
-    if (pDnode == NULL) {
-      mError("failed to cfg dnode, invalid dnodeId:%d", dnodeId);
-      return TSDB_CODE_MND_DNODE_NOT_EXIST;
-    }
-  }
-
-  SRpcEpSet epSet = mnodeGetEpSetFromIp(pDnode->dnodeEp);
-
-  if (strncasecmp(pCmCfgDnode->config, "balance", 7) == 0) {
-    int32_t vnodeId = 0;
-    int32_t dnodeId = 0;
-    bool parseOk = taosCheckBalanceCfgOptions(pCmCfgDnode->config + 8, &vnodeId, &dnodeId);
-    if (!parseOk) {
-      mnodeDecDnodeRef(pDnode);
-      return TSDB_CODE_MND_INVALID_DNODE_CFG_OPTION;
-    }
-
-    int32_t code = bnAlterDnode(pDnode, vnodeId, dnodeId);
-    mnodeDecDnodeRef(pDnode);
-    return code;
-  } else {
-    SCfgDnodeMsg *pMdCfgDnode = rpcMallocCont(sizeof(SCfgDnodeMsg));
-    strcpy(pMdCfgDnode->ep, pCmCfgDnode->ep);
-    strcpy(pMdCfgDnode->config, pCmCfgDnode->config);
-
-    SRpcMsg rpcMdCfgDnodeMsg = {
-      .ahandle = 0,
-      .code = 0,
-      .msgType = TSDB_MSG_TYPE_MD_CONFIG_DNODE,
-      .pCont = pMdCfgDnode,
-      .contLen = sizeof(SCfgDnodeMsg)
-    };
-
-    mInfo("dnode:%s, is configured by %s", pCmCfgDnode->ep, pMsg->pUser->user);
-    dnodeSendMsgToDnode(&epSet, &rpcMdCfgDnodeMsg);
-    mnodeDecDnodeRef(pDnode);
-    return TSDB_CODE_SUCCESS;
-  }
-}
-
-static void mnodeProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) {
-  mInfo("cfg dnode rsp is received");
-}
-
-static int32_t mnodeCheckClusterCfgPara(const SClusterCfg *clusterCfg) {
-  if (clusterCfg->numOfMnodes != htonl(tsNumOfMnodes)) {
-    mError("\"numOfMnodes\"[%d - %d] cfg parameters inconsistent", clusterCfg->numOfMnodes, htonl(tsNumOfMnodes));
-    return TAOS_DN_OFF_NUM_OF_MNODES_NOT_MATCH;
-  }
-  if (clusterCfg->mnodeEqualVnodeNum != htonl(tsMnodeEqualVnodeNum)) {
-    mError("\"mnodeEqualVnodeNum\"[%d - %d] cfg parameters inconsistent", clusterCfg->mnodeEqualVnodeNum,
-           htonl(tsMnodeEqualVnodeNum));
-    return TAOS_DN_OFF_MN_EQUAL_VN_NOT_MATCH;
-  }
-  if (clusterCfg->offlineThreshold != htonl(tsOfflineThreshold)) {
-    mError("\"offlineThreshold\"[%d - %d] cfg parameters inconsistent", clusterCfg->offlineThreshold,
-           htonl(tsOfflineThreshold));
-    return TAOS_DN_OFF_OFFLINE_THRESHOLD_NOT_MATCH;
-  }
-  if (clusterCfg->statusInterval != htonl(tsStatusInterval)) {
-    mError("\"statusInterval\"[%d - %d] cfg parameters inconsistent", clusterCfg->statusInterval,
-           htonl(tsStatusInterval));
-    return TAOS_DN_OFF_STATUS_INTERVAL_NOT_MATCH;
-  }
-  if (clusterCfg->maxtablesPerVnode != htonl(tsMaxTablePerVnode)) {
-    mError("\"maxTablesPerVnode\"[%d - %d] cfg parameters inconsistent", clusterCfg->maxtablesPerVnode,
-           htonl(tsMaxTablePerVnode));
-    return TAOS_DN_OFF_MAX_TAB_PER_VN_NOT_MATCH;
-  }
-  if (clusterCfg->maxVgroupsPerDb != htonl(tsMaxVgroupsPerDb)) {
-    mError("\"maxVgroupsPerDb\"[%d - %d]  cfg parameters inconsistent", clusterCfg->maxVgroupsPerDb,
-           htonl(tsMaxVgroupsPerDb));
-    return TAOS_DN_OFF_MAX_VG_PER_DB_NOT_MATCH;
-  }
-  if (0 != strncasecmp(clusterCfg->arbitrator, tsArbitrator, strlen(tsArbitrator))) {
-    mError("\"arbitrator\"[%s - %s]  cfg parameters inconsistent", clusterCfg->arbitrator, tsArbitrator);
-    return TAOS_DN_OFF_ARBITRATOR_NOT_MATCH;
-  }
-
-  int64_t checkTime = 0;
-  char    timestr[32] = "1970-01-01 00:00:00.00";
-  (void)taosParseTime(timestr, &checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
-  if ((0 != strncasecmp(clusterCfg->timezone, tsTimezone, strlen(tsTimezone))) &&
-      (checkTime != clusterCfg->checkTime)) {
-    mError("\"timezone\"[%s - %s] [%" PRId64 " - %" PRId64 "] cfg parameters inconsistent", clusterCfg->timezone,
-           tsTimezone, clusterCfg->checkTime, checkTime);
-    return TAOS_DN_OFF_TIME_ZONE_NOT_MATCH;
-  }
-
-  // if (0 != strncasecmp(clusterCfg->locale, tsLocale, strlen(tsLocale))) {
-  //   mError("\"locale\"[%s - %s]  cfg parameters inconsistent", clusterCfg->locale, tsLocale);
-  //   return TAOS_DN_OFF_LOCALE_NOT_MATCH;
-  // }
-  // if (0 != strncasecmp(clusterCfg->charset, tsCharset, strlen(tsCharset))) {
-  //   mError("\"charset\"[%s - %s] cfg parameters inconsistent.", clusterCfg->charset, tsCharset);
-  //   return TAOS_DN_OFF_CHARSET_NOT_MATCH;
-  // }
-
-  if (clusterCfg->enableBalance != tsEnableBalance) {
-    mError("\"balance\"[%d - %d] cfg parameters inconsistent", clusterCfg->enableBalance, tsEnableBalance);
-    return TAOS_DN_OFF_ENABLE_BALANCE_NOT_MATCH;
-  }
-  if (clusterCfg->flowCtrl != tsEnableFlowCtrl) {
-    mError("\"flowCtrl\"[%d - %d] cfg parameters inconsistent", clusterCfg->flowCtrl, tsEnableFlowCtrl);
-    return TAOS_DN_OFF_FLOW_CTRL_NOT_MATCH;
-  }
-  if (clusterCfg->slaveQuery != tsEnableSlaveQuery) {
-    mError("\"slaveQuery\"[%d - %d] cfg parameters inconsistent", clusterCfg->slaveQuery, tsEnableSlaveQuery);
-    return TAOS_DN_OFF_SLAVE_QUERY_NOT_MATCH;
-  }
-  if (clusterCfg->adjustMaster != tsEnableAdjustMaster) {
-    mError("\"adjustMaster\"[%d - %d] cfg parameters inconsistent", clusterCfg->adjustMaster, tsEnableAdjustMaster);
-    return TAOS_DN_OFF_ADJUST_MASTER_NOT_MATCH;
-  }
-
-  return 0;
-}
-
-static int32_t mnodeGetDnodeEpsSize() {
-  pthread_mutex_lock(&tsDnodeEpsMutex);
-  int32_t size = tsDnodeEpsSize;
-  pthread_mutex_unlock(&tsDnodeEpsMutex);
-  return size;
-}
-
-static void mnodeGetDnodeEpsData(SDnodeEps *pEps, int32_t epsSize) {
-  pthread_mutex_lock(&tsDnodeEpsMutex);
-  if (epsSize == tsDnodeEpsSize) {
-    memcpy(pEps, tsDnodeEps, tsDnodeEpsSize);
-  }
-  pthread_mutex_unlock(&tsDnodeEpsMutex);
-}
-
-static void mnodeUpdateDnodeEps() {
-  pthread_mutex_lock(&tsDnodeEpsMutex);
-
-  int32_t totalDnodes = mnodeGetDnodesNum();
-  tsDnodeEpsSize = sizeof(SDnodeEps) + totalDnodes * sizeof(SDnodeEp);
-  free(tsDnodeEps);
-  tsDnodeEps = calloc(1, tsDnodeEpsSize);
-  tsDnodeEps->dnodeNum = htonl(totalDnodes);
-
-  SDnodeObj *pDnode = NULL;
-  void *     pIter = NULL;
-  int32_t    dnodesNum = 0;
-
-  while (1) {
-    pIter = mnodeGetNextDnode(pIter, &pDnode);
-    if (pDnode == NULL) break;
-    if (dnodesNum >= totalDnodes) {
-      mnodeCancelGetNextDnode(pIter);
-      break;
-    }
-
-    SDnodeEp *pEp = &tsDnodeEps->dnodeEps[dnodesNum];
-    dnodesNum++;
-    pEp->dnodeId = htonl(pDnode->dnodeId);
-    pEp->dnodePort = htons(pDnode->dnodePort);
-    tstrncpy(pEp->dnodeFqdn, pDnode->dnodeFqdn, TSDB_FQDN_LEN);
-    mnodeDecDnodeRef(pDnode);
-  }
-
-  pthread_mutex_unlock(&tsDnodeEpsMutex);
-}
-
-static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg) {
-  SDnodeObj *pDnode     = NULL;
-  SStatusMsg *pStatus   = pMsg->rpcMsg.pCont;
-  pStatus->dnodeId      = htonl(pStatus->dnodeId);
-  pStatus->moduleStatus = htonl(pStatus->moduleStatus);
-  pStatus->lastReboot   = htonl(pStatus->lastReboot);
-  pStatus->numOfCores   = htons(pStatus->numOfCores);
-
-  uint32_t _version = htonl(pStatus->version);
-  if (_version != tsVersion) {
-    pDnode = mnodeGetDnodeByEp(pStatus->dnodeEp);
-    if (pDnode != NULL && pDnode->status != TAOS_DN_STATUS_READY) {
-      pDnode->offlineReason = TAOS_DN_OFF_VERSION_NOT_MATCH;
-    }
-    mError("dnode:%d, status msg version:%d not equal with cluster:%d", pStatus->dnodeId, _version, tsVersion);
-    return TSDB_CODE_MND_INVALID_MSG_VERSION;
-  }
-
-  if (pStatus->dnodeId == 0) {
-    pDnode = mnodeGetDnodeByEp(pStatus->dnodeEp);
-    if (pDnode == NULL) {
-      mDebug("dnode %s not created", pStatus->dnodeEp);
-      return TSDB_CODE_MND_DNODE_NOT_EXIST;
-    }
-  } else {
-    pDnode = mnodeGetDnode(pStatus->dnodeId);
-    if (pDnode == NULL) {
-      pDnode = mnodeGetDnodeByEp(pStatus->dnodeEp);
-      if (pDnode != NULL && pDnode->status != TAOS_DN_STATUS_READY) {
-        pDnode->offlineReason = TAOS_DN_OFF_DNODE_ID_NOT_MATCH;
-      }
-      mError("dnode:%d, %s not exist", pStatus->dnodeId, pStatus->dnodeEp);
-      return TSDB_CODE_MND_DNODE_NOT_EXIST;
-    }
-  }
-
-  pDnode->lastReboot       = pStatus->lastReboot;
-  pDnode->numOfCores       = pStatus->numOfCores;
-  pDnode->diskAvailable    = pStatus->diskAvailable;
-  pDnode->alternativeRole  = pStatus->alternativeRole;
-  pDnode->moduleStatus     = pStatus->moduleStatus;
-
-  if (pStatus->dnodeId == 0) {
-    mDebug("dnode:%d %s, first access, set clusterId %s", pDnode->dnodeId, pDnode->dnodeEp, mnodeGetClusterId());
-  } else {
-    if (strncmp(pStatus->clusterId, mnodeGetClusterId(), TSDB_CLUSTER_ID_LEN - 1) != 0) {
-      if (pDnode != NULL && pDnode->status != TAOS_DN_STATUS_READY) {
-        pDnode->offlineReason = TAOS_DN_OFF_CLUSTER_ID_NOT_MATCH;
-      }
-      mError("dnode:%d, input clusterId %s not match with exist %s", pDnode->dnodeId, pStatus->clusterId,
-             mnodeGetClusterId());
-      return TSDB_CODE_MND_INVALID_CLUSTER_ID;
-    } else {
-      mTrace("dnode:%d, status received, access times %" PRId64 " openVnodes:%d:%d", pDnode->dnodeId, pDnode->lastAccess,
-             htons(pStatus->openVnodes), pDnode->openVnodes);
-    }
-  }
-
-  int32_t openVnodes = htons(pStatus->openVnodes);
-  int32_t epsSize = mnodeGetDnodeEpsSize();
-  int32_t vgAccessSize = openVnodes * sizeof(SVgroupAccess);
-  int32_t contLen = sizeof(SStatusRsp) + vgAccessSize + epsSize;
-
-  SStatusRsp *pRsp = rpcMallocCont(contLen);
-  if (pRsp == NULL) {
-    mnodeDecDnodeRef(pDnode);
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-
-  pRsp->dnodeCfg.dnodeId = htonl(pDnode->dnodeId);
-  pRsp->dnodeCfg.moduleStatus = htonl((int32_t)pDnode->isMgmt);
-  pRsp->dnodeCfg.numOfVnodes = htonl(openVnodes);
-  tstrncpy(pRsp->dnodeCfg.clusterId, mnodeGetClusterId(), TSDB_CLUSTER_ID_LEN);
-  SVgroupAccess *pAccess = (SVgroupAccess *)((char *)pRsp + sizeof(SStatusRsp));
-  
-  for (int32_t j = 0; j < openVnodes; ++j) {
-    SVnodeLoad *pVload = &pStatus->load[j];
-    pVload->vgId = htonl(pVload->vgId);
-    pVload->dbCfgVersion = htonl(pVload->dbCfgVersion);
-    pVload->vgCfgVersion = htonl(pVload->vgCfgVersion);
-    pVload->vnodeVersion = htobe64(pVload->vnodeVersion);
-
-    SVgObj *pVgroup = mnodeGetVgroup(pVload->vgId);
-    if (pVgroup == NULL) {
-      SRpcEpSet epSet = mnodeGetEpSetFromIp(pDnode->dnodeEp);
-      mInfo("dnode:%d, vgId:%d not exist in mnode, drop it", pDnode->dnodeId, pVload->vgId);
-      mnodeSendDropVnodeMsg(pVload->vgId, &epSet, NULL);
-    } else {
-      mnodeUpdateVgroupStatus(pVgroup, pDnode, pVload);
-      pAccess->vgId = htonl(pVload->vgId);
-      pAccess->accessState = pVgroup->accessState;
-      pAccess++;
-      mnodeDecVgroupRef(pVgroup);
-    }
-  }
-
-  if (pDnode->status == TAOS_DN_STATUS_OFFLINE) {
-    // Verify whether the cluster parameters are consistent when status change from offline to ready
-    int32_t ret = mnodeCheckClusterCfgPara(&(pStatus->clusterCfg));
-    if (0 != ret) {
-      pDnode->offlineReason = ret;
-      mnodeDecDnodeRef(pDnode);
-      rpcFreeCont(pRsp);
-      mError("dnode:%d, %s cluster cfg parameters inconsistent, reason:%s", pDnode->dnodeId, pStatus->dnodeEp,
-             offlineReason[ret]);
-      return TSDB_CODE_MND_CLUSTER_CFG_INCONSISTENT;
-    }
-
-    mInfo("dnode:%d, from offline to online", pDnode->dnodeId);
-    pDnode->status = TAOS_DN_STATUS_READY;
-    pDnode->offlineReason = TAOS_DN_OFF_ONLINE;
-    bnCheckModules();
-    bnNotify();
-  }
-
-  int32_t numOfMnodes = mnodeGetMnodesNum();
-  if (numOfMnodes < tsNumOfMnodes && numOfMnodes < mnodeGetOnlineDnodesNum()
-      && bnDnodeCanCreateMnode(pDnode)) {
-    bnNotify();
-  }
-
-  if (openVnodes != pDnode->openVnodes) {
-    mnodeCheckUnCreatedVgroup(pDnode, pStatus->load, openVnodes);
-  }
-
-  pDnode->lastAccess = tsAccessSquence;
-
-  //this func should be called after sdb replica changed
-  mnodeGetMnodeInfos(&pRsp->mnodes);
-  
-  mnodeDecDnodeRef(pDnode);
-
-  SDnodeEps *pEps = (SDnodeEps *)((char *)pRsp + sizeof(SStatusRsp) + vgAccessSize);
-  mnodeGetDnodeEpsData(pEps, epsSize);
-
-  pMsg->rpcRsp.len = contLen;
-  pMsg->rpcRsp.rsp =  pRsp;
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeCreateDnode(char *ep, SMnodeMsg *pMsg) {
-  int32_t grantCode = grantCheck(TSDB_GRANT_DNODE);
-  if (grantCode != TSDB_CODE_SUCCESS) {
-    return grantCode;
-  }
-
-  char dnodeEp[TSDB_EP_LEN] = {0};
-  tstrncpy(dnodeEp, ep, TSDB_EP_LEN);
-  strtrim(dnodeEp);
-
-  char *temp = strchr(dnodeEp, ':');
-  if (!temp) {
-    int32_t len = (int32_t)strlen(dnodeEp);
-    if (dnodeEp[len - 1] == ';') dnodeEp[len - 1] = 0;
-    len = (int32_t)strlen(dnodeEp);
-    snprintf(dnodeEp + len, TSDB_EP_LEN - len, ":%d", tsServerPort);
-  }
-  ep = dnodeEp;
-
-  SDnodeObj *pDnode = mnodeGetDnodeByEp(ep);
-  if (pDnode != NULL) {
-    mnodeDecDnodeRef(pDnode);
-    mError("dnode:%d, already exist, %s:%d", pDnode->dnodeId, pDnode->dnodeFqdn, pDnode->dnodePort);
-    return TSDB_CODE_MND_DNODE_ALREADY_EXIST;
-  }
-
-  pDnode = (SDnodeObj *) calloc(1, sizeof(SDnodeObj));
-  pDnode->createdTime = taosGetTimestampMs();
-  pDnode->status = TAOS_DN_STATUS_OFFLINE; 
-  pDnode->offlineReason = TAOS_DN_OFF_STATUS_NOT_RECEIVED;
-  tstrncpy(pDnode->dnodeEp, ep, TSDB_EP_LEN);
-  taosGetFqdnPortFromEp(ep, pDnode->dnodeFqdn, &pDnode->dnodePort);
-
-  SSdbRow row = {
-    .type    = SDB_OPER_GLOBAL,
-    .pTable  = tsDnodeSdb,
-    .pObj    = pDnode,
-    .rowSize = sizeof(SDnodeObj),
-    .pMsg    = pMsg
-  };
-
-  int32_t code = sdbInsertRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    int dnodeId = pDnode->dnodeId;
-    tfree(pDnode);
-    mError("failed to create dnode:%d, reason:%s", dnodeId, tstrerror(code));
-  } else {
-    mLInfo("dnode:%d is created", pDnode->dnodeId);
-  }
-
-  return code;
-}
-
-int32_t mnodeDropDnode(SDnodeObj *pDnode, void *pMsg) {
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsDnodeSdb,
-    .pObj   = pDnode,
-    .pMsg   = pMsg
-  };
-
-  int32_t code = sdbDeleteRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("dnode:%d, failed to drop from cluster, result:%s", pDnode->dnodeId, tstrerror(code));
-  } else {
-    mLInfo("dnode:%d, is dropped from cluster", pDnode->dnodeId);
-  }
-
-  return code;
-}
-
-static int32_t mnodeDropDnodeByEp(char *ep, SMnodeMsg *pMsg) {
-  SDnodeObj *pDnode = mnodeGetDnodeByEp(ep);
-  if (pDnode == NULL) {
-    if (strspn(ep, "0123456789 ;") != strlen(ep)) {
-      return TSDB_CODE_MND_DNODE_NOT_EXIST;
-    }
-
-    int32_t dnodeId = (int32_t)strtol(ep, NULL, 10);
-    pDnode = mnodeGetDnode(dnodeId);
-    if (pDnode == NULL) {
-      mError("dnode:%s, is not exist", ep);
-      return TSDB_CODE_MND_DNODE_NOT_EXIST;
-    }
-  }
-
-  if (strcmp(pDnode->dnodeEp, mnodeGetMnodeMasterEp()) == 0) {
-    mError("dnode:%d, can't drop dnode:%s which is master", pDnode->dnodeId, ep);
-    mnodeDecDnodeRef(pDnode);
-    return TSDB_CODE_MND_NO_REMOVE_MASTER;
-  }
-
-  int32_t maxReplica = mnodeGetDbMaxReplica();
-  int32_t dnodesNum = mnodeGetDnodesNum();
-  if (dnodesNum <= maxReplica) {
-    mError("dnode:%d, can't drop dnode:%s, #dnodes: %d, replia: %d", pDnode->dnodeId, ep, dnodesNum, maxReplica);
-    mnodeDecDnodeRef(pDnode);
-    return TSDB_CODE_MND_NO_ENOUGH_DNODES;
-  }
-
-  mInfo("dnode:%d, start to drop it", pDnode->dnodeId);
-
-  int32_t code = bnDropDnode(pDnode);
-  mnodeDecDnodeRef(pDnode);
-  return code;
-}
-
-static int32_t mnodeProcessCreateDnodeMsg(SMnodeMsg *pMsg) {
-  SCreateDnodeMsg *pCreate = pMsg->rpcMsg.pCont;
-
-  if (strcmp(pMsg->pUser->user, TSDB_DEFAULT_USER) != 0) {
-    return TSDB_CODE_MND_NO_RIGHTS;
-  } else {
-    return mnodeCreateDnode(pCreate->ep, pMsg);
-  }
-}
-
-static int32_t mnodeProcessDropDnodeMsg(SMnodeMsg *pMsg) {
-  SDropDnodeMsg *pDrop = pMsg->rpcMsg.pCont;
-
-  if (strcmp(pMsg->pUser->user, TSDB_DEFAULT_USER) != 0) {
-    return TSDB_CODE_MND_NO_RIGHTS;
-  } else {
-    return mnodeDropDnodeByEp(pDrop->ep, pMsg);
-  }
-}
-
-static int32_t mnodeGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) return 0;
-
-  if (strcmp(pUser->pAcct->user, TSDB_DEFAULT_USER) != 0) {
-    mnodeDecUserRef(pUser);
-    return TSDB_CODE_MND_NO_RIGHTS;
-  }
-
-  int32_t  cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "id");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_EP_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "end_point");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "vnodes");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "cores");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 10 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "status");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 5 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "role");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "create_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 24 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "offline reason");
-  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 = mnodeGetDnodesNum();
-  if (tsArbitrator[0] != 0) {
-    pShow->numOfRows++;
-  }
-
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-  pShow->pIter = NULL;
-
-  mnodeDecUserRef(pUser);
-
-  return 0;
-}
-
-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 = mnodeGetNextDnode(pShow->pIter, &pDnode);
-    if (pDnode == NULL) break;
-
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pDnode->dnodeId;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDnode->dnodeEp, pShow->bytes[cols]);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pDnode->openVnodes;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pDnode->numOfCores;
-    cols++;
-    
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;  
-    char* status = dnodeStatus[pDnode->status];
-    STR_TO_VARSTR(pWrite, status);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;  
-    char* role = dnodeRoles[pDnode->alternativeRole];
-    STR_TO_VARSTR(pWrite, role);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pDnode->createdTime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_TO_VARSTR(pWrite, offlineReason[pDnode->offlineReason]);
-    cols++;
-
-    numOfRows++;
-    mnodeDecDnodeRef(pDnode);
-  }
-
-  if (tsArbitrator[0] != 0) {
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = 0;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, tsArbitrator, pShow->bytes[cols]);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = 0;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = 0;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    char *status = dnodeStatus[tsArbOnline > 0 ? TAOS_DN_STATUS_READY : TAOS_DN_STATUS_OFFLINE];
-    STR_TO_VARSTR(pWrite, status);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_TO_VARSTR(pWrite, "arb");
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = tsArbOnlineTimestamp;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_TO_VARSTR(pWrite, "-");
-    cols++;
-
-    numOfRows++;
-  }
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  pShow->numOfReads += numOfRows;
-  return numOfRows;
-}
-
-static bool mnodeCheckModuleInDnode(SDnodeObj *pDnode, int32_t moduleType) {
-  uint32_t status = pDnode->moduleStatus & (1u << moduleType);
-  return status > 0;
-}
-
-static int32_t mnodeGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  int32_t cols = 0;
-
-  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) return 0;
-
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0)  {
-    mnodeDecUserRef(pUser);
-    return TSDB_CODE_MND_NO_RIGHTS;
-  }
-
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "id");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 40 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "end_point");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "module");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "status");
-  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 = mnodeGetDnodesNum() * TSDB_MOD_MAX;
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-  pShow->pIter = NULL;
-  mnodeDecUserRef(pUser);
-
-  return 0;
-}
-
-int32_t mnodeRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  int32_t numOfRows = 0;
-
-  char* pWrite;
-  char* moduleName[5] = { "MNODE", "HTTP", "MONITOR", "MQTT", "UNKNOWN" };
-  int32_t cols;
-
-  while (numOfRows < rows) {
-    SDnodeObj *pDnode = NULL;
-    pShow->pIter = mnodeGetNextDnode(pShow->pIter, (SDnodeObj **)&pDnode);
-    if (pDnode == NULL) break;
-
-    for (int32_t moduleType = 0; moduleType < TSDB_MOD_MAX; ++moduleType) {
-      cols = 0;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int16_t *)pWrite = pDnode->dnodeId;
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDnode->dnodeEp, pShow->bytes[cols] - 1);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, moduleName[moduleType], pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      bool enable = mnodeCheckModuleInDnode(pDnode, moduleType);
-
-      char* v = enable? "enable":"disable";
-      STR_TO_VARSTR(pWrite, v);
-      cols++;
-
-      numOfRows++;
-    }
-
-    mnodeDecDnodeRef(pDnode);
-  }
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  pShow->numOfReads += numOfRows;
-  return numOfRows;
-}
-
-static bool mnodeCheckConfigShow(SGlobalCfg *cfg) {
-  if (!(cfg->cfgType & TSDB_CFG_CTYPE_B_SHOW))
-    return false;
-  return true;
-}
-
-static int32_t mnodeGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  int32_t cols = 0;
-
-  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) return 0;
-
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0)  {
-    mnodeDecUserRef(pUser);
-    return TSDB_CODE_MND_NO_RIGHTS;
-  }
-
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = TSDB_CFG_OPTION_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  tstrncpy(pSchema[cols].name, "name", sizeof(pSchema[cols].name));
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_CFG_VALUE_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  tstrncpy(pSchema[cols].name, "value", sizeof(pSchema[cols].name));
-  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 = 0;
-  for (int32_t i = tsGlobalConfigNum - 1; i >= 0; --i) {
-    SGlobalCfg *cfg = tsGlobalConfig + i;
-    if (!mnodeCheckConfigShow(cfg)) continue;
-    pShow->numOfRows++;
-  }
-
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-  pShow->pIter = NULL;
-  mnodeDecUserRef(pUser);
-
-  return 0;
-}
-
-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 (!mnodeCheckConfigShow(cfg)) continue;
-
-    char *pWrite;
-    int32_t   cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, cfg->option, TSDB_CFG_OPTION_LEN);
-
-    cols++;
-    int32_t t = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    switch (cfg->valType) {
-      case TAOS_CFG_VTYPE_INT8:
-        t = snprintf(varDataVal(pWrite), TSDB_CFG_VALUE_LEN, "%d", *((int8_t *)cfg->ptr));
-        varDataSetLen(pWrite, t);
-        numOfRows++;
-        break;
-      case TAOS_CFG_VTYPE_INT16:
-        t = snprintf(varDataVal(pWrite), TSDB_CFG_VALUE_LEN, "%d", *((int16_t *)cfg->ptr));
-        varDataSetLen(pWrite, t);
-        numOfRows++;
-        break;
-      case TAOS_CFG_VTYPE_INT32:
-        t = snprintf(varDataVal(pWrite), TSDB_CFG_VALUE_LEN, "%d", *((int32_t *)cfg->ptr));
-        varDataSetLen(pWrite, t);
-        numOfRows++;
-        break;
-      case TAOS_CFG_VTYPE_FLOAT:
-      case TAOS_CFG_VTYPE_DOUBLE:
-        t = snprintf(varDataVal(pWrite), TSDB_CFG_VALUE_LEN, "%f", *((float *)cfg->ptr));
-        varDataSetLen(pWrite, t);
-        numOfRows++;
-        break;
-      case TAOS_CFG_VTYPE_STRING:
-      case TAOS_CFG_VTYPE_IPSTR:
-      case TAOS_CFG_VTYPE_DIRECTORY:
-        STR_WITH_MAXSIZE_TO_VARSTR(pWrite, cfg->ptr, TSDB_CFG_VALUE_LEN);
-        numOfRows++;
-        break;
-      default:
-        break;
-    }
-  }
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  pShow->numOfReads += numOfRows;
-  return numOfRows;
-}
-
-static int32_t mnodeGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  int32_t cols = 0;
-  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) return 0;
-  
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0)  {
-    mnodeDecUserRef(pUser);
-    return TSDB_CODE_MND_NO_RIGHTS;
-  }
-
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "vgId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 12 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "status");
-  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];
-
-  SDnodeObj *pDnode = NULL;
-  if (pShow->payloadLen > 0 ) {
-    char ep[TSDB_EP_LEN] = {0}; 
-    // not use tstrncpy to make runtime happy   
-    uint16_t len = (pShow->payloadLen + 1) > TSDB_EP_LEN ? TSDB_EP_LEN :(pShow->payloadLen + 1);
-    strncpy(ep, pShow->payload, len - 1);
-
-    pDnode = mnodeGetDnodeByEp(ep);
-  } else {
-    void *pIter = mnodeGetNextDnode(NULL, (SDnodeObj **)&pDnode);
-    mnodeCancelGetNextDnode(pIter);
-  }
-
-  if (pDnode != NULL) {
-    pShow->numOfRows += pDnode->openVnodes;
-    mnodeDecDnodeRef(pDnode);
-  }
-
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-  pShow->pIter = pDnode;
-  mnodeDecUserRef(pUser);
-
-  return 0;
-}
-
-static int32_t mnodeRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  int32_t    numOfRows = 0;
-  SDnodeObj *pDnode = NULL;
-  char *     pWrite;
-  int32_t    cols = 0;
-
-  if (0 == rows) return 0;
-
-  pDnode = (SDnodeObj *)(pShow->pIter);
-  if (pDnode != NULL) {
-    SVgObj *pVgroup;
-    while (1) {
-      pShow->pVgIter = mnodeGetNextVgroup(pShow->pVgIter, &pVgroup);
-      if (pVgroup == NULL) break;
-
-      for (int32_t i = 0; i < pVgroup->numOfVnodes && numOfRows < rows; ++i) {
-        SVnodeGid *pVgid = &pVgroup->vnodeGid[i];
-        if (pVgid->pDnode == pDnode) {
-          cols = 0;
-
-          pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-          *(uint32_t *)pWrite = pVgroup->vgId;
-          cols++;
-
-          pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-          STR_TO_VARSTR(pWrite, syncRole[pVgid->role]);
-          cols++;
-          numOfRows++;
-          
-        }
-      }
-      if (numOfRows >= rows) {
-        break;
-      }
-
-      mnodeDecVgroupRef(pVgroup);
-    }
-  } else {
-    numOfRows = 0;
-  }
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  pShow->numOfReads += numOfRows;
-  return numOfRows;
-}
-
-char* dnodeStatus[] = {
-  "offline",
-  "dropping",
-  "balancing",
-  "ready",
-  "undefined"
-};
-
-char* dnodeRoles[] = {
-  "any",
-  "mnode",
-  "vnode",
-  "any"
-};
-
-int32_t mnodeCompactDnodes() {
-  SDnodeObj *pDnode = NULL;
-  void *     pIter = NULL;
-
-  mInfo("start to compact dnodes table...");
-
-  while (1) {
-    pIter = mnodeGetNextDnode(pIter, &pDnode);
-    if (pDnode == NULL) break;
-
-    SSdbRow row = {
-      .type    = SDB_OPER_GLOBAL,
-      .pTable  = tsDnodeSdb,
-      .pObj    = pDnode,
-      .rowSize = sizeof(SDnodeObj),
-    };
-
-    mInfo("compact dnode %d", pDnode->dnodeId);
-    
-    sdbInsertCompactRow(&row);
-  }
-
-  mInfo("end to compact dnodes table...");
-
-  return 0;
-}

src/mnode/src/mnodeFunc.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "trpc.h"
-#include "tutil.h"
-#include "tglobal.h"
-#include "tgrant.h"
-#include "tdataformat.h"
-#include "tkey.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeUser.h"
-#include "mnodeMnode.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeFunc.h"
-#include "mnodeWrite.h"
-#include "mnodeRead.h"
-#include "mnodePeer.h"
-
-int64_t        tsFuncRid = -1;
-static void *  tsFuncSdb = NULL;
-static int32_t tsFuncUpdateSize = 0;
-static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeProcessRetrieveFuncImplMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg);
-
-static int32_t mnodeFuncActionDestroy(SSdbRow *pRow) {
-  tfree(pRow->pObj);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionInsert(SSdbRow *pRow) {
-  SFuncObj *pFunc = pRow->pObj;
-
-  mTrace("func:%s, contLen: %d, insert into sdb", pFunc->name, pFunc->contLen);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionDelete(SSdbRow *pRow) {
-  SFuncObj *pFunc = pRow->pObj;
-
-  mTrace("func:%s, length: %d, delete from sdb", pFunc->name, pFunc->contLen);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionUpdate(SSdbRow *pRow) {
-  SFuncObj *pFunc = pRow->pObj;
-
-  SFuncObj *pSaved = mnodeGetFunc(pFunc->name);
-  if (pFunc != pSaved) {
-    memcpy(pSaved, pFunc, tsFuncUpdateSize);
-    free(pFunc);
-  }
-
-  mnodeDecFuncRef(pSaved);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionEncode(SSdbRow *pRow) {
-  SFuncObj *pFunc = pRow->pObj;
-
-  memcpy(pRow->rowData, pFunc, tsFuncUpdateSize);
-  pRow->rowSize = tsFuncUpdateSize;
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionDecode(SSdbRow *pRow) {
-  SFuncObj *pFunc = (SFuncObj *)calloc(1, sizeof(SFuncObj));
-  if (pFunc == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
-  memcpy(pFunc, pRow->rowData, tsFuncUpdateSize);
-  pRow->pObj = pFunc;
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionRestored() {
-  int64_t numOfRows = sdbGetNumOfRows(tsFuncSdb);
-
-  if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
-    mInfo("dnode first deploy, func restored.");
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitFuncs() {
-  SFuncObj tObj;
-  tsFuncUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
-  SSdbTableDesc desc = {
-    .id           = SDB_TABLE_FUNC,
-    .name         = "funcs",
-    .hashSessions = TSDB_DEFAULT_USERS_HASH_SIZE,
-    .maxRowSize   = tsFuncUpdateSize,
-    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
-    .keyType      = SDB_KEY_STRING,
-    .fpInsert     = mnodeFuncActionInsert,
-    .fpDelete     = mnodeFuncActionDelete,
-    .fpUpdate     = mnodeFuncActionUpdate,
-    .fpEncode     = mnodeFuncActionEncode,
-    .fpDecode     = mnodeFuncActionDecode,
-    .fpDestroy    = mnodeFuncActionDestroy,
-    .fpRestored   = mnodeFuncActionRestored
-  };
-
-  tsFuncRid = sdbOpenTable(&desc);
-  tsFuncSdb = sdbGetTableByRid(tsFuncRid);
-  if (tsFuncSdb == NULL) {
-    mError("table:%s, failed to create hash", desc.name);
-    return -1;
-  }
-
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_FUNCTION, mnodeProcessCreateFuncMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_FUNCTION, mnodeProcessDropFuncMsg);
-  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_RETRIEVE_FUNC, mnodeProcessRetrieveFuncImplMsg);
-
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeGetFuncMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeRetrieveFuncs);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeCancelGetNextFunc);
-
-  mDebug("table:%s, hash is created", desc.name);
-
-  return 0;
-}
-
-void mnodeCleanupFuncs() {
-  sdbCloseTable(tsFuncRid);
-  tsFuncSdb = NULL;
-}
-
-SFuncObj *mnodeGetFunc(char *name) {
-  return (SFuncObj *)sdbGetRow(tsFuncSdb, name);
-}
-
-void *mnodeGetNextFunc(void *pIter, SFuncObj **pFunc) {
-  return sdbFetchRow(tsFuncSdb, pIter, (void **)pFunc);
-}
-
-void mnodeCancelGetNextFunc(void *pIter) {
- sdbFreeIter(tsFuncSdb, pIter);
-}
-
-void mnodeIncFuncRef(SFuncObj *pFunc) {
-  sdbIncRef(tsFuncSdb, pFunc);
-}
-
-void mnodeDecFuncRef(SFuncObj *pFunc) {
-  sdbDecRef(tsFuncSdb, pFunc);
-}
-/*
-static int32_t mnodeUpdateFunc(SFuncObj *pFunc, void *pMsg) {
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsFuncSdb,
-    .pObj   = pFunc,
-    .pMsg   = pMsg
-  };
-
-  int32_t code = sdbUpdateRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("func:%s, failed to alter by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
-  } else {
-    mLInfo("func:%s, is altered by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
-  }
-
-  return code;
-}
-*/
-int32_t mnodeCreateFunc(SAcctObj *pAcct, char *name, int32_t codeLen, char *codeScript, char *path, uint8_t outputType, int16_t outputLen, int32_t funcType, int32_t bufSize, SMnodeMsg *pMsg) {
-  if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_GRANT_EXPIRED;
-  }
-
-  if (!pMsg->pUser->writeAuth) {
-    return TSDB_CODE_MND_NO_RIGHTS;
-  }
-
-  int32_t code = acctCheck(pAcct, ACCT_GRANT_USER);
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  code = grantCheck(TSDB_GRANT_USER);
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  if (name[0] == 0) {
-    return TSDB_CODE_MND_INVALID_FUNC_NAME;
-  }
-
-  if (codeScript[0] == 0) {
-    return TSDB_CODE_MND_INVALID_FUNC_CODE;
-  }
-
-  if (codeLen < 0 || codeLen > TSDB_FUNC_CODE_LEN) {
-    return TSDB_CODE_MND_INVALID_FUNC_CODE;
-  }
-
-  if (bufSize < 0 || bufSize > TSDB_FUNC_BUF_SIZE) {
-    return TSDB_CODE_MND_INVALID_FUNC_BUFSIZE;
-  }
-
-  SFuncObj *pFunc = mnodeGetFunc(name);
-  if (pFunc != NULL) {
-    mDebug("func:%s, is already there", name);
-    mnodeDecFuncRef(pFunc);
-    return TSDB_CODE_MND_FUNC_ALREADY_EXIST;
-  }
-
-  pFunc = calloc(1, sizeof(SFuncObj));
-  tstrncpy(pFunc->name, name, TSDB_FUNC_NAME_LEN);
-  tstrncpy(pFunc->path, path, tListLen(pFunc->path));
-  memcpy(pFunc->cont, codeScript, codeLen);
-  pFunc->contLen     = codeLen;
-  pFunc->createdTime = taosGetTimestampMs();
-  pFunc->resType     = outputType;
-  pFunc->resBytes    = outputLen;
-  pFunc->funcType    = funcType;
-  pFunc->bufSize     = bufSize;
-  pFunc->sig  = 0;
-  pFunc->type = 1; //lua script, refactor
-
-  SSdbRow row = {
-    .type     = SDB_OPER_GLOBAL,
-    .pTable   = tsFuncSdb,
-    .pObj     = pFunc,
-    .rowSize  = sizeof(SFuncObj),
-    .pMsg     = pMsg
-  };
-
-  code = sdbInsertRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("func:%s, failed to create by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
-    tfree(pFunc);
-  } else {
-    mLInfo("func:%s, is created by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
-  }
-
-  return code;
-}
-
-static int32_t mnodeDropFunc(SFuncObj *pFunc, void *pMsg) {
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsFuncSdb,
-    .pObj   = pFunc,
-    .pMsg   = pMsg
-  };
-
-  int32_t code = sdbDeleteRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("func:%s, failed to drop by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
-  } else {
-    mLInfo("func:%s, is dropped by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
-  }
-
-  return code;
-}
-
-static int32_t mnodeGetFuncsNum() {
-  return (int32_t)sdbGetNumOfRows(tsFuncSdb);
-}
-
-static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) {
-    return TSDB_CODE_MND_NO_USER_FROM_CONN;
-  }
-
-  int32_t cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = TSDB_FUNC_NAME_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "name");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = PATH_MAX + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "path");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "aggregate");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_TYPE_STR_MAX_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "outputtype");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "create_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "code_len");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "bufsize");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pMeta->numOfColumns = htons(cols);
-  strcpy(pMeta->tableFname, "show funcs");
-  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 = mnodeGetFuncsNum();
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  mnodeDecUserRef(pUser);
-
-  return 0;
-}
-
-static void* mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int16_t len) {
-  char *msg = "unknown";
-  if (type >= sizeof(tDataTypes)/sizeof(tDataTypes[0])) {
-    return msg;
-  }
-  
-  if (type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_BINARY) {
-    int32_t bytes = len > 0 ? (int)(len - VARSTR_HEADER_SIZE) : len;
-    
-    snprintf(buf, buflen - 1, "%s(%d)", tDataTypes[type].name, type == TSDB_DATA_TYPE_NCHAR ? bytes/4 : bytes);
-    buf[buflen - 1] = 0;
-
-    return buf;
-  }
-  
-  return tDataTypes[type].name;
-}
-
-static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  int32_t   numOfRows = 0;
-  SFuncObj *pFunc    = NULL;
-  int32_t   cols      = 0;
-  char     *pWrite;
-  char      buf[TSDB_TYPE_STR_MAX_LEN];
-
-  while (numOfRows < rows) {
-    pShow->pIter = mnodeGetNextFunc(pShow->pIter, &pFunc);
-    if (pFunc == NULL) break;
-
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pFunc->name, pShow->bytes[cols]);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pFunc->path, pShow->bytes[cols]);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *)pWrite = pFunc->funcType == TSDB_UDF_TYPE_AGGREGATE ? 1 : 0;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->resType, pFunc->resBytes), pShow->bytes[cols]);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pFunc->createdTime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *)pWrite = pFunc->contLen;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *)pWrite = pFunc->bufSize;
-    cols++;
-
-    numOfRows++;
-    mnodeDecFuncRef(pFunc);
-  }
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  pShow->numOfReads += numOfRows;
-  return numOfRows;
-}
-
-static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg) {
-  SCreateFuncMsg *pCreate    = pMsg->rpcMsg.pCont;
-  pCreate->codeLen       = htonl(pCreate->codeLen);
-  pCreate->outputLen     = htons(pCreate->outputLen);
-  pCreate->funcType      = htonl(pCreate->funcType);
-  pCreate->bufSize       = htonl(pCreate->bufSize);
-
-  return mnodeCreateFunc(pMsg->pUser->pAcct, pCreate->name, pCreate->codeLen, pCreate->code, pCreate->path, pCreate->outputType, pCreate->outputLen, pCreate->funcType, pCreate->bufSize, pMsg);
-}
-
-static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg) {
-  SDropFuncMsg *pDrop = pMsg->rpcMsg.pCont;
-
-  SFuncObj *pFunc = mnodeGetFunc(pDrop->name);
-  if (pFunc == NULL) {
-    return TSDB_CODE_MND_INVALID_FUNC;
-  }
-
-  return mnodeDropFunc(pFunc, pMsg);
-}
-
-static int32_t mnodeProcessRetrieveFuncImplMsg(SMnodeMsg *pMsg) {
-  SRetrieveFuncMsg *pInfo = pMsg->rpcMsg.pCont;
-  pInfo->num = htonl(pInfo->num);
-
-  int32_t t = sizeof(SUdfFuncMsg) + (sizeof(SFunctionInfoMsg) + TSDB_FUNC_CODE_LEN) * pInfo->num + 16384;
-
-  SUdfFuncMsg *pFuncMsg = rpcMallocCont(t);
-  pFuncMsg->num = htonl(pInfo->num);
-  char* pOutput = pFuncMsg->content;
-  tstr* name = (tstr*) pInfo->name;
-
-  for(int32_t i = 0; i < pInfo->num; ++i) {
-    char buf[TSDB_FUNC_NAME_LEN] = {0};
-    tstrncpy(buf, name->data, htons(name->len) + 1);
-
-    SFuncObj* pFuncObj = mnodeGetFunc(buf);
-    if (pFuncObj == NULL) {
-      mError("function %s does not exist", buf);
-      return TSDB_CODE_MND_INVALID_FUNC;
-    }
-    
-    SFunctionInfoMsg* pFuncInfo = (SFunctionInfoMsg*) pOutput;
-
-    strcpy(pFuncInfo->name, buf);
-    pFuncInfo->len = htonl(pFuncObj->contLen);
-    memcpy(pFuncInfo->content, pFuncObj->cont, pFuncObj->contLen);
-
-    pFuncInfo->funcType = htonl(pFuncObj->funcType);
-    pFuncInfo->resType = pFuncObj->resType;
-    pFuncInfo->resBytes = htons(pFuncObj->resBytes);
-    pFuncInfo->bufSize  = htonl(pFuncObj->bufSize);
-    
-    pOutput += sizeof(SFunctionInfoMsg) + pFuncObj->contLen;
-    name =(tstr *)((char *)name + sizeof(*name) + htons(name->len));
-  }
-
-  pMsg->rpcRsp.rsp = pFuncMsg;
-  pMsg->rpcRsp.len = (int32_t)(pOutput - (char*)pFuncMsg);
-  return TSDB_CODE_SUCCESS;
-}

src/mnode/src/mnodeGrant.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#ifndef _GRANT
-#include "os.h"
-#include "taoserror.h"
-#include "tgrant.h"
-#include "mnodeInt.h"
-
-int32_t grantInit() { return TSDB_CODE_SUCCESS; }
-void    grantCleanUp() {}
-void    grantParseParameter() { mError("can't parsed parameter k"); }
-int32_t grantCheck(EGrantType grant) { return TSDB_CODE_SUCCESS; }
-void    grantReset(EGrantType grant, uint64_t value) {}
-void    grantAdd(EGrantType grant, uint64_t value) {}
-void    grantRestore(EGrantType grant, uint64_t value) {}
-
-#endif
\ No newline at end of file

src/mnode/src/mnodeInt.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosmsg.h"
-#include "taoserror.h"
-#include "trpc.h"
-#include "tqueue.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(SRpcMsg *pRpcMsg) {
-  int32_t    size = sizeof(SMnodeMsg) + pRpcMsg->contLen;
-  SMnodeMsg *pMsg = taosAllocateQitem(size);
-
-  pMsg->rpcMsg = *pRpcMsg;
-  pMsg->rpcMsg.pCont = pMsg->pCont;
-  pMsg->incomingTs = taosGetTimestampSec();
-  memcpy(pMsg->pCont, pRpcMsg->pCont, pRpcMsg->contLen);
-
-  return pMsg;
-}
-
-int32_t mnodeInitMsg(SMnodeMsg *pMsg) {
-  if (pMsg->pUser != NULL) {
-    mTrace("msg:%p, app:%p user info already inited", pMsg, pMsg->rpcMsg.ahandle);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  pMsg->pUser = mnodeGetUserFromConn(pMsg->rpcMsg.handle);
-  if (pMsg->pUser == NULL) {
-    return TSDB_CODE_MND_INVALID_USER;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-void mnodeCleanupMsg(SMnodeMsg *pMsg) {
-  if (pMsg != NULL) {
-    if (pMsg->rpcMsg.pCont != pMsg->pCont) {
-      tfree(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->pSTable) mnodeDecTableRef(pMsg->pSTable);
-    if (pMsg->pAcct) mnodeDecAcctRef(pMsg->pAcct);
-    if (pMsg->pDnode) mnodeDecDnodeRef(pMsg->pDnode);
-  }
-}

src/mnode/src/mnodeMain.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosdef.h"
-#include "tsched.h"
-#include "tbn.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 "mnodeFunc.h"
-#include "mnodeTable.h"
-#include "mnodeCluster.h"
-#include "mnodeShow.h"
-#include "mnodeProfile.h"
-
-void *tsMnodeTmr = NULL;
-static bool tsMgmtIsRunning = false;
-
-static SStep tsMnodeSteps[] = {
-  {"sdbref",  sdbInitRef,       sdbCleanUpRef},
-  {"profile", mnodeInitProfile, mnodeCleanupProfile},
-  {"cluster", mnodeInitCluster, mnodeCleanupCluster},
-  {"accts",   mnodeInitAccts,   mnodeCleanupAccts},
-  {"users",   mnodeInitUsers,   mnodeCleanupUsers},
-  {"funcs",   mnodeInitFuncs,   mnodeCleanupFuncs},
-  {"dnodes",  mnodeInitDnodes,  mnodeCleanupDnodes},
-  {"dbs",     mnodeInitDbs,     mnodeCleanupDbs},
-  {"vgroups", mnodeInitVgroups, mnodeCleanupVgroups},
-  {"tables",  mnodeInitTables,  mnodeCleanupTables},  
-  {"mnodes",  mnodeInitMnodes,  mnodeCleanupMnodes},
-  {"sdb",     sdbInit,          sdbCleanUp},
-  {"balance", bnInit,           bnCleanUp},
-  {"grant",   grantInit,        grantCleanUp},
-  {"show",    mnodeInitShow,    mnodeCleanUpShow}
-};
-
-static SStep tsMnodeCompactSteps[] = {
-  {"cluster", mnodeCompactCluster, NULL},
-  {"dnodes",  mnodeCompactDnodes,  NULL},
-  {"mnodes",  mnodeCompactMnodes,  NULL},
-  {"accts",   mnodeCompactAccts,  NULL},
-  {"users",   mnodeCompactUsers,  NULL},
-  {"dbs",     mnodeCompactDbs,     NULL},
-  {"vgroups", mnodeCompactVgroups, NULL},
-  {"tables",  mnodeCompactTables,  NULL}, 
-
-};
-
-static void mnodeInitTimer();
-static void mnodeCleanupTimer();
-static bool mnodeNeedStart() ;
-
-static void mnodeCleanupComponents() {
-  int32_t stepSize = sizeof(tsMnodeSteps) / sizeof(SStep);
-  dnodeStepCleanup(tsMnodeSteps, stepSize);
-}
-
-static int32_t mnodeInitComponents() {
-  int32_t stepSize = sizeof(tsMnodeSteps) / sizeof(SStep);
-  return dnodeStepInit(tsMnodeSteps, stepSize);
-}
-
-int32_t mnodeCompactComponents() {
-  int32_t stepSize = sizeof(tsMnodeCompactSteps) / sizeof(SStep);
-  return dnodeStepInit(tsMnodeCompactSteps, stepSize);
-}
-
-int32_t mnodeStartSystem() {
-  if (tsMgmtIsRunning) {
-    mInfo("mnode module already started...");
-    return TSDB_CODE_SUCCESS;
-  }
-
-  mInfo("starting to initialize mnode ...");
-  if (mkdir(tsMnodeDir, 0755) != 0 && errno != EEXIST) {
-    mError("failed to init mnode dir:%s, reason:%s", tsMnodeDir, strerror(errno));
-    return TSDB_CODE_MND_FAILED_TO_CREATE_DIR;
-  }
-
-  dnodeAllocMWritequeue();
-  dnodeAllocMReadQueue();
-  dnodeAllocateMPeerQueue();
-
-  if (mnodeInitComponents() != 0) {
-    return TSDB_CODE_MND_FAILED_TO_INIT_STEP;
-  }
-
-  dnodeReportStep("mnode-grant", "start to set grant infomation", 0);
-  grantReset(TSDB_GRANT_ALL, 0);
-  tsMgmtIsRunning = true;
-
-  mInfo("mnode is initialized successfully");
-
-  sdbUpdateSync(NULL);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitSystem() {
-  mnodeInitTimer();
-  if (mnodeNeedStart() || tsCompactMnodeWal) {
-    return mnodeStartSystem();
-  }
-  return 0;
-}
-
-void mnodeCleanupSystem() {
-  if (tsMgmtIsRunning) {
-    mInfo("starting to clean up mnode");
-    tsMgmtIsRunning = false;
-
-    dnodeFreeMWritequeue();
-    dnodeFreeMReadQueue();
-    dnodeFreeMPeerQueue();
-    mnodeCleanupTimer();
-    mnodeCleanupComponents();
-
-    mInfo("mnode is cleaned up");
-  }
-}
-
-void mnodeStopSystem() {
-  if (sdbIsMaster()) {
-    mDebug("it is a master mnode, it could not be stopped");
-    return;
-  }
-  
-  mnodeCleanupSystem();
-
-  if (remove(tsMnodeDir) != 0) {
-    mInfo("failed to remove mnode file, reason:%s", strerror(errno));
-  } else {
-    mInfo("mnode file is removed");
-  }
-}
-
-static void mnodeInitTimer() {
-  if (tsMnodeTmr == NULL) {
-    tsMnodeTmr = taosTmrInit(tsMaxShellConns, 200, 3600000, "MND");
-  }
-}
-
-static void mnodeCleanupTimer() {
-  if (tsMnodeTmr != NULL) {
-    taosTmrCleanUp(tsMnodeTmr);
-    tsMnodeTmr = NULL;
-  }
-}
-
-static bool mnodeNeedStart() {
-  struct stat dirstat;
-  char mnodeFileName[TSDB_FILENAME_LEN * 2] = {0};
-  sprintf(mnodeFileName, "%s/wal/wal0", tsMnodeDir);
-
-  bool fileExist = (stat(mnodeFileName, &dirstat) == 0);
-  bool asMaster = (strcmp(tsFirst, tsLocalEp) == 0);
-
-  if (asMaster || fileExist) {
-    mDebug("mnode module start, asMaster:%d fileExist:%d", asMaster, fileExist);
-    return true;
-  } else {
-    mDebug("mnode module won't start, asMaster:%d fileExist:%d", asMaster, fileExist);
-    return false;
-  }
-}
-
-bool mnodeIsRunning() {
-  return tsMgmtIsRunning;
-}

src/mnode/src/mnodeMnode.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "tglobal.h"
-#include "trpc.h"
-#include "tsync.h"
-#include "tbn.h"
-#include "tutil.h"
-#include "tsocket.h"
-#include "tdataformat.h"
-#include "dnode.h"
-#include "mnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeMnode.h"
-#include "mnodeDnode.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeUser.h"
-#include "mnodeVgroup.h"
-
-int64_t          tsMnodeRid = -1;
-static void *    tsMnodeSdb = NULL;
-static int32_t   tsMnodeUpdateSize = 0;
-static SRpcEpSet tsMEpForShell;
-static SRpcEpSet tsMEpForPeer;
-static SMInfos   tsMInfos;
-static int32_t   mnodeGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t   mnodeRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-
-#if defined(LINUX)
-  static pthread_rwlock_t         tsMnodeLock;
-  #define mnodeMnodeWrLock()      pthread_rwlock_wrlock(&tsMnodeLock)
-  #define mnodeMnodeRdLock()      pthread_rwlock_rdlock(&tsMnodeLock)
-  #define mnodeMnodeUnLock()      pthread_rwlock_unlock(&tsMnodeLock)
-  #define mnodeMnodeInitLock()    pthread_rwlock_init(&tsMnodeLock, NULL)
-  #define mnodeMnodeDestroyLock() pthread_rwlock_destroy(&tsMnodeLock)
-#else
-  static pthread_mutex_t          tsMnodeLock;
-  #define mnodeMnodeWrLock()      pthread_mutex_lock(&tsMnodeLock)
-  #define mnodeMnodeRdLock()      pthread_mutex_lock(&tsMnodeLock)
-  #define mnodeMnodeUnLock()      pthread_mutex_unlock(&tsMnodeLock)
-  #define mnodeMnodeInitLock()    pthread_mutex_init(&tsMnodeLock, NULL)
-  #define mnodeMnodeDestroyLock() pthread_mutex_destroy(&tsMnodeLock)
-#endif
-
-static int32_t mnodeMnodeActionDestroy(SSdbRow *pRow) {
-  tfree(pRow->pObj);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionInsert(SSdbRow *pRow) {
-  SMnodeObj *pMnode = pRow->pObj;
-  SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
-  if (pDnode == NULL) return TSDB_CODE_MND_DNODE_NOT_EXIST;
-
-  pDnode->isMgmt = true;
-  mnodeDecDnodeRef(pDnode);
-
-  mInfo("mnode:%d, fqdn:%s ep:%s port:%u is created", pMnode->mnodeId, pDnode->dnodeFqdn, pDnode->dnodeEp,
-        pDnode->dnodePort);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionDelete(SSdbRow *pRow) {
-  SMnodeObj *pMnode = pRow->pObj;
-
-  SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
-  if (pDnode == NULL) return TSDB_CODE_MND_DNODE_NOT_EXIST;
-  pDnode->isMgmt = false;
-  mnodeDecDnodeRef(pDnode);
-
-  mDebug("mnode:%d, is dropped from sdb", pMnode->mnodeId);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionUpdate(SSdbRow *pRow) {
-  SMnodeObj *pMnode = pRow->pObj;
-  SMnodeObj *pSaved = mnodeGetMnode(pMnode->mnodeId);
-  if (pMnode != pSaved) {
-    memcpy(pSaved, pMnode, pRow->rowSize);
-    free(pMnode);
-  }
-  mnodeDecMnodeRef(pSaved);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionEncode(SSdbRow *pRow) {
-  SMnodeObj *pMnode = pRow->pObj;
-  memcpy(pRow->rowData, pMnode, tsMnodeUpdateSize);
-  pRow->rowSize = tsMnodeUpdateSize;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionDecode(SSdbRow *pRow) {
-  SMnodeObj *pMnode = calloc(1, sizeof(SMnodeObj));
-  if (pMnode == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
-  memcpy(pMnode, pRow->rowData, tsMnodeUpdateSize);
-  pRow->pObj = pMnode;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionRestored() {
-  if (mnodeGetMnodesNum() == 1) {
-    SMnodeObj *pMnode = NULL;
-    void *pIter = mnodeGetNextMnode(NULL, &pMnode);
-    if (pMnode != NULL) {
-      pMnode->role = TAOS_SYNC_ROLE_MASTER;
-      pMnode->roleTime = taosGetTimestampMs();
-      mnodeDecMnodeRef(pMnode);
-    }
-    mnodeCancelGetNextMnode(pIter);
-  }
-
-  mnodeUpdateMnodeEpSet(NULL);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitMnodes() {
-  mnodeMnodeInitLock();
-
-  SMnodeObj tObj;
-  tsMnodeUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
-  SSdbTableDesc desc = {
-    .id           = SDB_TABLE_MNODE,
-    .name         = "mnodes",
-    .hashSessions = TSDB_DEFAULT_MNODES_HASH_SIZE,
-    .maxRowSize   = tsMnodeUpdateSize,
-    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
-    .keyType      = SDB_KEY_INT,
-    .fpInsert     = mnodeMnodeActionInsert,
-    .fpDelete     = mnodeMnodeActionDelete,
-    .fpUpdate     = mnodeMnodeActionUpdate,
-    .fpEncode     = mnodeMnodeActionEncode,
-    .fpDecode     = mnodeMnodeActionDecode,
-    .fpDestroy    = mnodeMnodeActionDestroy,
-    .fpRestored   = mnodeMnodeActionRestored
-  };
-
-  tsMnodeRid = sdbOpenTable(&desc);
-  tsMnodeSdb = sdbGetTableByRid(tsMnodeRid);
-  if (tsMnodeSdb == NULL) {
-    mError("failed to init mnodes data");
-    return -1;
-  }
-
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_MNODE, mnodeGetMnodeMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_MNODE, mnodeRetrieveMnodes);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_MNODE, mnodeCancelGetNextMnode);
-
-  mDebug("table:mnodes table is created");
-  return TSDB_CODE_SUCCESS;
-}
-
-void mnodeCleanupMnodes() {
-  sdbCloseTable(tsMnodeRid);
-  tsMnodeSdb = NULL;
-  mnodeMnodeDestroyLock();
-}
-
-int32_t mnodeGetMnodesNum() { 
-  return (int32_t)sdbGetNumOfRows(tsMnodeSdb); 
-}
-
-void *mnodeGetMnode(int32_t mnodeId) {
-  return sdbGetRow(tsMnodeSdb, &mnodeId);
-}
-
-void mnodeIncMnodeRef(SMnodeObj *pMnode) {
-  sdbIncRef(tsMnodeSdb, pMnode);
-}
-
-void mnodeDecMnodeRef(SMnodeObj *pMnode) {
-  sdbDecRef(tsMnodeSdb, pMnode);
-}
-
-void *mnodeGetNextMnode(void *pIter, SMnodeObj **pMnode) { 
-  return sdbFetchRow(tsMnodeSdb, pIter, (void **)pMnode); 
-}
-
-void mnodeCancelGetNextMnode(void *pIter) {
-  sdbFreeIter(tsMnodeSdb, pIter);
-}
-
-void mnodeUpdateMnodeEpSet(SMInfos *pMinfos) {
-  bool    set = false;
-  SMInfos mInfos = {0};
-
-  if (pMinfos != NULL) {
-    mInfo("vgId:1, update mnodes epSet, numOfMinfos:%d", pMinfos->mnodeNum);
-    set = true;
-    mInfos = *pMinfos;
-  } else {
-    mInfo("vgId:1, update mnodes epSet, numOfMnodes:%d", mnodeGetMnodesNum());
-    int32_t index = 0;
-    void *  pIter = NULL;
-    while (1) {
-      SMnodeObj *pMnode = NULL;
-      pIter = mnodeGetNextMnode(pIter, &pMnode);
-      if (pMnode == NULL) break;
-
-      SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
-      if (pDnode != NULL) {
-        set = true;
-        mInfos.mnodeInfos[index].mnodeId = pMnode->mnodeId;
-        strcpy(mInfos.mnodeInfos[index].mnodeEp, pDnode->dnodeEp);
-        if (pMnode->role == TAOS_SYNC_ROLE_MASTER) mInfos.inUse = index;
-        index++;
-      } else {
-        set = false;
-      }
-
-      mnodeDecDnodeRef(pDnode);
-      mnodeDecMnodeRef(pMnode);
-    }
-
-    mInfos.mnodeNum = index;
-    if (mInfos.mnodeNum < sdbGetReplicaNum()) {
-      set = false;
-      mDebug("vgId:1, mnodes info not synced, current:%d syncCfgNum:%d", mInfos.mnodeNum, sdbGetReplicaNum());
-    }
-  }
-
-  mnodeMnodeWrLock();
-
-  if (set) {
-    memset(&tsMEpForShell, 0, sizeof(SRpcEpSet));
-    memset(&tsMEpForPeer, 0, sizeof(SRpcEpSet));
-    memcpy(&tsMInfos, &mInfos, sizeof(SMInfos));
-    tsMEpForShell.inUse = tsMInfos.inUse;
-    tsMEpForPeer.inUse = tsMInfos.inUse;
-    tsMEpForShell.numOfEps = tsMInfos.mnodeNum;
-    tsMEpForPeer.numOfEps = tsMInfos.mnodeNum;
-
-    mInfo("vgId:1, mnodes epSet is set, num:%d inUse:%d", tsMInfos.mnodeNum, tsMInfos.inUse);
-    for (int index = 0; index < mInfos.mnodeNum; ++index) {
-      SMInfo *pInfo = &tsMInfos.mnodeInfos[index];
-      taosGetFqdnPortFromEp(pInfo->mnodeEp, tsMEpForShell.fqdn[index], &tsMEpForShell.port[index]);
-      taosGetFqdnPortFromEp(pInfo->mnodeEp, tsMEpForPeer.fqdn[index], &tsMEpForPeer.port[index]);
-      tsMEpForPeer.port[index] = tsMEpForPeer.port[index] + TSDB_PORT_DNODEDNODE;
-
-      mInfo("vgId:1, mnode:%d, fqdn:%s shell:%u peer:%u", pInfo->mnodeId, tsMEpForShell.fqdn[index],
-            tsMEpForShell.port[index], tsMEpForPeer.port[index]);
-
-      tsMEpForShell.port[index] = htons(tsMEpForShell.port[index]);
-      tsMEpForPeer.port[index] = htons(tsMEpForPeer.port[index]);
-      pInfo->mnodeId = htonl(pInfo->mnodeId);
-    }
-  } else {
-    mInfo("vgId:1, mnodes epSet not set, num:%d inUse:%d", tsMInfos.mnodeNum, tsMInfos.inUse);
-    for (int index = 0; index < tsMInfos.mnodeNum; ++index) {
-      mInfo("vgId:1, index:%d, ep:%s:%u", index, tsMEpForShell.fqdn[index], htons(tsMEpForShell.port[index]));
-    }
-  }
-
-  mnodeMnodeUnLock();
-}
-
-void mnodeGetMnodeEpSetForPeer(SRpcEpSet *epSet, bool redirect) {
-  mnodeMnodeRdLock();
-  *epSet = tsMEpForPeer;
-  mnodeMnodeUnLock();
-
-  mTrace("vgId:1, mnodes epSet for peer is returned, num:%d inUse:%d", tsMEpForPeer.numOfEps, tsMEpForPeer.inUse);
-  for (int32_t i = 0; i < epSet->numOfEps; ++i) {
-    if (redirect && strcmp(epSet->fqdn[i], tsLocalFqdn) == 0 && htons(epSet->port[i]) == tsServerPort + TSDB_PORT_DNODEDNODE) {
-      epSet->inUse = (i + 1) % epSet->numOfEps;
-      mTrace("vgId:1, mnode:%d, for peer ep:%s:%u, set inUse to %d", i, epSet->fqdn[i], htons(epSet->port[i]), epSet->inUse);
-    } else {
-      mTrace("vgId:1, mpeer:%d, for peer ep:%s:%u", i, epSet->fqdn[i], htons(epSet->port[i]));
-    }
-  }
-}
-
-void mnodeGetMnodeEpSetForShell(SRpcEpSet *epSet, bool redirect) {
-  mnodeMnodeRdLock();
-  *epSet = tsMEpForShell;
-  mnodeMnodeUnLock();
-
-  if (mnodeGetDnodesNum() <= 1) {
-    epSet->numOfEps = 0;
-    return;
-  }
-
-  mTrace("vgId:1, mnodes epSet for shell is returned, num:%d inUse:%d", tsMEpForShell.numOfEps, tsMEpForShell.inUse);
-  for (int32_t i = 0; i < epSet->numOfEps; ++i) {
-    if (redirect && strcmp(epSet->fqdn[i], tsLocalFqdn) == 0 && htons(epSet->port[i]) == tsServerPort) {
-      epSet->inUse = (i + 1) % epSet->numOfEps;
-      mTrace("vgId:1, mnode:%d, for shell ep:%s:%u, set inUse to %d", i, epSet->fqdn[i], htons(epSet->port[i]), epSet->inUse);
-    } else {
-      mTrace("vgId:1, mnode:%d, for shell ep:%s:%u", i, epSet->fqdn[i], htons(epSet->port[i]));
-    }
-  }
-}
-
-char* mnodeGetMnodeMasterEp() {
-  return tsMInfos.mnodeInfos[tsMInfos.inUse].mnodeEp;
-}
-
-void mnodeGetMnodeInfos(void *pMinfos) {
-  mnodeMnodeRdLock();
-  *(SMInfos *)pMinfos = tsMInfos;
-  mnodeMnodeUnLock();
-}
-
-static int32_t mnodeSendCreateMnodeMsg(int32_t dnodeId, char *dnodeEp) {
-  SCreateMnodeMsg *pCreate = rpcMallocCont(sizeof(SCreateMnodeMsg));
-  if (pCreate == NULL) {
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  } else {
-    pCreate->dnodeId = htonl(dnodeId);
-    tstrncpy(pCreate->dnodeEp, dnodeEp, sizeof(pCreate->dnodeEp));
-    mnodeGetMnodeInfos(&pCreate->mnodes);
-    bool found = false;
-    for (int i = 0; i < pCreate->mnodes.mnodeNum; ++i) {
-      if (pCreate->mnodes.mnodeInfos[i].mnodeId == htonl(dnodeId)) {
-        found = true;
-      }
-    }
-    if (!found) {
-      pCreate->mnodes.mnodeInfos[pCreate->mnodes.mnodeNum].mnodeId = htonl(dnodeId);
-      tstrncpy(pCreate->mnodes.mnodeInfos[pCreate->mnodes.mnodeNum].mnodeEp, dnodeEp, sizeof(pCreate->dnodeEp));
-      pCreate->mnodes.mnodeNum++;
-    }
-  }
-
-  mDebug("dnode:%d, send create mnode msg to dnode %s, numOfMnodes:%d", dnodeId, dnodeEp, pCreate->mnodes.mnodeNum);
-  for (int32_t i = 0; i < pCreate->mnodes.mnodeNum; ++i) {
-    mDebug("index:%d, mnodeId:%d ep:%s", i, pCreate->mnodes.mnodeInfos[i].mnodeId, pCreate->mnodes.mnodeInfos[i].mnodeEp);
-  }
-
-  SRpcMsg rpcMsg = {0};
-  rpcMsg.pCont = pCreate;
-  rpcMsg.contLen = sizeof(SCreateMnodeMsg);
-  rpcMsg.msgType = TSDB_MSG_TYPE_MD_CREATE_MNODE;
-
-  SRpcMsg   rpcRsp = {0};
-  SRpcEpSet epSet = mnodeGetEpSetFromIp(pCreate->dnodeEp);
-  dnodeSendMsgToDnodeRecv(&rpcMsg, &rpcRsp, &epSet);
-
-  if (rpcRsp.code != TSDB_CODE_SUCCESS) {
-    mError("dnode:%d, failed to send create mnode msg, ep:%s reason:%s", dnodeId, dnodeEp, tstrerror(rpcRsp.code));
-  } else {
-    mDebug("dnode:%d, create mnode msg is disposed, mnode is created in dnode", dnodeId);
-  }
-
-  rpcFreeCont(rpcRsp.pCont);
-  return rpcRsp.code;
-}
-
-static int32_t mnodeCreateMnodeCb(SMnodeMsg *pMsg, int32_t code) {
-  if (code != TSDB_CODE_SUCCESS) {
-    mError("failed to create mnode, reason:%s", tstrerror(code));
-  } else {
-    mDebug("mnode is created successfully");
-    mnodeUpdateMnodeEpSet(NULL);
-    sdbUpdateAsync();
-  }
-
-  return code;
-}
-
-static bool mnodeAllOnline() {
-  void *pIter = NULL;
-  bool  allOnline = true;
-
-  sdbUpdateMnodeRoles();
-
-  while (1) {
-    SMnodeObj *pMnode = NULL;
-    pIter = mnodeGetNextMnode(pIter, &pMnode);
-    if (pMnode == NULL) break;
-    if (pMnode->role != TAOS_SYNC_ROLE_MASTER && pMnode->role != TAOS_SYNC_ROLE_SLAVE) {
-      allOnline = false;
-      mDebug("mnode:%d, role:%s, not online", pMnode->mnodeId, syncRole[pMnode->role]);
-      mnodeDecMnodeRef(pMnode);
-    }
-  }
-  mnodeCancelGetNextMnode(pIter);
-
-  return allOnline;
-}
-
-void mnodeCreateMnode(int32_t dnodeId, char *dnodeEp, bool needConfirm) {
-  SMnodeObj *pMnode = calloc(1, sizeof(SMnodeObj));
-  pMnode->mnodeId = dnodeId;
-  pMnode->createdTime = taosGetTimestampMs();
-
-  SSdbRow row = {
-    .type    = SDB_OPER_GLOBAL,
-    .pTable  = tsMnodeSdb,
-    .pObj    = pMnode,
-    .fpRsp   = mnodeCreateMnodeCb
-  };
-
-  if (needConfirm && !mnodeAllOnline()) {
-    mDebug("wait all mnode online then create new mnode");
-    return;
-  }
-
-  int32_t code = TSDB_CODE_SUCCESS;
-  if (needConfirm) {
-    code = mnodeSendCreateMnodeMsg(dnodeId, dnodeEp);
-  }
-
-  if (code != TSDB_CODE_SUCCESS) {
-    tfree(pMnode);
-    return;
-  }
-
-  code = sdbInsertRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("dnode:%d, failed to create mnode, ep:%s reason:%s", dnodeId, dnodeEp, tstrerror(code));
-    tfree(pMnode);
-  }
-}
-
-void mnodeDropMnodeLocal(int32_t dnodeId) {
-  SMnodeObj *pMnode = mnodeGetMnode(dnodeId);
-  if (pMnode != NULL) {
-    SSdbRow row = {.type = SDB_OPER_LOCAL, .pTable = tsMnodeSdb, .pObj = pMnode};
-    sdbDeleteRow(&row);
-    mnodeDecMnodeRef(pMnode);
-  }
-
-  mnodeUpdateMnodeEpSet(NULL);
-  sdbUpdateAsync();
-}
-
-int32_t mnodeDropMnode(int32_t dnodeId) {
-  SMnodeObj *pMnode = mnodeGetMnode(dnodeId);
-  if (pMnode == NULL) {
-    return TSDB_CODE_MND_DNODE_NOT_EXIST;
-  }
-  
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsMnodeSdb,
-    .pObj   = pMnode
-  };
-
-  int32_t code = sdbDeleteRow(&row);
-
-  sdbDecRef(tsMnodeSdb, pMnode);
-
-  mnodeUpdateMnodeEpSet(NULL);
-  sdbUpdateAsync();
-
-  return code;
-}
-
-static int32_t mnodeGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  sdbUpdateMnodeRoles();
-  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) return 0;
-
-  if (strcmp(pUser->pAcct->user, TSDB_DEFAULT_USER) != 0)  {
-    mnodeDecUserRef(pUser);
-    return TSDB_CODE_MND_NO_RIGHTS;
-  }
-
-  int32_t  cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "id");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_EP_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "end_point");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 12 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "role");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "role_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "create_time");
-  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 = mnodeGetMnodesNum();
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-  pShow->pIter = NULL;
-  mnodeDecUserRef(pUser);
-
-  return 0;
-}
-
-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 = mnodeGetNextMnode(pShow->pIter, &pMnode);
-    if (pMnode == NULL) break;
-
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pMnode->mnodeId;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    
-    SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
-    if (pDnode != NULL) {
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDnode->dnodeEp, pShow->bytes[cols]);
-    } else {
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, "invalid ep", pShow->bytes[cols]);
-    }
-    mnodeDecDnodeRef(pDnode);
-
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    char* roles = syncRole[pMnode->role];
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, roles, pShow->bytes[cols]);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pMnode->roleTime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pMnode->createdTime;
-    cols++;
-    
-    numOfRows++;
-
-    mnodeDecMnodeRef(pMnode);
-  }
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  pShow->numOfReads += numOfRows;
-
-  return numOfRows;
-}
-
-int32_t mnodeCompactMnodes() {
-  void *pIter = NULL;
-  SMnodeObj *pMnode = NULL;
-
-  mInfo("start to compact mnodes table...");
-
-  while (1) {
-    pIter = mnodeGetNextMnode(pIter, &pMnode);
-    if (pMnode == NULL) break;
-
-    SSdbRow row = {
-      .type    = SDB_OPER_GLOBAL,
-      .pTable  = tsMnodeSdb,
-      .pObj    = pMnode,
-      .rowSize = sizeof(SMnodeObj),
-    };
-
-    mInfo("compact mnode %d", pMnode->mnodeId);
-    
-    sdbInsertCompactRow(&row);
-  }
-
-  mInfo("end to compact mnodes table...");
-
-  return 0; 
-}
\ No newline at end of file

src/mnode/src/mnodePeer.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "tsched.h"
-#include "tutil.h"
-#include "tgrant.h"
-#include "tbn.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("msg:%p, ahandle:%p type:%s in mpeer queue, content is null", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
-    return TSDB_CODE_MND_INVALID_MSG_LEN;
-  }
-
-  if (!sdbIsMaster()) {
-    SMnodeRsp *rpcRsp = &pMsg->rpcRsp;
-    SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
-    mnodeGetMnodeEpSetForPeer(epSet, true);
-    rpcRsp->rsp = epSet;
-    rpcRsp->len = sizeof(SRpcEpSet);
-
-    mDebug("msg:%p, ahandle:%p type:%s in mpeer queue is redirected, numOfEps:%d inUse:%d", pMsg, pMsg->rpcMsg.ahandle,
-           taosMsg[pMsg->rpcMsg.msgType], epSet->numOfEps, epSet->inUse);
-
-    return TSDB_CODE_RPC_REDIRECT;
-  }
-
-  if (tsMnodeProcessPeerMsgFp[pMsg->rpcMsg.msgType] == NULL) {
-    mError("msg:%p, ahandle:%p type:%s in mpeer queue, not processed", pMsg, pMsg->rpcMsg.ahandle,
-           taosMsg[pMsg->rpcMsg.msgType]);
-    return TSDB_CODE_MND_MSG_NOT_PROCESSED;
-  }
-
-  return (*tsMnodeProcessPeerMsgFp[pMsg->rpcMsg.msgType])(pMsg);
-}
-
-void mnodeProcessPeerRsp(SRpcMsg *pMsg) {
-  if (!sdbIsMaster()) {
-    mError("msg:%p, ahandle:%p type:%s  is not processed for it is not master", pMsg, pMsg->ahandle,
-           taosMsg[pMsg->msgType]);
-    return;
-  }
-
-  if (tsMnodeProcessPeerRspFp[pMsg->msgType]) {
-    (*tsMnodeProcessPeerRspFp[pMsg->msgType])(pMsg);
-  } else {
-    mError("msg:%p, ahandle:%p type:%s is not processed", pMsg, pMsg->ahandle, taosMsg[pMsg->msgType]);
-  }
-}

src/mnode/src/mnodeProfile.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosmsg.h"
-#include "taoserror.h"
-#include "tutil.h"
-#include "tcache.h"
-#include "tglobal.h"
-#include "tdataformat.h"
-#include "mnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeProfile.h"
-#include "mnodeShow.h"
-#include "mnodeUser.h"
-#include "mnodeWrite.h"
-
-#define CONN_KEEP_TIME  (tsShellActivityTimer * 3)
-#define CONN_CHECK_TIME (tsShellActivityTimer * 2)
-#define QUERY_ID_SIZE   20
-#define QUERY_OBJ_ID_SIZE   18
-#define SUBQUERY_INFO_SIZE   6
-#define QUERY_STREAM_SAVE_SIZE 20
-
-static SCacheObj *tsMnodeConnCache = NULL;
-static int32_t tsConnIndex = 0;
-
-static int32_t mnodeGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveConns(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void    mnodeCancelGetNextConn(void *pIter);
-static int32_t mnodeGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void    mnodeFreeConn(void *data);
-static int32_t mnodeProcessKillQueryMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessKillStreamMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessKillConnectionMsg(SMnodeMsg *pMsg);
-
-int32_t mnodeInitProfile() {
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mnodeGetQueryMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mnodeRetrieveQueries);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_QUERIES, mnodeCancelGetNextConn);
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mnodeGetConnsMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mnodeRetrieveConns);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_CONNS, mnodeCancelGetNextConn);
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_STREAMS, mnodeGetStreamMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMS, mnodeRetrieveStreams);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_STREAMS, mnodeCancelGetNextConn);
-
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mnodeProcessKillQueryMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mnodeProcessKillStreamMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_CONN, mnodeProcessKillConnectionMsg);
-
-  tsMnodeConnCache = taosCacheInit(TSDB_DATA_TYPE_INT, CONN_CHECK_TIME, true, mnodeFreeConn, "conn");
-  return 0;
-}
-
-void mnodeCleanupProfile() {
-  if (tsMnodeConnCache != NULL) {
-    taosCacheCleanup(tsMnodeConnCache);
-    tsMnodeConnCache = NULL;
-  }
-}
-
-SConnObj *mnodeCreateConn(char *user, uint32_t ip, uint16_t port, int32_t pid, const char* app) {
-#if 0
-  int32_t connSize = taosHashGetSize(tsMnodeConnCache->pHashTable);
-  if (connSize > tsMaxShellConns) {
-    mError("failed to create conn for user:%s ip:%s:%u, conns:%d larger than maxShellConns:%d, ", user, taosIpStr(ip),
-           port, connSize, tsMaxShellConns);
-    terrno = TSDB_CODE_MND_TOO_MANY_SHELL_CONNS;
-    return NULL;
-  }
-#endif  
-
-  int32_t connId = atomic_add_fetch_32(&tsConnIndex, 1);
-  if (connId == 0) atomic_add_fetch_32(&tsConnIndex, 1);
-
-  SConnObj connObj = {
-    .ip     = ip,
-    .port   = port,
-    .connId = connId,
-    .stime  = taosGetTimestampMs(),
-    .pid    = pid,
-  };
-
-  tstrncpy(connObj.user, user, tListLen(connObj.user));
-  tstrncpy(connObj.appName, app, tListLen(connObj.appName));
-
-  connObj.lastAccess = connObj.stime;
-
-  SConnObj *pConn = taosCachePut(tsMnodeConnCache, &connId, sizeof(int32_t), &connObj, sizeof(connObj), CONN_KEEP_TIME * 1000);
-
-  mDebug("connId:%d, is created, user:%s ip:%s:%u", connId, user, taosIpStr(ip), port);
-  return pConn;
-}
-
-void mnodeReleaseConn(SConnObj *pConn) {
-  if (pConn == NULL) return;
-  taosCacheRelease(tsMnodeConnCache, (void **)&pConn, false);
-}
-
-SConnObj *mnodeAccquireConn(int32_t connId, char *user, uint32_t ip, uint16_t port) {
-  SConnObj *pConn = taosCacheAcquireByKey(tsMnodeConnCache, &connId, sizeof(int32_t));
-  if (pConn == NULL) {
-    mDebug("connId:%d, is already destroyed, user:%s ip:%s:%u", connId, user, taosIpStr(ip), port);
-    return NULL;
-  }
-
-  if (/* pConn->ip != ip || */ pConn->port != port /* || strcmp(pConn->user, user) != 0 */) {
-    mDebug("connId:%d, incoming conn user:%s ip:%s:%u, not match exist conn user:%s ip:%s:%u", connId, user,
-           taosIpStr(ip), port, pConn->user, taosIpStr(pConn->ip), pConn->port);
-    pConn->port = port;
-    //taosCacheRelease(tsMnodeConnCache, (void **)&pConn, false);
-    //return NULL;
-  }
-
-  // mDebug("connId:%d, is incoming, user:%s ip:%s:%u", connId, pConn->user, taosIpStr(pConn->ip), pConn->port);
-  pConn->lastAccess = CONN_KEEP_TIME * 1000 + (uint64_t)taosGetTimestampMs();
-  return pConn;
-}
-
-static void mnodeFreeConn(void *data) {
-  SConnObj *pConn = data;
-  tfree(pConn->pQueries);
-  tfree(pConn->pStreams);
-
-  mDebug("connId:%d, is destroyed", pConn->connId);
-}
-
-static void *mnodeGetNextConn(void *pIter, SConnObj **pConn) {
-  *pConn = NULL;
-
-  pIter = taosHashIterate(tsMnodeConnCache->pHashTable, pIter);
-  if (pIter == NULL) return NULL;
-
-  SCacheDataNode **pNode = pIter;
-  if (pNode == NULL || *pNode == NULL) {
-    taosHashCancelIterate(tsMnodeConnCache->pHashTable, pIter);
-    return NULL;
-  }
-
-  *pConn = (SConnObj*)((*pNode)->data);
-  return pIter;
-}
-
-static void mnodeCancelGetNextConn(void *pIter) {
-  taosHashCancelIterate(tsMnodeConnCache->pHashTable, pIter);
-}
-
-static int32_t mnodeGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) return 0;
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-  
-  int32_t cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "connId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "user");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  // app name
-  pShow->bytes[cols] = TSDB_APPNAME_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "program");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  // app pid
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "pid");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "ip:port");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "login_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "last_access");
-  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 = taosHashGetSize(tsMnodeConnCache->pHashTable);
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  return 0;
-}
-
-static int32_t mnodeRetrieveConns(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  int32_t   numOfRows = 0;
-  SConnObj *pConnObj = NULL;
-  int32_t   cols = 0;
-  char *    pWrite;
-  char      ipStr[TSDB_IPv4ADDR_LEN + 6];
-
-  while (numOfRows < rows) {
-    pShow->pIter = mnodeGetNextConn(pShow->pIter, &pConnObj);
-    if (pConnObj == NULL) break;
-    
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *) pWrite = pConnObj->connId;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pConnObj->user, pShow->bytes[cols]);
-    cols++;
-
-    // app name
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pConnObj->appName, pShow->bytes[cols]);
-    cols++;
-
-    // app pid
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t*)pWrite = pConnObj->pid;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    snprintf(ipStr, sizeof(ipStr), "%s:%u", taosIpStr(pConnObj->ip), pConnObj->port);
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, ipStr, pShow->bytes[cols]);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pConnObj->stime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    if (pConnObj->lastAccess < pConnObj->stime) pConnObj->lastAccess = pConnObj->stime;
-    *(int64_t *)pWrite = pConnObj->lastAccess;
-    cols++;
-
-    numOfRows++;
-  }
-
-  pShow->numOfReads += numOfRows;
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  
-  return numOfRows;
-}
-
-// not thread safe, need optimized
-int32_t mnodeSaveQueryStreamList(SConnObj *pConn, SHeartBeatMsg *pHBMsg) {
-  pConn->numOfQueries = 0;	
-  pConn->numOfStreams = 0;
-  int32_t numOfQueries = htonl(pHBMsg->numOfQueries);
-  int32_t numOfStreams = htonl(pHBMsg->numOfStreams);
-  
-  if (numOfQueries > 0) {
-    if (pConn->pQueries == NULL) {
-      pConn->pQueries = calloc(sizeof(SQueryDesc), QUERY_STREAM_SAVE_SIZE);
-    }
-
-    pConn->numOfQueries = MIN(QUERY_STREAM_SAVE_SIZE, numOfQueries);
-
-    int32_t saveSize = pConn->numOfQueries * sizeof(SQueryDesc);
-    if (saveSize > 0 && pConn->pQueries != NULL) {
-      memcpy(pConn->pQueries, pHBMsg->pData, saveSize);
-    }
-  }
-
-  if (numOfStreams > 0) {
-    if (pConn->pStreams == NULL) {
-      pConn->pStreams = calloc(sizeof(SStreamDesc), QUERY_STREAM_SAVE_SIZE);
-    }
-
-    pConn->numOfStreams = MIN(QUERY_STREAM_SAVE_SIZE, numOfStreams);
-
-    int32_t saveSize = pConn->numOfStreams * sizeof(SStreamDesc);
-    if (saveSize > 0 && pConn->pStreams != NULL) {
-      memcpy(pConn->pStreams, pHBMsg->pData + numOfQueries * sizeof(SQueryDesc), saveSize);
-    }
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) return 0;
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-
-  int32_t cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = QUERY_ID_SIZE + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "query_id");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
-  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 + 6 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "ip:port");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 24;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "qid");
-  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_BIGINT;
-  strcpy(pSchema[cols].name, "time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = QUERY_OBJ_ID_SIZE + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "sql_obj_id");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "pid");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_EP_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "ep");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 1;
-  pSchema[cols].type = TSDB_DATA_TYPE_BOOL;
-  strcpy(pSchema[cols].name, "stable_query");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "sub_queries");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_SHOW_SUBQUERY_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "sub_query_info");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "sql");
-  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->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  return 0;
-}
-
-static int32_t mnodeRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  int32_t   numOfRows = 0;
-  SConnObj *pConnObj = NULL;
-  int32_t   cols = 0;
-  char *    pWrite;
-  void *    pIter;
-  char      str[TSDB_IPv4ADDR_LEN + 6] = {0};
-
-  while (numOfRows < rows) {
-    pIter = mnodeGetNextConn(pShow->pIter, &pConnObj);
-    if (pConnObj == NULL) {
-      pShow->pIter = pIter;
-      break;
-    }
-
-    if (numOfRows + pConnObj->numOfQueries >= rows) {
-      mnodeCancelGetNextConn(pIter);
-      break;
-    }
-
-    pShow->pIter = pIter;
-    for (int32_t i = 0; i < pConnObj->numOfQueries; ++i) {
-      SQueryDesc *pDesc = pConnObj->pQueries + i;
-      cols = 0;
-
-      snprintf(str, QUERY_ID_SIZE + 1, "%u:%u", pConnObj->connId, htonl(pDesc->queryId));
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, str, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pConnObj->user, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      snprintf(str, tListLen(str), "%s:%u", taosIpStr(pConnObj->ip), pConnObj->port);
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, str, pShow->bytes[cols]);
-      cols++;
-
-      char handleBuf[24] = {0};
-      snprintf(handleBuf, tListLen(handleBuf), "%"PRIu64, htobe64(pDesc->qId));
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, handleBuf, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int64_t *)pWrite = htobe64(pDesc->stime);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int64_t *)pWrite = htobe64(pDesc->useconds);
-      cols++;
-
-      snprintf(str, tListLen(str), "0x%" PRIx64, htobe64(pDesc->sqlObjId));
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, str, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int32_t *)pWrite = htonl(pDesc->pid);
-      cols++;
-
-      char epBuf[TSDB_EP_LEN + 1] = {0};
-      snprintf(epBuf, tListLen(epBuf), "%s:%u", pDesc->fqdn, pConnObj->port);
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, epBuf, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(bool *)pWrite = pDesc->stableQuery;
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int32_t *)pWrite = htonl(pDesc->numOfSub);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDesc->subSqlInfo, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDesc->sql, pShow->bytes[cols]);
-      cols++;
-
-      numOfRows++;
-    }
-  }
-
-  pShow->numOfReads += numOfRows;
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  return numOfRows;
-}
-
-static int32_t mnodeGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) return 0;
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-
-  int32_t cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = QUERY_ID_SIZE + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "streamId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "user");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "dest table");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "ip:port");
-  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_BIGINT;
-  strcpy(pSchema[cols].name, "time(us)");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE;
-  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->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  return 0;
-}
-
-static int32_t mnodeRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  int32_t   numOfRows = 0;
-  SConnObj *pConnObj = NULL;
-  int32_t   cols = 0;
-  char *    pWrite;
-  void *    pIter;
-  char      ipStr[TSDB_IPv4ADDR_LEN + 6];
-
-  while (numOfRows < rows) {
-    pIter = mnodeGetNextConn(pShow->pIter, &pConnObj);
-    if (pConnObj == NULL) {
-      pShow->pIter = pIter;
-      break;
-    }
-
-    if (numOfRows + pConnObj->numOfStreams >= rows) {
-      mnodeCancelGetNextConn(pIter);
-      break;
-    }
-
-    pShow->pIter = pIter;
-    for (int32_t i = 0; i < pConnObj->numOfStreams; ++i) {
-      SStreamDesc *pDesc = pConnObj->pStreams + i;
-      cols = 0;
-
-      snprintf(ipStr, QUERY_ID_SIZE + 1, "%u:%u", pConnObj->connId, htonl(pDesc->streamId));
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, ipStr, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pConnObj->user, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDesc->dstTable, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      snprintf(ipStr, sizeof(ipStr), "%s:%u", taosIpStr(pConnObj->ip), pConnObj->port);
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, ipStr, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int64_t *)pWrite = htobe64(pDesc->ctime);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int64_t *)pWrite = htobe64(pDesc->stime);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int64_t *)pWrite = htobe64(pDesc->useconds);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDesc->sql, pShow->bytes[cols]);
-      cols++;
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int32_t *)pWrite = (int32_t)htobe64(pDesc->num);
-      cols++;
-
-      numOfRows++;
-    }
-  }
-
-  pShow->numOfReads += numOfRows;
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  return numOfRows;
-}
-
-static int32_t mnodeProcessKillQueryMsg(SMnodeMsg *pMsg) {
-  SUserObj *pUser = pMsg->pUser;
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-
-  SKillQueryMsg *pKill = pMsg->rpcMsg.pCont;
-  mInfo("kill query msg is received, queryId:%s", pKill->queryId);
-
-  const char delim = ':';
-  char* connIdStr = strtok(pKill->queryId, &delim);
-  char* queryIdStr = strtok(NULL, &delim);
-
-  if (queryIdStr == NULL || connIdStr == NULL) {
-    mInfo("failed to kill query, queryId:%s", pKill->queryId);
-   return TSDB_CODE_MND_INVALID_QUERY_ID;
-  }
-
-  int32_t queryId = (int32_t)strtol(queryIdStr, NULL, 10);
-
-  int32_t connId = atoi(connIdStr);
-  SConnObj *pConn = taosCacheAcquireByKey(tsMnodeConnCache, &connId, sizeof(int32_t));
-  if (pConn == NULL) {
-    mError("connId:%s, failed to kill queryId:%d, conn not exist", connIdStr, queryId);
-    return TSDB_CODE_MND_INVALID_CONN_ID;
-  } else {
-    mInfo("connId:%s, queryId:%d is killed by user:%s", connIdStr, queryId, pUser->user);
-    pConn->queryId = queryId;
-    taosCacheRelease(tsMnodeConnCache, (void **)&pConn, false);
-    return TSDB_CODE_SUCCESS;
-  }
-}
-
-static int32_t mnodeProcessKillStreamMsg(SMnodeMsg *pMsg) {
-  SUserObj *pUser = pMsg->pUser;
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-
-  SKillQueryMsg *pKill = pMsg->rpcMsg.pCont;
-  mInfo("kill stream msg is received, streamId:%s", pKill->queryId);
-
-  const char delim = ':';
-  char* connIdStr = strtok(pKill->queryId, &delim);
-  char* streamIdStr = strtok(NULL, &delim);
-
-  if (streamIdStr == NULL || connIdStr == NULL) {
-    mInfo("failed to kill stream, streamId:%s", pKill->queryId);
-   return TSDB_CODE_MND_INVALID_STREAM_ID;
-  }
-
-  int32_t streamId = (int32_t)strtol(streamIdStr, NULL, 10);
-  int32_t connId = atoi(connIdStr);
-
-  SConnObj *pConn = taosCacheAcquireByKey(tsMnodeConnCache, &connId, sizeof(int32_t));
-  if (pConn == NULL) {
-    mError("connId:%s, failed to kill streamId:%d, conn not exist", connIdStr, streamId);
-    return TSDB_CODE_MND_INVALID_CONN_ID;
-  } else {
-    mInfo("connId:%s, streamId:%d is killed by user:%s", connIdStr, streamId, pUser->user);
-    pConn->streamId = streamId;
-    taosCacheRelease(tsMnodeConnCache, (void **)&pConn, false);
-    return TSDB_CODE_SUCCESS;
-  }
-}
-
-static int32_t mnodeProcessKillConnectionMsg(SMnodeMsg *pMsg) {
-  SUserObj *pUser = pMsg->pUser;
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-
-  SKillConnMsg *pKill = pMsg->rpcMsg.pCont;
-  int32_t connId = atoi(pKill->queryId);
-  SConnObj *pConn = taosCacheAcquireByKey(tsMnodeConnCache, &connId, sizeof(int32_t));
-  if (pConn == NULL) {
-    mError("connId:%s, failed to kill, conn not exist", pKill->queryId);
-    return TSDB_CODE_MND_INVALID_CONN_ID;
-  } else {
-    mInfo("connId:%s, is killed by user:%s", pKill->queryId, pUser->user);
-    pConn->killed = 1;
-    taosCacheRelease(tsMnodeConnCache, (void**)&pConn, false);
-    return TSDB_CODE_SUCCESS;
-  }
-}

src/mnode/src/mnodeRead.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosdef.h"
-#include "tsched.h"
-#include "tbn.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("msg:%p, app:%p type:%s in mread queue, content is null", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
-    return TSDB_CODE_MND_INVALID_MSG_LEN;
-  }
-
-  if (!sdbIsMaster()) {
-    SMnodeRsp *rpcRsp = &pMsg->rpcRsp;
-    SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
-    if (!epSet) {
-      return TSDB_CODE_MND_OUT_OF_MEMORY;
-    }
-    mnodeGetMnodeEpSetForShell(epSet, true);
-    rpcRsp->rsp = epSet;
-    rpcRsp->len = sizeof(SRpcEpSet);
-
-    mDebug("msg:%p, app:%p type:%s in mread queue is redirected, numOfEps:%d inUse:%d", pMsg, pMsg->rpcMsg.ahandle,
-           taosMsg[pMsg->rpcMsg.msgType], epSet->numOfEps, epSet->inUse);
-
-    return TSDB_CODE_RPC_REDIRECT;
-  }
-
-  if (tsMnodeProcessReadMsgFp[pMsg->rpcMsg.msgType] == NULL) {
-    mError("msg:%p, app:%p type:%s in mread queue, not processed", pMsg, pMsg->rpcMsg.ahandle,
-           taosMsg[pMsg->rpcMsg.msgType]);
-    return TSDB_CODE_MND_MSG_NOT_PROCESSED;
-  }
-
-  int32_t code = mnodeInitMsg(pMsg);
-  if (code != TSDB_CODE_SUCCESS) {
-    mError("msg:%p, app:%p type:%s in mread queue, not processed reason:%s", pMsg, pMsg->rpcMsg.ahandle,
-           taosMsg[pMsg->rpcMsg.msgType], tstrerror(code));
-    return code;
-  }
-
-  return (*tsMnodeProcessReadMsgFp[pMsg->rpcMsg.msgType])(pMsg);
-}

src/mnode/src/mnodeSdb.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "hash.h"
-#include "tutil.h"
-#include "tref.h"
-#include "tbn.h"
-#include "tfs.h"
-#include "tqueue.h"
-#include "twal.h"
-#include "tsync.h"
-#include "ttimer.h"
-#include "tglobal.h"
-#include "dnode.h"
-#include "mnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeMnode.h"
-#include "mnodeDnode.h"
-#include "mnodeCluster.h"
-#include "mnodeSdb.h"
-
-#define SDB_TABLE_LEN 12
-#define MAX_QUEUED_MSG_NUM 100000
-
-typedef enum {
-  SDB_ACTION_INSERT = 0,
-  SDB_ACTION_DELETE = 1,
-  SDB_ACTION_UPDATE = 2
-} ESdbAction;
-
-typedef enum {
-  SDB_STATUS_OFFLINE = 0,
-  SDB_STATUS_SERVING = 1,
-  SDB_STATUS_CLOSING = 2
-} ESdbStatus;
-
-char *actStr[] = {
-  "insert",
-  "delete",
-  "update",
-  "invalid"
-};
-
-typedef struct SSdbTable {
-  char      name[SDB_TABLE_LEN];
-  ESdbTable id;
-  ESdbKey   keyType;
-  int32_t   hashSessions;
-  int32_t   maxRowSize;
-  int32_t   refCountPos;
-  int32_t   autoIndex;
-  int64_t   numOfRows;
-  void *    iHandle;
-  int32_t (*fpInsert)(SSdbRow *pRow);
-  int32_t (*fpDelete)(SSdbRow *pRow);
-  int32_t (*fpUpdate)(SSdbRow *pRow);
-  int32_t (*fpDecode)(SSdbRow *pRow);
-  int32_t (*fpEncode)(SSdbRow *pRow);
-  int32_t (*fpDestroy)(SSdbRow *pRow);
-  int32_t (*fpRestored)();
-  pthread_mutex_t mutex;
-} SSdbTable;
-
-typedef struct {
-  ESyncRole  role;
-  ESdbStatus status;
-  uint64_t   version;
-  int64_t    sync;
-  void *     wal;
-  SSyncCfg   cfg;
-  int32_t    queuedMsg;
-  int32_t    numOfTables;
-  SSdbTable *tableList[SDB_TABLE_MAX];
-  pthread_mutex_t mutex;
-} SSdbMgmt;
-
-typedef struct {
-  pthread_t thread;
-  int32_t   workerId;
-} SSdbWorker;
-
-typedef struct {
-  int32_t num;
-  SSdbWorker *worker;
-} SSdbWorkerPool;
-
-int32_t tsSdbRid;
-extern void *     tsMnodeTmr;
-static void *     tsSdbTmr;
-static SSdbMgmt   tsSdbMgmt = {0};
-static taos_qset  tsSdbWQset;
-static taos_qall  tsSdbWQall;
-static taos_queue tsSdbWQueue;
-static SSdbWorkerPool tsSdbPool;
-
-static int32_t sdbProcessWrite(void *pRow, void *pHead, int32_t qtype, void *unused);
-static int32_t sdbWriteFwdToQueue(int32_t vgId, void *pHead, int32_t qtype, void *rparam);
-static int32_t sdbWriteRowToQueue(SSdbRow *pRow, int32_t action);
-static void    sdbFreeFromQueue(SSdbRow *pRow);
-static void *  sdbWorkerFp(void *pWorker);
-static int32_t sdbInitWorker();
-static void    sdbCleanupWorker();
-static int32_t sdbAllocQueue();
-static void    sdbFreeQueue();
-static int32_t sdbInsertHash(SSdbTable *pTable, SSdbRow *pRow);
-static int32_t sdbUpdateHash(SSdbTable *pTable, SSdbRow *pRow);
-static int32_t sdbDeleteHash(SSdbTable *pTable, SSdbRow *pRow);
-static void    sdbCloseTableObj(void *handle);
-
-int32_t sdbGetId(void *pTable) {
-  return ((SSdbTable *)pTable)->autoIndex;
-}
-
-int64_t sdbGetNumOfRows(void *pTable) {
-  return ((SSdbTable *)pTable)->numOfRows;
-}
-
-uint64_t sdbGetVersion() {
-  return tsSdbMgmt.version;
-}
-
-bool sdbIsMaster() { 
-  return tsSdbMgmt.role == TAOS_SYNC_ROLE_MASTER; 
-}
-
-bool sdbIsServing() {
-  return tsSdbMgmt.status == SDB_STATUS_SERVING; 
-}
-
-static void *sdbGetObjKey(SSdbTable *pTable, void *key) {
-  if (pTable->keyType == SDB_KEY_VAR_STRING) {
-    return *(char **)key;
-  }
-
-  return key;
-}
-
-static char *sdbGetKeyStr(SSdbTable *pTable, void *key) {
-  static char str[16];
-  switch (pTable->keyType) {
-    case SDB_KEY_STRING:
-    case SDB_KEY_VAR_STRING:
-      return (char *)key;
-    case SDB_KEY_INT:
-    case SDB_KEY_AUTO:
-      sprintf(str, "%d", *(int32_t *)key);
-      return str;
-    default:
-      return "invalid";
-  }
-}
-
-static char *sdbGetRowStr(SSdbTable *pTable, void *key) {
-  return sdbGetKeyStr(pTable, sdbGetObjKey(pTable, key));
-}
-
-static void *sdbGetTableFromId(int32_t tableId) {
-  return tsSdbMgmt.tableList[tableId];
-}
-
-static int32_t sdbInitWal() {
-  SWalCfg walCfg = {.vgId = 1, .walLevel = TAOS_WAL_FSYNC, .keep = TAOS_WAL_KEEP, .fsyncPeriod = 0};
-  char    temp[TSDB_FILENAME_LEN] = {0};
-  sprintf(temp, "%s/wal", tsMnodeDir);
-  tsSdbMgmt.wal = walOpen(temp, &walCfg);
-  if (tsSdbMgmt.wal == NULL) {
-    sdbError("vgId:1, failed to open wal in %s", tsMnodeDir);
-    return -1;
-  }
-
-  sdbInfo("vgId:1, open sdb wal for restore");
-  int32_t code = walRestore(tsSdbMgmt.wal, NULL, sdbProcessWrite);
-  if (code != TSDB_CODE_SUCCESS) {
-    sdbError("vgId:1, failed to open wal for restore since %s", tstrerror(code));
-    return -1;
-  }
-
-  sdbInfo("vgId:1, sdb wal load success");
-  return 0;
-}
-
-static void sdbRestoreTables() {
-  int32_t totalRows = 0;
-  int32_t numOfTables = 0;
-
-  sdbInfo("vgId:1, sdb start to check for integrity");
-
-  for (int32_t tableId = 0; tableId < SDB_TABLE_MAX; ++tableId) {
-    SSdbTable *pTable = sdbGetTableFromId(tableId);
-    if (pTable == NULL) continue;
-    if (pTable->fpRestored) {
-      (*pTable->fpRestored)();
-    }
-
-    totalRows += (int32_t)pTable->numOfRows;
-    numOfTables++;
-    sdbInfo("vgId:1, sdb:%s is checked, rows:%" PRId64, pTable->name, pTable->numOfRows);
-  }
-
-  sdbInfo("vgId:1, sdb is restored, mver:%" PRIu64 " rows:%d tables:%d", tsSdbMgmt.version, totalRows, numOfTables);
-}
-
-void sdbUpdateMnodeRoles() {
-  if (tsSdbMgmt.sync <= 0) return;
-
-  SNodesRole roles = {0};
-  if (syncGetNodesRole(tsSdbMgmt.sync, &roles) != 0) return;
-
-  sdbInfo("vgId:1, update mnodes role, replica:%d", tsSdbMgmt.cfg.replica);
-  for (int32_t i = 0; i < tsSdbMgmt.cfg.replica; ++i) {
-    SMnodeObj *pMnode = mnodeGetMnode(roles.nodeId[i]);
-    if (pMnode != NULL) {
-      if (pMnode->role != roles.role[i]) {
-        pMnode->roleTime = taosGetTimestampMs();
-        bnNotify();
-      }
-
-      pMnode->role = roles.role[i];
-      sdbInfo("vgId:1, mnode:%d, role:%s", pMnode->mnodeId, syncRole[pMnode->role]);
-      if (pMnode->mnodeId == dnodeGetDnodeId()) tsSdbMgmt.role = pMnode->role;
-      mnodeDecMnodeRef(pMnode);
-    } else {
-      sdbDebug("vgId:1, mnode:%d not found", roles.nodeId[i]);
-    }
-  }
-
-  mnodeUpdateClusterId();
-  mnodeUpdateMnodeEpSet(NULL);
-}
-
-static int32_t sdbGetWalInfo(int32_t vgId, char *fileName, int64_t *fileId) {
-  return walGetWalFile(tsSdbMgmt.wal, fileName, fileId);
-}
-
-static void sdbNotifyRole(int32_t vgId, int8_t role) {
-  sdbInfo("vgId:1, mnode role changed from %s to %s", syncRole[tsSdbMgmt.role], syncRole[role]);
-
-  if (role == TAOS_SYNC_ROLE_MASTER && tsSdbMgmt.role != TAOS_SYNC_ROLE_MASTER) {
-    bnReset();
-  }
-  tsSdbMgmt.role = role;
-
-  sdbUpdateMnodeRoles();
-}
-
-static void sdbStartFileSync(int32_t vgId) {}
-
-static void sdbStopFileSync(int32_t vgId, uint64_t fversion) {}
-
-static void sdbNotifyFlowCtrl(int32_t vgId, int32_t level) {}
-
-static int32_t sdbGetSyncVersion(int32_t vgId, uint64_t *fver, uint64_t *vver) {
-  *fver = 0;
-  *vver = 0;
-  return 0;
-}
-
-// failed to forward, need revert insert
-static void sdbHandleFailedConfirm(SSdbRow *pRow) {
-  SWalHead *pHead = &pRow->pHead;
-  int32_t   action = pHead->msgType % 10;
-
-  sdbError("vgId:1, row:%p:%s hver:%" PRIu64 " action:%s, failed to foward since %s", pRow->pObj,
-           sdbGetKeyStr(pRow->pTable, pHead->cont), pHead->version, actStr[action], tstrerror(pRow->code));
-
-  // It's better to create a table in two stages, create it first and then set it success
-  if (action == SDB_ACTION_INSERT) {
-    SSdbRow row = {.type = SDB_OPER_GLOBAL, .pTable = pRow->pTable, .pObj = pRow->pObj};
-    sdbDeleteRow(&row);
-  }
-}
-
-FORCE_INLINE
-static void sdbConfirmForward(int32_t vgId, void *wparam, int32_t code) {
-  if (wparam == NULL) return;
-  SSdbRow *pRow = wparam;
-  SMnodeMsg * pMsg = pRow->pMsg;
-
-  if (code <= 0) pRow->code = code;
-  int32_t count = atomic_add_fetch_32(&pRow->processedCount, 1);
-  if (count <= 1) {
-    if (pMsg != NULL) sdbTrace("vgId:1, msg:%p waiting for confirm, count:%d code:%x", pMsg, count, code);
-    return;
-  } else {
-    if (pMsg != NULL) sdbTrace("vgId:1, msg:%p is confirmed, code:%x", pMsg, code);
-  }
-
-  if (pRow->code != TSDB_CODE_SUCCESS) sdbHandleFailedConfirm(pRow);
-
-  if (pRow->fpRsp != NULL) {
-    pRow->code = (*pRow->fpRsp)(pMsg, pRow->code);
-  }
-
-  dnodeSendRpcMWriteRsp(pMsg, pRow->code);
-  sdbFreeFromQueue(pRow);
-}
-
-static void sdbUpdateSyncTmrFp(void *param, void *tmrId) { sdbUpdateSync(NULL); }
-
-void sdbUpdateAsync() {
-  taosTmrReset(sdbUpdateSyncTmrFp, 200, NULL, tsMnodeTmr, &tsSdbTmr);
-}
-
-static int node_cmp(const void *l, const void *r) {
-  return ((SNodeInfo *)l)->nodeId - ((SNodeInfo *)r)->nodeId;
-}
-
-int32_t sdbUpdateSync(void *pMnodes) {
-  SMInfos *pMinfos = pMnodes;
-  if (!mnodeIsRunning()) {
-    mDebug("vgId:1, mnode not start yet, update sync config later");
-    return TSDB_CODE_MND_MNODE_IS_RUNNING;
-  }
-
-  mDebug("vgId:1, update sync config, pMnodes:%p", pMnodes);
-
-  SSyncCfg syncCfg = {0};
-  int32_t  index = 0;
-
-  if (pMinfos == NULL) {
-    mDebug("vgId:1, mInfos not input, use mInfos in sdb, numOfMnodes:%d", syncCfg.replica);
-
-    void *pIter = NULL;
-    while (1) {
-      SMnodeObj *pMnode = NULL;
-      pIter = mnodeGetNextMnode(pIter, &pMnode);
-      if (pMnode == NULL) break;
-
-      syncCfg.nodeInfo[index].nodeId = pMnode->mnodeId;
-
-      SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
-      if (pDnode != NULL) {
-        syncCfg.nodeInfo[index].nodePort = pDnode->dnodePort + TSDB_PORT_SYNC;
-        tstrncpy(syncCfg.nodeInfo[index].nodeFqdn, pDnode->dnodeFqdn, TSDB_FQDN_LEN);
-        index++;
-      }
-
-      mnodeDecDnodeRef(pDnode);
-      mnodeDecMnodeRef(pMnode);
-    }
-    syncCfg.replica = index;
-  } else {
-    mDebug("vgId:1, mInfos input, numOfMnodes:%d", pMinfos->mnodeNum);
-
-    for (index = 0; index < pMinfos->mnodeNum; ++index) {
-      SMInfo *node = &pMinfos->mnodeInfos[index];
-      syncCfg.nodeInfo[index].nodeId = node->mnodeId;
-      taosGetFqdnPortFromEp(node->mnodeEp, syncCfg.nodeInfo[index].nodeFqdn, &syncCfg.nodeInfo[index].nodePort);
-      syncCfg.nodeInfo[index].nodePort += TSDB_PORT_SYNC;
-    }
-    syncCfg.replica = index;
-    mnodeUpdateMnodeEpSet(pMnodes);
-  }
-
-  syncCfg.quorum = (syncCfg.replica == 1) ? 1 : 2;
-
-  bool hasThisDnode = false;
-  for (int32_t i = 0; i < syncCfg.replica; ++i) {
-    if (syncCfg.nodeInfo[i].nodeId == dnodeGetDnodeId()) {
-      hasThisDnode = true;
-      break;
-    }
-  }
-
-  if (!hasThisDnode) {
-    sdbDebug("vgId:1, update sync config, this dnode not exist");
-    return TSDB_CODE_MND_FAILED_TO_CONFIG_SYNC;
-  }
-
-  if (memcmp(&syncCfg, &tsSdbMgmt.cfg, sizeof(SSyncCfg)) == 0) {
-    sdbDebug("vgId:1, update sync config, info not changed");
-    return TSDB_CODE_SUCCESS;
-  }
-
-  qsort(syncCfg.nodeInfo, syncCfg.replica, sizeof(syncCfg.nodeInfo[0]), node_cmp);
-
-  sdbInfo("vgId:1, work as mnode, replica:%d", syncCfg.replica);
-  for (int32_t i = 0; i < syncCfg.replica; ++i) {
-    sdbInfo("vgId:1, mnode:%d, %s:%d", syncCfg.nodeInfo[i].nodeId, syncCfg.nodeInfo[i].nodeFqdn,
-            syncCfg.nodeInfo[i].nodePort);
-  }
-
-  SSyncInfo syncInfo = {0};
-  syncInfo.vgId = 1;
-  syncInfo.version = sdbGetVersion();
-  syncInfo.syncCfg = syncCfg;
-  sprintf(syncInfo.path, "%s", tsMnodeDir);
-  syncInfo.getWalInfoFp = sdbGetWalInfo;
-  syncInfo.writeToCacheFp = sdbWriteFwdToQueue;
-  syncInfo.confirmForward = sdbConfirmForward;
-  syncInfo.notifyRoleFp = sdbNotifyRole;
-  syncInfo.startSyncFileFp = sdbStartFileSync;
-  syncInfo.stopSyncFileFp = sdbStopFileSync;
-  syncInfo.notifyFlowCtrlFp = sdbNotifyFlowCtrl;
-  syncInfo.getVersionFp = sdbGetSyncVersion;
-  tsSdbMgmt.cfg = syncCfg;
-
-  if (tsSdbMgmt.sync) {
-    int32_t code = syncReconfig(tsSdbMgmt.sync, &syncCfg);
-    if (code != 0) return code;
-  } else {
-    tsSdbMgmt.sync = syncStart(&syncInfo);
-    if (tsSdbMgmt.sync <= 0) return TSDB_CODE_MND_FAILED_TO_START_SYNC;
-  }
-
-  sdbUpdateMnodeRoles();
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t sdbInitRef() {
-  tsSdbRid = taosOpenRef(10, sdbCloseTableObj);
-  if (tsSdbRid <= 0) {
-    sdbError("failed to init sdb ref");
-    return -1;
-  }
-  return 0;
-}
-
-void sdbCleanUpRef() { taosCloseRef(tsSdbRid); }
-
-int32_t sdbInit() {
-  pthread_mutex_init(&tsSdbMgmt.mutex, NULL);
-
-  if (sdbInitWorker() != 0) {
-    return -1;
-  }
-
-  if (sdbInitWal() != 0) {
-    return -1;
-  }
-
-  sdbRestoreTables();
-
-  if (mnodeGetMnodesNum() == 1) {
-    tsSdbMgmt.role = TAOS_SYNC_ROLE_MASTER;
-  }
-
-  tsSdbMgmt.status = SDB_STATUS_SERVING;
-
-  if (tsCompactMnodeWal) {
-    mnodeCompactWal();
-    exit(EXIT_SUCCESS);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-void sdbCleanUp() {
-  if (tsSdbMgmt.status != SDB_STATUS_SERVING) return;
-
-  tsSdbMgmt.status = SDB_STATUS_CLOSING;
-
-  sdbCleanupWorker();
-  sdbDebug("vgId:1, sdb will be closed, mver:%" PRIu64, tsSdbMgmt.version);
-
-  if (tsSdbMgmt.sync) {
-    syncStop(tsSdbMgmt.sync);
-    tsSdbMgmt.sync = -1;
-  }
-
-  if (tsSdbMgmt.wal) {
-    walClose(tsSdbMgmt.wal);
-    tsSdbMgmt.wal = NULL;
-  }
-
-  pthread_mutex_destroy(&tsSdbMgmt.mutex);
-}
-
-void sdbIncRef(void *tparam, void *pRow) {
-  if (pRow == NULL || tparam == NULL) return;
-
-  SSdbTable *pTable = tparam;
-  int32_t *  pRefCount = (int32_t *)((char *)pRow + pTable->refCountPos);
-  int32_t    refCount = atomic_add_fetch_32(pRefCount, 1);
-  sdbTrace("vgId:1, sdb:%s, inc ref to row:%p:%s:%d", pTable->name, pRow, sdbGetRowStr(pTable, pRow), refCount);
-}
-
-void sdbDecRef(void *tparam, void *pRow) {
-  if (pRow == NULL || tparam == NULL) return;
-
-  SSdbTable *pTable = tparam;
-  int32_t *  pRefCount = (int32_t *)((char *)pRow + pTable->refCountPos);
-  int32_t    refCount = atomic_sub_fetch_32(pRefCount, 1);
-  sdbTrace("vgId:1, sdb:%s, dec ref to row:%p:%s:%d", pTable->name, pRow, sdbGetRowStr(pTable, pRow), refCount);
-
-  int32_t *updateEnd = (int32_t *)((char *)pRow + pTable->refCountPos - 4);
-  if (refCount <= 0 && *updateEnd) {
-    sdbTrace("vgId:1, sdb:%s, row:%p:%s:%d destroyed", pTable->name, pRow, sdbGetRowStr(pTable, pRow), refCount);
-    SSdbRow row = {.pObj = pRow};
-    (*pTable->fpDestroy)(&row);
-  }
-}
-
-static void *sdbGetRowMeta(SSdbTable *pTable, void *key) {
-  if (pTable == NULL) return NULL;
-
-  int32_t keySize = sizeof(int32_t);
-  if (pTable->keyType == SDB_KEY_STRING || pTable->keyType == SDB_KEY_VAR_STRING) {
-    keySize = (int32_t)strlen((char *)key);
-  }
-
-  void **ppRow = (void **)taosHashGet(pTable->iHandle, key, keySize);
-  if (ppRow != NULL) return *ppRow;
-
-  return NULL;
-}
-
-static void *sdbGetRowMetaFromObj(SSdbTable *pTable, void *key) {
-  return sdbGetRowMeta(pTable, sdbGetObjKey(pTable, key));
-}
-
-void *sdbGetRow(void *tparam, void *key) {
-  SSdbTable *pTable = tparam;
-
-  pthread_mutex_lock(&pTable->mutex);
-  void *pRow = sdbGetRowMeta(pTable, key);
-  if (pRow) sdbIncRef(pTable, pRow);
-  pthread_mutex_unlock(&pTable->mutex);
-
-  return pRow;
-}
-
-static void *sdbGetRowFromObj(SSdbTable *pTable, void *key) {
-  return sdbGetRow(pTable, sdbGetObjKey(pTable, key));
-}
-
-static int32_t sdbInsertHash(SSdbTable *pTable, SSdbRow *pRow) {
-  void *  key = sdbGetObjKey(pTable, pRow->pObj);
-  int32_t keySize = sizeof(int32_t);
-
-  if (pTable->keyType == SDB_KEY_STRING || pTable->keyType == SDB_KEY_VAR_STRING) {
-    keySize =  (int32_t)strlen((char *)key);
-  }
-
-  pthread_mutex_lock(&pTable->mutex);
-  taosHashPut(pTable->iHandle, key, keySize, &pRow->pObj, sizeof(int64_t));
-  pthread_mutex_unlock(&pTable->mutex);
-
-  sdbIncRef(pTable, pRow->pObj);
-  atomic_add_fetch_32(&pTable->numOfRows, 1);
-
-  if (pTable->keyType == SDB_KEY_AUTO) {
-    pTable->autoIndex = MAX(pTable->autoIndex, *((uint32_t *)pRow->pObj));
-  } else {
-    atomic_add_fetch_32(&pTable->autoIndex, 1);
-  }
-
-  sdbTrace("vgId:1, sdb:%s, insert key:%s to hash, rowSize:%d rows:%" PRId64 ", msg:%p", pTable->name,
-           sdbGetRowStr(pTable, pRow->pObj), pRow->rowSize, pTable->numOfRows, pRow->pMsg);
-
-  int32_t code = (*pTable->fpInsert)(pRow);
-  if (code != TSDB_CODE_SUCCESS) {
-    sdbError("vgId:1, sdb:%s, failed to perform insert action for key:%s, remove it", pTable->name,
-             sdbGetRowStr(pTable, pRow->pObj));
-    sdbDeleteHash(pTable, pRow);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t sdbDeleteHash(SSdbTable *pTable, SSdbRow *pRow) {
-  int32_t *updateEnd = (int32_t *)((char*)pRow->pObj + pTable->refCountPos - 4);
-  bool set = atomic_val_compare_exchange_32(updateEnd, 0, 1) == 0;
-  if (!set) {
-    sdbError("vgId:1, sdb:%s, failed to delete key:%s from hash, for it already removed", pTable->name,
-             sdbGetRowStr(pTable, pRow->pObj));
-    return TSDB_CODE_MND_SDB_OBJ_NOT_THERE;
-  }
-
-  (*pTable->fpDelete)(pRow);
-  
-  void *  key = sdbGetObjKey(pTable, pRow->pObj);
-  int32_t keySize = sizeof(int32_t);
-  if (pTable->keyType == SDB_KEY_STRING || pTable->keyType == SDB_KEY_VAR_STRING) {
-    keySize = (int32_t)strlen((char *)key);
-  }
-
-  pthread_mutex_lock(&pTable->mutex);
-  taosHashRemove(pTable->iHandle, key, keySize);
-  pthread_mutex_unlock(&pTable->mutex);
-
-  atomic_sub_fetch_32(&pTable->numOfRows, 1);
-
-  sdbTrace("vgId:1, sdb:%s, delete key:%s from hash, numOfRows:%" PRId64 ", msg:%p", pTable->name,
-           sdbGetRowStr(pTable, pRow->pObj), pTable->numOfRows, pRow->pMsg);
-
-  sdbDecRef(pTable, pRow->pObj);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t sdbUpdateHash(SSdbTable *pTable, SSdbRow *pRow) {
-  sdbTrace("vgId:1, sdb:%s, update key:%s in hash, numOfRows:%" PRId64 ", msg:%p", pTable->name,
-           sdbGetRowStr(pTable, pRow->pObj), pTable->numOfRows, pRow->pMsg);
-
-  (*pTable->fpUpdate)(pRow);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t sdbPerformInsertAction(SWalHead *pHead, SSdbTable *pTable) {
-  SSdbRow row = {.rowSize = pHead->len, .rowData = pHead->cont, .pTable = pTable};
-  (*pTable->fpDecode)(&row);
-  return sdbInsertHash(pTable, &row);
-}
-
-static int32_t sdbPerformDeleteAction(SWalHead *pHead, SSdbTable *pTable) {
-  void *pObj = sdbGetRowMeta(pTable, pHead->cont);
-  if (pObj == NULL) {
-    sdbDebug("vgId:1, sdb:%s, object:%s not exist in hash, ignore delete action", pTable->name,
-             sdbGetKeyStr(pTable, pHead->cont));
-    return TSDB_CODE_SUCCESS;
-  }
-  SSdbRow row = {.pTable = pTable, .pObj = pObj};
-  return sdbDeleteHash(pTable, &row);
-}
-
-static int32_t sdbPerformUpdateAction(SWalHead *pHead, SSdbTable *pTable) {
-  void *pObj = sdbGetRowMeta(pTable, pHead->cont);
-  if (pObj == NULL) {
-    sdbDebug("vgId:1, sdb:%s, object:%s not exist in hash, ignore update action", pTable->name,
-             sdbGetKeyStr(pTable, pHead->cont));
-    return TSDB_CODE_SUCCESS;
-  }
-  SSdbRow row = {.rowSize = pHead->len, .rowData = pHead->cont, .pTable = pTable};
-  (*pTable->fpDecode)(&row);
-  return sdbUpdateHash(pTable, &row);
-}
-
-static int32_t sdbProcessWrite(void *wparam, void *hparam, int32_t qtype, void *unused) {
-  SSdbRow *pRow = wparam;
-  SWalHead *pHead = hparam;
-  int32_t tableId = pHead->msgType / 10;
-  int32_t action = pHead->msgType % 10;
-
-  SSdbTable *pTable = sdbGetTableFromId(tableId);
-  assert(pTable != NULL);
-
-  if (!mnodeIsRunning() && tsSdbMgmt.version % 100000 == 0) {
-    char stepDesc[TSDB_STEP_DESC_LEN] = {0};
-    snprintf(stepDesc, TSDB_STEP_DESC_LEN, "%" PRIu64 " rows have been restored", tsSdbMgmt.version);
-    dnodeReportStep("mnode-sdb", stepDesc, 0);
-  }
-
-  pthread_mutex_lock(&tsSdbMgmt.mutex);
-  
-  if (pHead->version == 0) {
-    // assign version
-    tsSdbMgmt.version++;
-    pHead->version = tsSdbMgmt.version;
-  } else {
-    // for data from WAL or forward, version may be smaller
-    if (pHead->version <= tsSdbMgmt.version) {
-      pthread_mutex_unlock(&tsSdbMgmt.mutex);
-      sdbDebug("vgId:1, sdb:%s, failed to restore %s key:%s from source(%d), hver:%" PRIu64 " too large, mver:%" PRIu64,
-               pTable->name, actStr[action], sdbGetKeyStr(pTable, pHead->cont), qtype, pHead->version, tsSdbMgmt.version);
-      return TSDB_CODE_SUCCESS;
-    } else if (pHead->version != tsSdbMgmt.version + 1) {
-      if (qtype != TAOS_QTYPE_WAL) {
-        pthread_mutex_unlock(&tsSdbMgmt.mutex);
-        sdbError(
-            "vgId:1, sdb:%s, failed to restore %s key:%s from source(%d), hver:%" PRIu64 " too large, mver:%" PRIu64,
-            pTable->name, actStr[action], sdbGetKeyStr(pTable, pHead->cont), qtype, pHead->version, tsSdbMgmt.version);
-        return TSDB_CODE_SYN_INVALID_VERSION;
-      } else {
-        // If cksum is wrong when recovering wal, use this code
-        tsSdbMgmt.version = pHead->version;
-      }
-
-    } else {
-      tsSdbMgmt.version = pHead->version;
-    }
-  }
-
-  int32_t code = walWrite(tsSdbMgmt.wal, pHead);
-  if (code < 0) {
-    pthread_mutex_unlock(&tsSdbMgmt.mutex);
-    return code;
-  }
-
-  pthread_mutex_unlock(&tsSdbMgmt.mutex);
-
-  // from app, row is created
-  if (pRow != NULL && tsCompactMnodeWal != 1) {
-    // forward to peers
-    pRow->processedCount = 0;
-    int32_t syncCode = syncForwardToPeer(tsSdbMgmt.sync, pHead, pRow, TAOS_QTYPE_RPC, false);
-    if (syncCode <= 0) pRow->processedCount = 1;
-
-    if (syncCode < 0) {
-      sdbError("vgId:1, sdb:%s, failed to forward req since %s action:%s key:%s hver:%" PRIu64 ", msg:%p", pTable->name,
-               tstrerror(syncCode), actStr[action], sdbGetKeyStr(pTable, pHead->cont), pHead->version, pRow->pMsg);
-    } else if (syncCode > 0) {
-      sdbDebug("vgId:1, sdb:%s, forward req is sent, action:%s key:%s hver:%" PRIu64 ", msg:%p", pTable->name,
-               actStr[action], sdbGetKeyStr(pTable, pHead->cont), pHead->version, pRow->pMsg);
-    } else {
-      sdbTrace("vgId:1, sdb:%s, no need to send fwd req, action:%s key:%s hver:%" PRIu64 ", msg:%p", pTable->name,
-               actStr[action], sdbGetKeyStr(pTable, pHead->cont), pHead->version, pRow->pMsg);
-    }
-    return syncCode;
-  }
-
-  sdbTrace("vgId:1, sdb:%s, record from %s is disposed, action:%s key:%s hver:%" PRIu64, pTable->name, qtypeStr[qtype],
-           actStr[action], sdbGetKeyStr(pTable, pHead->cont), pHead->version);
-
-  // even it is WAL/FWD, it shall be called to update version in sync
-  if (tsCompactMnodeWal != 1) {
-    syncForwardToPeer(tsSdbMgmt.sync, pHead, pRow, TAOS_QTYPE_RPC, false);
-  }
-
-  // from wal or forward msg, row not created, should add into hash
-  if (action == SDB_ACTION_INSERT) {
-    return sdbPerformInsertAction(pHead, pTable);
-  } else if (action == SDB_ACTION_DELETE) {
-    if (qtype == TAOS_QTYPE_FWD) {
-      // Drop database/stable may take a long time and cause a timeout, so we confirm first
-      syncConfirmForward(tsSdbMgmt.sync, pHead->version, TSDB_CODE_SUCCESS, false);
-    }
-    return sdbPerformDeleteAction(pHead, pTable);
-  } else if (action == SDB_ACTION_UPDATE) {
-    return sdbPerformUpdateAction(pHead, pTable);
-  } else {
-    return TSDB_CODE_MND_INVALID_MSG_TYPE;
-  }
-}
-
-int32_t sdbInsertCompactRow(SSdbRow *pRow) {
-  SSdbTable *pTable = pRow->pTable;
-  if (pTable == NULL) return TSDB_CODE_MND_SDB_INVALID_TABLE_TYPE;
-  return sdbWriteRowToQueue(pRow, SDB_ACTION_INSERT);
-}
-
-int32_t sdbInsertRow(SSdbRow *pRow) {
-  SSdbTable *pTable = pRow->pTable;
-  if (pTable == NULL) return TSDB_CODE_MND_SDB_INVALID_TABLE_TYPE;
-
-  if (sdbGetRowFromObj(pTable, pRow->pObj)) {
-    sdbError("vgId:1, sdb:%s, failed to insert:%s since it exist", pTable->name, sdbGetRowStr(pTable, pRow->pObj));
-    sdbDecRef(pTable, pRow->pObj);
-    return TSDB_CODE_MND_SDB_OBJ_ALREADY_THERE;
-  }
-
-  if (pTable->keyType == SDB_KEY_AUTO) {
-    *((uint32_t *)pRow->pObj) = atomic_add_fetch_32(&pTable->autoIndex, 1);
-
-    // let vgId increase from 2
-    if (pTable->autoIndex == 1 && pTable->id == SDB_TABLE_VGROUP) {
-      *((uint32_t *)pRow->pObj) = atomic_add_fetch_32(&pTable->autoIndex, 1);
-    }
-  }
-
-  int32_t code = sdbInsertHash(pTable, pRow);
-  if (code != TSDB_CODE_SUCCESS) {
-    sdbError("vgId:1, sdb:%s, failed to insert:%s into hash", pTable->name, sdbGetRowStr(pTable, pRow->pObj));
-    return code;
-  }
-
-  // just insert data into memory
-  if (pRow->type != SDB_OPER_GLOBAL) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (pRow->fpReq) {
-    return (*pRow->fpReq)(pRow->pMsg);
-  } else {
-    return sdbWriteRowToQueue(pRow, SDB_ACTION_INSERT);
-  }
-}
-
-bool sdbCheckRowDeleted(void *tparam, void *pRow) {
-  SSdbTable *pTable = tparam;
-  if (pTable == NULL) return false;
-
-  int32_t *updateEnd =  (int32_t *)((char*)pRow + pTable->refCountPos - 4);
-  return atomic_val_compare_exchange_32(updateEnd, 1, 1) == 1;
-}
-
-int32_t sdbDeleteRow(SSdbRow *pRow) {
-  SSdbTable *pTable = pRow->pTable;
-  if (pTable == NULL) return TSDB_CODE_MND_SDB_INVALID_TABLE_TYPE;
-
-  void *pObj = sdbGetRowMetaFromObj(pTable, pRow->pObj);
-  if (pObj == NULL) {
-    sdbDebug("vgId:1, sdb:%s, record is not there, delete failed", pTable->name);
-    return TSDB_CODE_MND_SDB_OBJ_NOT_THERE;
-  }
-
-  int32_t code = sdbDeleteHash(pTable, pRow);
-  if (code != TSDB_CODE_SUCCESS) {
-    sdbError("vgId:1, sdb:%s, failed to delete from hash", pTable->name);
-    return code;
-  }
-
-  // just delete data from memory
-  if (pRow->type != SDB_OPER_GLOBAL) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (pRow->fpReq) {
-    return (*pRow->fpReq)(pRow->pMsg);
-  } else {
-    return sdbWriteRowToQueue(pRow, SDB_ACTION_DELETE);
-  }
-}
-
-int32_t sdbUpdateRow(SSdbRow *pRow) {
-  SSdbTable *pTable = pRow->pTable;
-  if (pTable == NULL) return TSDB_CODE_MND_SDB_INVALID_TABLE_TYPE;
-
-  void *pObj = sdbGetRowMetaFromObj(pTable, pRow->pObj);
-  if (pObj == NULL) {
-    sdbDebug("vgId:1, sdb:%s, record is not there, update failed", pTable->name);
-    return TSDB_CODE_MND_SDB_OBJ_NOT_THERE;
-  }
-
-  int32_t code = sdbUpdateHash(pTable, pRow);
-  if (code != TSDB_CODE_SUCCESS) {
-    sdbError("vgId:1, sdb:%s, failed to update hash", pTable->name);
-    return code;
-  }
-
-  // just update data in memory
-  if (pRow->type != SDB_OPER_GLOBAL) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (pRow->fpReq) {
-    return (*pRow->fpReq)(pRow->pMsg);
-  } else {
-    return sdbWriteRowToQueue(pRow, SDB_ACTION_UPDATE);
-  }
-}
-
-void *sdbFetchRow(void *tparam, void *pIter, void **ppRow) {
-  SSdbTable *pTable = tparam;
-  *ppRow = NULL;
-  if (pTable == NULL) return NULL;
-
-  pIter = taosHashIterate(pTable->iHandle, pIter);
-  if (pIter == NULL) return NULL;
-
-  void **ppMetaRow = pIter;
-  if (ppMetaRow == NULL) {
-    taosHashCancelIterate(pTable->iHandle, pIter);
-    return NULL;
-  }
-
-  *ppRow = *ppMetaRow;
-  sdbIncRef(pTable, *ppMetaRow);
-
-  return pIter;
-}
-
-void sdbFreeIter(void *tparam, void *pIter) {
-  SSdbTable *pTable = tparam;
-  if (pTable == NULL || pIter == NULL) return;
-
-  taosHashCancelIterate(pTable->iHandle, pIter);
-}
-
-int64_t sdbOpenTable(SSdbTableDesc *pDesc) {
-  SSdbTable *pTable = (SSdbTable *)calloc(1, sizeof(SSdbTable));
-  
-  if (pTable == NULL) return -1;
-
-  pthread_mutex_init(&pTable->mutex, NULL);
-  tstrncpy(pTable->name, pDesc->name, SDB_TABLE_LEN);
-  pTable->keyType      = pDesc->keyType;
-  pTable->id           = pDesc->id;
-  pTable->hashSessions = pDesc->hashSessions;
-  pTable->maxRowSize   = pDesc->maxRowSize;
-  pTable->refCountPos  = pDesc->refCountPos;
-  pTable->fpInsert     = pDesc->fpInsert;
-  pTable->fpDelete     = pDesc->fpDelete;
-  pTable->fpUpdate     = pDesc->fpUpdate;
-  pTable->fpEncode     = pDesc->fpEncode;
-  pTable->fpDecode     = pDesc->fpDecode;
-  pTable->fpDestroy    = pDesc->fpDestroy;
-  pTable->fpRestored   = pDesc->fpRestored;
-
-  _hash_fn_t hashFp = taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT);
-  if (pTable->keyType == SDB_KEY_STRING || pTable->keyType == SDB_KEY_VAR_STRING) {
-    hashFp = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
-  }
-  pTable->iHandle = taosHashInit(pTable->hashSessions, hashFp, true, HASH_ENTRY_LOCK);
-
-  tsSdbMgmt.numOfTables++;
-  tsSdbMgmt.tableList[pTable->id] = pTable;
-
-  return taosAddRef(tsSdbRid, pTable);
-}
-
-void sdbCloseTable(int64_t rid) {
-  taosRemoveRef(tsSdbRid, rid);
-}
-
-void *sdbGetTableByRid(int64_t rid) {
-  void *handle = taosAcquireRef(tsSdbRid, rid);
-  taosReleaseRef(tsSdbRid, rid);
-  return handle;
-}
-
-static void sdbCloseTableObj(void *handle) {
-  SSdbTable *pTable = (SSdbTable *)handle;
-  if (pTable == NULL) return;
-  
-  tsSdbMgmt.numOfTables--;
-  tsSdbMgmt.tableList[pTable->id] = NULL;
-
-  void *pIter = taosHashIterate(pTable->iHandle, NULL);
-  while (pIter) {
-    void **ppRow = pIter;
-    pIter = taosHashIterate(pTable->iHandle, pIter);
-    if (ppRow == NULL) continue;
-
-    SSdbRow row = {
-      .pObj = *ppRow,
-      .pTable = pTable,
-    };
-
-    (*pTable->fpDestroy)(&row);
-  }
-
-  taosHashCancelIterate(pTable->iHandle, pIter);
-  taosHashCleanup(pTable->iHandle);
-  pTable->iHandle = NULL;
-  pthread_mutex_destroy(&pTable->mutex);
-
-  sdbDebug("vgId:1, sdb:%s, is closed, numOfTables:%d", pTable->name, tsSdbMgmt.numOfTables);
-  free(pTable);
-}
-
-static int32_t sdbInitWorker() {
-  tsSdbPool.num = 1;
-  tsSdbPool.worker = calloc(sizeof(SSdbWorker), tsSdbPool.num);
-
-  if (tsSdbPool.worker == NULL) return -1;
-  for (int32_t i = 0; i < tsSdbPool.num; ++i) {
-    SSdbWorker *pWorker = tsSdbPool.worker + i;
-    pWorker->workerId = i;
-  }
-
-  sdbAllocQueue();
-  
-  mInfo("vgId:1, sdb write is opened");
-  return 0;
-}
-
-static void sdbCleanupWorker() {
-  for (int32_t i = 0; i < tsSdbPool.num; ++i) {
-    SSdbWorker *pWorker = tsSdbPool.worker + i;
-    if (taosCheckPthreadValid(pWorker->thread)) {
-      taosQsetThreadResume(tsSdbWQset);
-    }
-  }
-
-  for (int32_t i = 0; i < tsSdbPool.num; ++i) {
-    SSdbWorker *pWorker = tsSdbPool.worker + i;
-    if (taosCheckPthreadValid(pWorker->thread)) {
-      pthread_join(pWorker->thread, NULL);
-    }
-  }
-
-  sdbFreeQueue();
-  tfree(tsSdbPool.worker);
-
-  mInfo("vgId:1, sdb write is closed");
-}
-
-static int32_t sdbAllocQueue() {
-  tsSdbWQueue = taosOpenQueue();
-  if (tsSdbWQueue == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
-  tsSdbWQset = taosOpenQset();
-  if (tsSdbWQset == NULL) {
-    taosCloseQueue(tsSdbWQueue);
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-  taosAddIntoQset(tsSdbWQset, tsSdbWQueue, NULL);
-
-  tsSdbWQall = taosAllocateQall();
-  if (tsSdbWQall == NULL) {
-    taosCloseQset(tsSdbWQset);
-    taosCloseQueue(tsSdbWQueue);
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-  
-  for (int32_t i = 0; i < tsSdbPool.num; ++i) {
-    SSdbWorker *pWorker = tsSdbPool.worker + 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, sdbWorkerFp, pWorker) != 0) {
-      mError("failed to create thread to process sdb write queue, reason:%s", strerror(errno));
-      taosFreeQall(tsSdbWQall);
-      taosCloseQset(tsSdbWQset);
-      taosCloseQueue(tsSdbWQueue);
-      return TSDB_CODE_MND_OUT_OF_MEMORY;
-    }
-
-    pthread_attr_destroy(&thAttr);
-    mDebug("sdb write worker:%d is launched, total:%d", pWorker->workerId, tsSdbPool.num);
-  }
-
-  mDebug("sdb write queue:%p is allocated", tsSdbWQueue);
-  return TSDB_CODE_SUCCESS;
-}
-
-static void sdbFreeQueue() {
-  taosCloseQueue(tsSdbWQueue);
-  taosFreeQall(tsSdbWQall);
-  taosCloseQset(tsSdbWQset);
-  tsSdbWQall = NULL;
-  tsSdbWQset = NULL;
-  tsSdbWQueue = NULL;
-}
-
-static int32_t sdbWriteToQueue(SSdbRow *pRow, int32_t qtype) {
-  SWalHead *pHead = &pRow->pHead;
-
-  if (pHead->len > TSDB_MAX_WAL_SIZE) {
-    sdbError("vgId:1, wal len:%d exceeds limit, hver:%" PRIu64, pHead->len, pHead->version);
-    taosFreeQitem(pRow);
-    return TSDB_CODE_WAL_SIZE_LIMIT;
-  }
-
-  int32_t queued = atomic_add_fetch_32(&tsSdbMgmt.queuedMsg, 1);
-  if (queued > MAX_QUEUED_MSG_NUM) {
-    sdbInfo("vgId:1, too many msg:%d in sdb queue, flow control", queued);
-    taosMsleep(1);
-  }
-
-  sdbIncRef(pRow->pTable, pRow->pObj);
-
-  sdbTrace("vgId:1, msg:%p qtype:%s write into to sdb queue, queued:%d", pRow->pMsg, qtypeStr[qtype], queued);
-  taosWriteQitem(tsSdbWQueue, qtype, pRow);
-
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-static void sdbFreeFromQueue(SSdbRow *pRow) {
-  int32_t queued = atomic_sub_fetch_32(&tsSdbMgmt.queuedMsg, 1);
-  sdbTrace("vgId:1, msg:%p free from sdb queue, queued:%d", pRow->pMsg, queued);
-
-  sdbDecRef(pRow->pTable, pRow->pObj);
-  taosFreeQitem(pRow);
-}
-
-static int32_t sdbWriteFwdToQueue(int32_t vgId, void *wparam, int32_t qtype, void *rparam) {
-  SWalHead *pHead = wparam;
-
-  int32_t  size = sizeof(SSdbRow) + sizeof(SWalHead) + pHead->len;
-  SSdbRow *pRow = taosAllocateQitem(size);
-  if (pRow == NULL) {
-    return TSDB_CODE_VND_OUT_OF_MEMORY;
-  }
-
-  memcpy(&pRow->pHead, pHead, sizeof(SWalHead) + pHead->len);
-  pRow->rowData = pRow->pHead.cont;
-
-  int32_t code = sdbWriteToQueue(pRow, qtype);
-  if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) code = 0;
-
-  return code;
-}
-
-static int32_t sdbWriteRowToQueue(SSdbRow *pInputRow, int32_t action) {
-  SSdbTable *pTable = pInputRow->pTable;
-  if (pTable == NULL) return TSDB_CODE_MND_SDB_INVALID_TABLE_TYPE;
-
-  int32_t  size = sizeof(SSdbRow) + sizeof(SWalHead) + pTable->maxRowSize;
-  SSdbRow *pRow = taosAllocateQitem(size);
-  if (pRow == NULL) {
-    return TSDB_CODE_VND_OUT_OF_MEMORY;
-  }
-
-  memcpy(pRow, pInputRow, sizeof(SSdbRow));
-  pRow->processedCount = 1;
-
-  SWalHead *pHead = &pRow->pHead;
-  pRow->rowData = pHead->cont;
-  (*pTable->fpEncode)(pRow);
-
-  pHead->len = pRow->rowSize;
-  pHead->version = 0;
-  pHead->msgType = pTable->id * 10 + action;
-
-  return sdbWriteToQueue(pRow, TAOS_QTYPE_RPC);
-}
-
-int32_t sdbInsertRowToQueue(SSdbRow *pRow) { return sdbWriteRowToQueue(pRow, SDB_ACTION_INSERT); }
-
-static void *sdbWorkerFp(void *pWorker) {
-  SSdbRow *pRow;
-  int32_t  qtype;
-  void *   unUsed;
-
-  taosBlockSIGPIPE();
-  setThreadName("sdbWorker");
-
-  while (1) {
-    int32_t numOfMsgs = taosReadAllQitemsFromQset(tsSdbWQset, tsSdbWQall, &unUsed);
-    if (numOfMsgs == 0) {
-      sdbDebug("qset:%p, sdb got no message from qset, exiting", tsSdbWQset);
-      break;
-    }
-
-    for (int32_t i = 0; i < numOfMsgs; ++i) {
-      taosGetQitem(tsSdbWQall, &qtype, (void **)&pRow);
-      sdbTrace("vgId:1, msg:%p, row:%p hver:%" PRIu64 ", will be processed in sdb queue", pRow->pMsg, pRow->pObj,
-               pRow->pHead.version);
-
-      pRow->code = sdbProcessWrite((qtype == TAOS_QTYPE_RPC) ? pRow : NULL, &pRow->pHead, qtype, NULL);
-      if (pRow->code > 0) pRow->code = 0;
-
-      sdbTrace("vgId:1, msg:%p is processed in sdb queue, code:%x", pRow->pMsg, pRow->code);
-    }
-
-    walFsync(tsSdbMgmt.wal, true);
-
-    // browse all items, and process them one by one
-    taosResetQitems(tsSdbWQall);
-    for (int32_t i = 0; i < numOfMsgs; ++i) {
-      taosGetQitem(tsSdbWQall, &qtype, (void **)&pRow);
-
-      if (qtype == TAOS_QTYPE_RPC) {
-        sdbConfirmForward(1, pRow, pRow->code);
-      } else {
-        if (qtype == TAOS_QTYPE_FWD) {
-          int32_t action = pRow->pHead.msgType % 10;
-          if (action != SDB_ACTION_DELETE) {
-            syncConfirmForward(tsSdbMgmt.sync, pRow->pHead.version, pRow->code, false);
-          }
-        }
-        sdbFreeFromQueue(pRow);
-      }
-    }
-  }
-
-  return NULL;
-}
-
-int32_t sdbGetReplicaNum() {
-  return tsSdbMgmt.cfg.replica;
-}
-
-int32_t mnodeCompactWal() {
-  sdbInfo("vgId:1, start compact mnode wal...");
-
-  // close old wal
-  walFsync(tsSdbMgmt.wal, true);
-  walClose(tsSdbMgmt.wal);
-
-  // reset version,then compacted wal log can start from version 1
-  tsSdbMgmt.version = 0;
-
-  // change wal to wal_tmp dir
-  SWalCfg walCfg = {.vgId = 1, .walLevel = TAOS_WAL_FSYNC, .keep = TAOS_WAL_KEEP, .fsyncPeriod = 0};
-  char    temp[TSDB_FILENAME_LEN] = {0};
-  sprintf(temp, "%s/wal", tsMnodeTmpDir);
-  tsSdbMgmt.wal = walOpen(temp, &walCfg);
-  walRenew(tsSdbMgmt.wal);
-
-  // compact memory tables info to wal tmp dir
-  if (mnodeCompactComponents() != 0) {
-    tfsRmdir(tsMnodeTmpDir);
-    return -1;
-  }
-
-  // close sdb and sync to disk
-  //walFsync(tsSdbMgmt.wal, true);
-  //walClose(tsSdbMgmt.wal);
-  sdbCleanUp();
-
-  // rename old wal to wal_bak
-  if (taosRename(tsMnodeDir, tsMnodeBakDir) != 0) {
-    return -1;
-  }
-
-  // rename wal_tmp to wal
-  if (taosRename(tsMnodeTmpDir, tsMnodeDir) != 0) {
-    return -1;
-  }
-  
-  // del wal_tmp dir
-  sdbInfo("vgId:1, compact mnode wal success");
-
-  return 0;
-}

src/mnode/src/mnodeShow.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosmsg.h"
-#include "taoserror.h"
-#include "tsched.h"
-#include "tutil.h"
-#include "ttimer.h"
-#include "tgrant.h"
-#include "tglobal.h"
-#include "tcache.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeDb.h"
-#include "mnodeDnode.h"
-#include "mnodeMnode.h"
-#include "mnodeProfile.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeTable.h"
-#include "mnodeUser.h"
-#include "mnodeVgroup.h"
-#include "mnodeWrite.h"
-#include "mnodeRead.h"
-
-static int32_t mnodeProcessShowMsg(SMnodeMsg *mnodeMsg);
-static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *mnodeMsg);
-static int32_t mnodeProcessHeartBeatMsg(SMnodeMsg *mnodeMsg);
-static int32_t mnodeProcessConnectMsg(SMnodeMsg *mnodeMsg);
-static int32_t mnodeProcessUseMsg(SMnodeMsg *mnodeMsg);
-
-static void  mnodeFreeShowObj(void *data);
-static bool  mnodeAccquireShowObj(SShowObj *pShow);
-static bool  mnodeCheckShowFinished(SShowObj *pShow);
-static void *mnodePutShowObj(SShowObj *pShow);
-static void  mnodeReleaseShowObj(SShowObj *pShow, bool forceRemove);
-
-static void *tsMnodeShowCache = NULL;
-static int32_t tsShowObjIndex = 0;
-static SShowMetaFp     tsMnodeShowMetaFp[TSDB_MGMT_TABLE_MAX]     = {0};
-static SShowRetrieveFp tsMnodeShowRetrieveFp[TSDB_MGMT_TABLE_MAX] = {0};
-static SShowFreeIterFp tsMnodeShowFreeIterFp[TSDB_MGMT_TABLE_MAX] = {0};
-
-int32_t mnodeInitShow() {
-  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_SHOW, mnodeProcessShowMsg);
-  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_RETRIEVE, mnodeProcessRetrieveMsg);
-  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_HEARTBEAT, mnodeProcessHeartBeatMsg);
-  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_CONNECT, mnodeProcessConnectMsg);
-  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_USE_DB, mnodeProcessUseMsg);
-  
-  tsMnodeShowCache = taosCacheInit(TSDB_CACHE_PTR_KEY, 5, true, mnodeFreeShowObj, "show");
-  return 0;
-}
-
-void mnodeCleanUpShow() {
-  if (tsMnodeShowCache != NULL) {
-    mInfo("show cache is cleanup");
-    taosCacheCleanup(tsMnodeShowCache);
-    tsMnodeShowCache = NULL;
-  }
-}
-
-void mnodeAddShowMetaHandle(uint8_t showType, SShowMetaFp fp) {
-  tsMnodeShowMetaFp[showType] = fp;
-}
-
-void mnodeAddShowRetrieveHandle(uint8_t msgType, SShowRetrieveFp fp) {
-  tsMnodeShowRetrieveFp[msgType] = fp;
-}
-
-void mnodeAddShowFreeIterHandle(uint8_t msgType, SShowFreeIterFp fp) {
-  tsMnodeShowFreeIterFp[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_VARIABLES: 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";
-    case TSDB_MGMT_TABLE_CLUSTER: return "show clusters";
-    case TSDB_MGMT_TABLE_STREAMTABLES : return "show streamtables";
-    case TSDB_MGMT_TABLE_TP:      return "show topics";
-    default:                      return "undefined";
-  }
-}
-
-static int32_t mnodeProcessShowMsg(SMnodeMsg *pMsg) {
-  SShowMsg *pShowMsg = pMsg->rpcMsg.pCont;
-  if (pShowMsg->type >= TSDB_MGMT_TABLE_MAX) {
-    return TSDB_CODE_MND_INVALID_MSG_TYPE;
-  }
-
-  if (!tsMnodeShowMetaFp[pShowMsg->type] || !tsMnodeShowRetrieveFp[pShowMsg->type]) {
-    mError("show type:%s is not support", mnodeGetShowType(pShowMsg->type));
-    return TSDB_CODE_COM_OPS_NOT_SUPPORT;
-  }
-
-  int32_t showObjSize = sizeof(SShowObj) + htons(pShowMsg->payloadLen);
-  SShowObj *pShow = calloc(1, showObjSize);
-  pShow->type       = pShowMsg->type;
-  pShow->payloadLen = htons(pShowMsg->payloadLen);
-  tstrncpy(pShow->db, pShowMsg->db, TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN);
-  memcpy(pShow->payload, pShowMsg->payload, pShow->payloadLen);
-
-  pShow = mnodePutShowObj(pShow);
-  if (pShow == NULL) {    
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-
-  int32_t size = sizeof(SShowRsp) + sizeof(SSchema) * TSDB_MAX_COLUMNS + TSDB_EXTRA_PAYLOAD_SIZE;
-  SShowRsp *pShowRsp = rpcMallocCont(size);
-  if (pShowRsp == NULL) {
-    mnodeReleaseShowObj(pShow, true);
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-  pShowRsp->qhandle = htobe64((uint64_t) pShow);
-
-  int32_t code = (*tsMnodeShowMetaFp[pShowMsg->type])(&pShowRsp->tableMeta, pShow, pMsg->rpcMsg.handle);
-  mDebug("%p, show type:%s index:%d, get meta finished, numOfRows:%d cols:%d result:%s", pShow,
-         mnodeGetShowType(pShowMsg->type), pShow->index, pShow->numOfRows, pShow->numOfColumns, tstrerror(code));
-
-  if (code == TSDB_CODE_SUCCESS) {
-    pMsg->rpcRsp.rsp = pShowRsp;
-    pMsg->rpcRsp.len = sizeof(SShowRsp) + sizeof(SSchema) * pShow->numOfColumns;
-    mnodeReleaseShowObj(pShow, false);
-    return TSDB_CODE_SUCCESS;
-  } else {
-    rpcFreeCont(pShowRsp);
-    mnodeReleaseShowObj(pShow, true);
-    return code;
-  }
-}
-
-static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) {
-  int32_t rowsToRead = 0;
-  int32_t size = 0;
-  int32_t rowsRead = 0;
-  SRetrieveTableMsg *pRetrieve = pMsg->rpcMsg.pCont;
-  pRetrieve->qhandle = htobe64(pRetrieve->qhandle);
-
-  SShowObj *pShow = (SShowObj *)pRetrieve->qhandle;
-  
-  /*
-   * in case of server restart, apps may hold qhandle created by server before
-   * restart, which is actually invalid, therefore, signature check is required.
-   */
-  if (!mnodeAccquireShowObj(pShow)) {
-    mError("%p, show is invalid", pShow);
-    return TSDB_CODE_MND_INVALID_SHOWOBJ;
-  }
-
-  mDebug("%p, show type:%s index:%d, start retrieve data, numOfReads:%d numOfRows:%d", pShow,
-         mnodeGetShowType(pShow->type), pShow->index, pShow->numOfReads, pShow->numOfRows);
-
-  if (mnodeCheckShowFinished(pShow)) {
-    mDebug("%p, show is already read finished, numOfReads:%d numOfRows:%d", pShow, pShow->numOfReads, pShow->numOfRows);
-    pShow->numOfReads = pShow->numOfRows;
-  }
-  
-  if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) {
-    rowsToRead = pShow->numOfRows - pShow->numOfReads;
-  }
-
-  /* return no more than 100 tables 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);
-
-  mDebug("%p, show type:%s index:%d, stop retrieve data, rowsRead:%d rowsToRead:%d", pShow,
-         mnodeGetShowType(pShow->type), pShow->index, rowsRead, rowsToRead);
-
-  if (rowsRead < 0) {
-    rpcFreeCont(pRsp);
-    mnodeReleaseShowObj(pShow, false);
-    assert(false);
-    return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-  }
-
-  pRsp->numOfRows = htonl(rowsRead);
-  pRsp->precision = (int16_t)htonl(TSDB_TIME_PRECISION_MILLI);  // millisecond time precision
-
-  pMsg->rpcRsp.rsp = pRsp;
-  pMsg->rpcRsp.len = size;
-
-  if (rowsToRead == 0 || (rowsRead == rowsToRead && pShow->numOfRows == pShow->numOfReads)) {
-    pRsp->completed = 1;
-    mDebug("%p, retrieve completed", pShow);
-    mnodeReleaseShowObj(pShow, true);
-  } else {
-    mDebug("%p, retrieve not completed yet", pShow);
-    mnodeReleaseShowObj(pShow, false);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeProcessHeartBeatMsg(SMnodeMsg *pMsg) {
-  SHeartBeatRsp *pRsp = (SHeartBeatRsp *)rpcMallocCont(sizeof(SHeartBeatRsp));
-  if (pRsp == NULL) {
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-
-  SHeartBeatMsg *pHBMsg = pMsg->rpcMsg.pCont;
-  if (taosCheckVersion(pHBMsg->clientVer, version, 3) != TSDB_CODE_SUCCESS) {
-    rpcFreeCont(pRsp);
-    return TSDB_CODE_TSC_INVALID_VERSION;  // todo change the error code
-  }
-
-  SRpcConnInfo connInfo = {0};
-  rpcGetConnInfo(pMsg->rpcMsg.handle, &connInfo);
-    
-  int32_t connId = htonl(pHBMsg->connId);
-  SConnObj *pConn = mnodeAccquireConn(connId, connInfo.user, connInfo.clientIp, connInfo.clientPort);
-  if (pConn == NULL) {
-    pHBMsg->pid = htonl(pHBMsg->pid);
-    pConn = mnodeCreateConn(connInfo.user, connInfo.clientIp, connInfo.clientPort, pHBMsg->pid, pHBMsg->appName);
-  }
-
-  if (pConn == NULL) {
-    // do not close existing links, otherwise
-    // mError("failed to create connId, close connect");
-    // pRsp->killConnection = 1;    
-  } else {
-    pRsp->connId = htonl(pConn->connId);
-    mnodeSaveQueryStreamList(pConn, pHBMsg);
-    
-    if (pConn->killed != 0) {
-      pRsp->killConnection = 1;
-    }
-
-    if (pConn->streamId != 0) {
-      pRsp->streamId = htonl(pConn->streamId);
-      pConn->streamId = 0;
-    }
-
-    if (pConn->queryId != 0) {
-      pRsp->queryId = htonl(pConn->queryId);
-      pConn->queryId = 0;
-    }
-  }
-
-  int32_t    onlineDnodes = 0, totalDnodes = 0;
-  mnodeGetOnlineAndTotalDnodesNum(&onlineDnodes, &totalDnodes);
-
-  pRsp->onlineDnodes = htonl(onlineDnodes);
-  pRsp->totalDnodes = htonl(totalDnodes);
-  mnodeGetMnodeEpSetForShell(&pRsp->epSet, false);
-
-  pMsg->rpcRsp.rsp = pRsp;
-  pMsg->rpcRsp.len = sizeof(SHeartBeatRsp);
-
-  mnodeReleaseConn(pConn);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeProcessConnectMsg(SMnodeMsg *pMsg) {
-  SConnectMsg *pConnectMsg = pMsg->rpcMsg.pCont;
-  SConnectRsp *pConnectRsp = NULL;
-  int32_t code = TSDB_CODE_SUCCESS;
-
-  SRpcConnInfo connInfo = {0};
-  if (rpcGetConnInfo(pMsg->rpcMsg.handle, &connInfo) != 0) {
-    mError("thandle:%p is already released while process connect msg", pMsg->rpcMsg.handle);
-    code = TSDB_CODE_MND_INVALID_CONNECTION;
-    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_FNAME_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_MND_INVALID_DB;
-      goto connect_over;
-    }
-    
-    if (pDb->status != TSDB_DB_STATUS_READY) {
-      mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
-      code = TSDB_CODE_MND_DB_IN_DROPPING;
-      mnodeDecDbRef(pDb);
-      goto connect_over;
-    }
-    mnodeDecDbRef(pDb);
-  }
-
-  pConnectRsp = rpcMallocCont(sizeof(SConnectRsp));
-  if (pConnectRsp == NULL) {
-    code = TSDB_CODE_MND_OUT_OF_MEMORY;
-    goto connect_over;
-  }
-
-  pConnectMsg->pid = htonl(pConnectMsg->pid);
-  SConnObj *pConn = mnodeCreateConn(connInfo.user, connInfo.clientIp, connInfo.clientPort, pConnectMsg->pid, pConnectMsg->appName);
-  if (pConn == NULL) {
-    code = terrno;
-  } else {
-    pConnectRsp->connId = htonl(pConn->connId);
-    mnodeReleaseConn(pConn);
-  }
-
-  sprintf(pConnectRsp->acctId, "%x", pAcct->acctId);
-  memcpy(pConnectRsp->serverVersion, version, TSDB_VERSION_LEN);
-  pConnectRsp->writeAuth = pUser->writeAuth;
-  pConnectRsp->superAuth = pUser->superAuth;
-  
-  mnodeGetMnodeEpSetForShell(&pConnectRsp->epSet, false);
-
-  dnodeGetClusterId(pConnectRsp->clusterId);
-
-connect_over:
-  if (code != TSDB_CODE_SUCCESS) {
-    if (pConnectRsp) rpcFreeCont(pConnectRsp);
-    mLError("user:%s login from %s, result:%s", connInfo.user, taosIpStr(connInfo.clientIp), tstrerror(code));
-  } else {
-    mLInfo("user:%s login from %s, result:%s", connInfo.user, taosIpStr(connInfo.clientIp), tstrerror(code));
-    pMsg->rpcRsp.rsp = pConnectRsp;
-    pMsg->rpcRsp.len = sizeof(SConnectRsp);
-  }
-
-  return code;
-}
-
-static int32_t mnodeProcessUseMsg(SMnodeMsg *pMsg) {
-  SUseDbMsg *pUseDbMsg = pMsg->rpcMsg.pCont;
-
-  int32_t code = TSDB_CODE_SUCCESS;
-  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pUseDbMsg->db);
-  if (pMsg->pDb == NULL) {
-    return TSDB_CODE_MND_INVALID_DB;
-  }
-  
-  if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-  return code;
-}
-
-static bool mnodeCheckShowFinished(SShowObj *pShow) {
-  if (pShow->pIter == NULL && pShow->numOfReads != 0) {
-    return true;
-  } 
-  return false;
-}
-
-static bool mnodeAccquireShowObj(SShowObj *pShow) {
-  TSDB_CACHE_PTR_TYPE handleVal = (TSDB_CACHE_PTR_TYPE)pShow;
-  SShowObj **ppShow = taosCacheAcquireByKey(tsMnodeShowCache, &handleVal, sizeof(TSDB_CACHE_PTR_TYPE));
-  if (ppShow) {
-    mDebug("%p, show is accquired from cache, data:%p, index:%d", pShow, ppShow, pShow->index);
-    return true;
-  }
-
-  return false;
-}
-
-static void* mnodePutShowObj(SShowObj *pShow) {
-  const int32_t DEFAULT_SHOWHANDLE_LIFE_SPAN = tsShellActivityTimer * 6 * 1000;
-
-  if (tsMnodeShowCache != NULL) {
-    pShow->index = atomic_add_fetch_32(&tsShowObjIndex, 1);
-    TSDB_CACHE_PTR_TYPE handleVal = (TSDB_CACHE_PTR_TYPE)pShow;
-    SShowObj **ppShow = taosCachePut(tsMnodeShowCache, &handleVal, sizeof(TSDB_CACHE_PTR_TYPE), &pShow, sizeof(TSDB_CACHE_PTR_TYPE), DEFAULT_SHOWHANDLE_LIFE_SPAN);
-    pShow->ppShow = (void**)ppShow;
-    mDebug("%p, show is put into cache, data:%p index:%d", pShow, ppShow, pShow->index);
-    return pShow;
-  }
-
-  return NULL;
-}
-
-static void mnodeFreeShowObj(void *data) {
-  SShowObj *pShow = *(SShowObj **)data;
-  if (tsMnodeShowFreeIterFp[pShow->type] != NULL) {
-    if (pShow->pVgIter != NULL) {
-      // only used in 'show vnodes "ep"'
-      (*tsMnodeShowFreeIterFp[pShow->type])(pShow->pVgIter);
-    } else {
-      if (pShow->pIter != NULL) (*tsMnodeShowFreeIterFp[pShow->type])(pShow->pIter);
-    }
-  }
-
-  mDebug("%p, show is destroyed, data:%p index:%d", pShow, data, pShow->index);
-  tfree(pShow);
-}
-
-static void mnodeReleaseShowObj(SShowObj *pShow, bool forceRemove) {
-  SShowObj **ppShow = (SShowObj **)pShow->ppShow;
-  mDebug("%p, show is released, force:%s data:%p index:%d", pShow, forceRemove ? "true" : "false", ppShow,
-         pShow->index);
-
-  taosCacheRelease(tsMnodeShowCache, (void **)(&ppShow), forceRemove);
-}
-
-void mnodeVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_t capacity, SShowObj *pShow) {
-  if (rows < capacity) {
-    for (int32_t i = 0; i < numOfCols; ++i) {
-      memmove(data + pShow->offset[i] * rows, data + pShow->offset[i] * capacity, pShow->bytes[i] * rows);
-    }
-  }
-}

src/mnode/src/mnodeTable.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "mnodeTable.h"
-#include "dnode.h"
-#include "hash.h"
-#include "mnode.h"
-#include "mnodeAcct.h"
-#include "mnodeDb.h"
-#include "mnodeDef.h"
-#include "mnodeDnode.h"
-#include "mnodeFunc.h"
-#include "mnodeInt.h"
-#include "mnodePeer.h"
-#include "mnodeRead.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeVgroup.h"
-#include "mnodeWrite.h"
-#include "os.h"
-#include "taoserror.h"
-#include "taosmsg.h"
-#include "tcompare.h"
-#include "tcompression.h"
-#include "tdataformat.h"
-#include "tglobal.h"
-#include "tgrant.h"
-#include "tidpool.h"
-#include "tname.h"
-#include "tqueue.h"
-#include "tutil.h"
-
-#define ALTER_CTABLE_RETRY_TIMES  3
-#define CREATE_CTABLE_RETRY_TIMES 10
-#define CREATE_CTABLE_RETRY_SEC   14
-
-int64_t          tsCTableRid = -1;
-static void *    tsChildTableSdb;
-int64_t          tsSTableRid = -1;
-static void *    tsSuperTableSdb;
-static SHashObj *tsSTableUidHash;
-static int32_t   tsChildTableUpdateSize;
-static int32_t   tsSuperTableUpdateSize;
-
-static void *  mnodeGetChildTable(char *tableId);
-static void *  mnodeGetSuperTable(char *tableId);
-static void *  mnodeGetSuperTableByUid(uint64_t uid);
-static void    mnodeDropAllChildTablesInStable(SSTableObj *pStable);
-static void    mnodeAddTableIntoStable(SSTableObj *pStable, SCTableObj *pCtable);
-static void    mnodeRemoveTableFromStable(SSTableObj *pStable, SCTableObj *pCtable);
-
-static int32_t mnodeGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetStreamTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveStreamTables(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-
-static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg);
-static void    mnodeProcessCreateChildTableRsp(SRpcMsg *rpcMsg);
-
-static int32_t mnodeProcessDropTableMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessDropSuperTableMsg(SMnodeMsg *pMsg);
-static void    mnodeProcessDropSuperTableRsp(SRpcMsg *rpcMsg);
-static int32_t mnodeProcessDropChildTableMsg(SMnodeMsg *pMsg);
-static void    mnodeProcessDropChildTableRsp(SRpcMsg *rpcMsg);
-
-static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessTableCfgMsg(SMnodeMsg *pMsg);
-
-static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *pMsg);
-static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg);
-static int32_t mnodeGetChildTableMeta(SMnodeMsg *pMsg);
-static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg);
-
-static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg);
-static void    mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg);
-
-static int32_t mnodeFindSuperTableColumnIndex(SSTableObj *pStable, char *colName);
-static int32_t mnodeChangeSuperTableColumn(SMnodeMsg *pMsg);
-static int32_t mnodeChangeSuperTableTag(SMnodeMsg *pMsg);
-static int32_t mnodeChangeNormalTableColumn(SMnodeMsg *pMsg);
-
-static void mnodeDestroyChildTable(SCTableObj *pTable) {
-  tfree(pTable->info.tableId);
-  tfree(pTable->schema);
-  tfree(pTable->sql);
-  tfree(pTable);
-}
-
-static char* mnodeGetTableShowPattern(SShowObj *pShow) {
-  char* pattern = NULL;
-  if (pShow != NULL && pShow->payloadLen > 0) {
-    pattern = (char*)malloc(pShow->payloadLen + 1);
-    if (pattern == NULL) {
-      terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
-      return NULL;
-    }
-    memcpy(pattern, pShow->payload, pShow->payloadLen);
-    pattern[pShow->payloadLen] = 0;
-  }
-  return pattern;
-}
-
-static int32_t mnodeChildTableActionDestroy(SSdbRow *pRow) {
-  mnodeDestroyChildTable(pRow->pObj);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeChildTableActionInsert(SSdbRow *pRow) {
-  SCTableObj *pTable = pRow->pObj;
-  int32_t code = 0;
-
-  SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId);
-  if (pVgroup == NULL) {
-    mError("ctable:%s, not in vgId:%d", pTable->info.tableId, pTable->vgId);
-    code = -1;
-  }
-
-  SDbObj *pDb = NULL;
-  if (pVgroup != NULL) {
-    pDb = mnodeGetDb(pVgroup->dbName);
-    if (pDb == NULL) {
-      mError("ctable:%s, vgId:%d not in db:%s", pTable->info.tableId, pVgroup->vgId, pVgroup->dbName);
-      code = -1;
-    }
-  }
-
-  SAcctObj *pAcct = NULL;
-  if (pDb != NULL) {
-    pAcct = mnodeGetAcct(pDb->acct);
-    if (pAcct == NULL) {
-      mError("ctable:%s, acct:%s not exists", pTable->info.tableId, pDb->acct);
-      code = -1;
-    }
-  }
-
-  if (pTable->info.type == TSDB_CHILD_TABLE) {
-    // add ref
-    pTable->superTable = mnodeGetSuperTableByUid(pTable->suid);
-    if (pTable->superTable != NULL) {
-      mnodeAddTableIntoStable(pTable->superTable, pTable);
-      grantAdd(TSDB_GRANT_TIMESERIES, pTable->superTable->numOfColumns - 1);
-      if (pAcct) pAcct->acctInfo.numOfTimeSeries += (pTable->superTable->numOfColumns - 1);
-    } else {
-      mError("table:%s:%p, correspond stable not found suid:%" PRIu64, pTable->info.tableId, pTable, pTable->suid);
-      code = -1;
-    }
-  } else {
-    grantAdd(TSDB_GRANT_TIMESERIES, pTable->numOfColumns - 1);
-    if (pAcct) pAcct->acctInfo.numOfTimeSeries += (pTable->numOfColumns - 1);
-  }
-
-  if (pDb) mnodeAddTableIntoDb(pDb);
-  if (pVgroup) {
-    if (mnodeAddTableIntoVgroup(pVgroup, pTable, pRow->pMsg == NULL) != 0) {
-      mError("table:%s, vgId:%d tid:%d, failed to perform insert action, uid:%" PRIu64 " suid:%" PRIu64,
-             pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid, pTable->suid);
-      code = -1;
-    }
-  }
-
-  mnodeDecVgroupRef(pVgroup);
-  mnodeDecDbRef(pDb);
-  mnodeDecAcctRef(pAcct);
-
-  if (code == 0) {
-    mTrace("table:%s, vgId:%d tid:%d, perform insert action, uid:%" PRIu64 " suid:%" PRIu64, pTable->info.tableId,
-           pTable->vgId, pTable->tid, pTable->uid, pTable->suid);
-  }
-
-  return code;
-}
-
-static int32_t mnodeChildTableActionDelete(SSdbRow *pRow) {
-  SCTableObj *pTable = pRow->pObj;
-  if (pTable->vgId == 0) {
-    mError("table:%s, vgId:%d tid:%d, failed to perform delete action, uid:%" PRIu64 " suid:%" PRIu64,
-           pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid, pTable->suid);
-    return TSDB_CODE_MND_VGROUP_NOT_EXIST;
-  }
-
-  SVgObj *pVgroup = NULL;
-  SDbObj *pDb = NULL;
-  SAcctObj *pAcct = NULL;
-
-  pVgroup = mnodeGetVgroup(pTable->vgId);
-  if (pVgroup != NULL) pDb = mnodeGetDb(pVgroup->dbName);
-  if (pDb != NULL) pAcct = mnodeGetAcct(pDb->acct);
-
-  if (pTable->info.type == TSDB_CHILD_TABLE) {
-    if (pTable->superTable) {
-      grantRestore(TSDB_GRANT_TIMESERIES, pTable->superTable->numOfColumns - 1);
-      if (pAcct != NULL) pAcct->acctInfo.numOfTimeSeries -= (pTable->superTable->numOfColumns - 1);
-      mnodeRemoveTableFromStable(pTable->superTable, pTable);
-      mnodeDecTableRef(pTable->superTable);
-    }
-  } else {
-    grantRestore(TSDB_GRANT_TIMESERIES, pTable->numOfColumns - 1);
-    if (pAcct != NULL) pAcct->acctInfo.numOfTimeSeries -= (pTable->numOfColumns - 1);
-  }
-
-  if (pDb != NULL) mnodeRemoveTableFromDb(pDb);
-  if (pVgroup != NULL) mnodeRemoveTableFromVgroup(pVgroup, pTable);
-
-  mnodeDecVgroupRef(pVgroup);
-  mnodeDecDbRef(pDb);
-  mnodeDecAcctRef(pAcct);
-
-  mTrace("table:%s, vgId:%d tid:%d, perform delete action, uid:%" PRIu64 " suid:%" PRIu64, pTable->info.tableId,
-         pTable->vgId, pTable->tid, pTable->uid, pTable->suid);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeChildTableActionUpdate(SSdbRow *pRow) {
-  SCTableObj *pNew = pRow->pObj;
-  SCTableObj *pTable = mnodeGetChildTable(pNew->info.tableId);
-  if (pTable != pNew) {
-    void *oldTableId = pTable->info.tableId;
-    void *oldSql = pTable->sql;
-    void *oldSchema = pTable->schema;
-    void *oldSTable = pTable->superTable;
-    int32_t oldRefCount = pTable->refCount;
-
-    memcpy(pTable, pNew, sizeof(SCTableObj));
-
-    pTable->refCount = oldRefCount;
-    pTable->sql = pNew->sql;
-    pTable->schema = pNew->schema;
-    pTable->superTable = oldSTable;
-
-    free(pNew);
-    free(oldSql);
-    free(oldSchema);
-    free(oldTableId);
-  }
-  mnodeDecTableRef(pTable);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeChildTableActionEncode(SSdbRow *pRow) {
-  SCTableObj *pTable = pRow->pObj;
-  assert(pTable != NULL && pRow->rowData != NULL);
-
-  int32_t len = (int32_t)strlen(pTable->info.tableId);
-  if (len >= TSDB_TABLE_FNAME_LEN) return TSDB_CODE_MND_INVALID_TABLE_ID;
-
-  memcpy(pRow->rowData, pTable->info.tableId, len);
-  memset((char *)pRow->rowData + len, 0, 1);
-  len++;
-
-  memcpy((char *)pRow->rowData + len, (char *)pTable + sizeof(char *), tsChildTableUpdateSize);
-  len += tsChildTableUpdateSize;
-
-  if (pTable->info.type != TSDB_CHILD_TABLE) {
-    int32_t schemaSize = pTable->numOfColumns * sizeof(SSchema);
-    memcpy((char *)pRow->rowData + len, pTable->schema, schemaSize);
-    len += schemaSize;
-
-    if (pTable->sqlLen != 0) {
-      memcpy((char *)pRow->rowData + len, pTable->sql, pTable->sqlLen);
-      len += pTable->sqlLen;
-    }
-  }
-
-  pRow->rowSize = len;
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeChildTableActionDecode(SSdbRow *pRow) {
-  assert(pRow->rowData != NULL);
-  SCTableObj *pTable = calloc(1, sizeof(SCTableObj));
-  if (pTable == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
-  int32_t len = (int32_t)strlen(pRow->rowData);
-  if (len >= TSDB_TABLE_FNAME_LEN) {
-    free(pTable);
-    return TSDB_CODE_MND_INVALID_TABLE_ID;
-  }
-  pTable->info.tableId = strdup(pRow->rowData);
-  len++;
-
-  memcpy((char *)pTable + sizeof(char *), (char *)pRow->rowData + len, tsChildTableUpdateSize);
-  len += tsChildTableUpdateSize;
-
-  if (pTable->info.type != TSDB_CHILD_TABLE) {
-    int32_t schemaSize = pTable->numOfColumns * sizeof(SSchema);
-    pTable->schema = (SSchema *)malloc(schemaSize);
-    if (pTable->schema == NULL) {
-      mnodeDestroyChildTable(pTable);
-      return TSDB_CODE_MND_INVALID_TABLE_TYPE;
-    }
-    memcpy(pTable->schema, (char *)pRow->rowData + len, schemaSize);
-    len += schemaSize;
-
-    if (pTable->sqlLen != 0) {
-      pTable->sql = malloc(pTable->sqlLen);
-      if (pTable->sql == NULL) {
-        mnodeDestroyChildTable(pTable);
-        return TSDB_CODE_MND_OUT_OF_MEMORY;
-      }
-      memcpy(pTable->sql, (char *)pRow->rowData + len, pTable->sqlLen);
-    }
-  }
-
-  pRow->pObj = pTable;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeChildTableActionRestored() {
-#if 0
-  void *pIter = NULL;
-  SCTableObj *pTable = NULL;
-
-  while (1) {
-    pIter = mnodeGetNextChildTable(pIter, &pTable);
-    if (pTable == NULL) break;
-
-    SDbObj *pDb = mnodeGetDbByTableName(pTable->info.tableId);
-    if (pDb == NULL || pDb->status != TSDB_DB_STATUS_READY) {
-      mError("ctable:%s, failed to get db or db in dropping, discard it", pTable->info.tableId);
-      SSdbRow desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .pTable = tsChildTableSdb};
-      sdbDeleteRow(&desc);
-      mnodeDecTableRef(pTable);
-      mnodeDecDbRef(pDb);
-      continue;
-    }
-    mnodeDecDbRef(pDb);
-
-    SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId);
-    if (pVgroup == NULL) {
-      mError("ctable:%s, failed to get vgId:%d tid:%d, discard it", pTable->info.tableId, pTable->vgId, pTable->tid);
-      pTable->vgId = 0;
-      SSdbRow desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .pTable = tsChildTableSdb};
-      sdbDeleteRow(&desc);
-      mnodeDecTableRef(pTable);
-      continue;
-    }
-    mnodeDecVgroupRef(pVgroup);
-
-    if (strcmp(pVgroup->dbName, pDb->name) != 0) {
-      mError("ctable:%s, db:%s not match with vgId:%d db:%s sid:%d, discard it",
-             pTable->info.tableId, pDb->name, pTable->vgId, pVgroup->dbName, pTable->tid);
-      pTable->vgId = 0;
-      SSdbRow desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .pTable = tsChildTableSdb};
-      sdbDeleteRow(&desc);
-      mnodeDecTableRef(pTable);
-      continue;
-    }
-
-    if (pTable->info.type == TSDB_CHILD_TABLE) {
-      SSTableObj *pSuperTable = mnodeGetSuperTableByUid(pTable->suid);
-      if (pSuperTable == NULL) {
-        mError("ctable:%s, stable:%" PRIu64 " not exist", pTable->info.tableId, pTable->suid);
-        pTable->vgId = 0;
-        SSdbRow desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .pTable = tsChildTableSdb};
-        sdbDeleteRow(&desc);
-        mnodeDecTableRef(pTable);
-        continue;
-      }
-      mnodeDecTableRef(pSuperTable);
-    }
-
-    mnodeDecTableRef(pTable);
-  }
-
-  mnodeCancelGetNextChildTable(pIter);
-#endif
-  return 0;
-}
-
-static int32_t mnodeInitChildTables() {
-  SCTableObj tObj;
-  tsChildTableUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj.info.type);
-
-  SSdbTableDesc desc = {
-    .id           = SDB_TABLE_CTABLE,
-    .name         = "ctables",
-    .hashSessions = TSDB_DEFAULT_CTABLES_HASH_SIZE,
-    .maxRowSize   = sizeof(SCTableObj) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16) + TSDB_TABLE_FNAME_LEN + TSDB_CQ_SQL_SIZE,
-    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
-    .keyType      = SDB_KEY_VAR_STRING,
-    .fpInsert     = mnodeChildTableActionInsert,
-    .fpDelete     = mnodeChildTableActionDelete,
-    .fpUpdate     = mnodeChildTableActionUpdate,
-    .fpEncode     = mnodeChildTableActionEncode,
-    .fpDecode     = mnodeChildTableActionDecode,
-    .fpDestroy    = mnodeChildTableActionDestroy,
-    .fpRestored   = mnodeChildTableActionRestored
-  };
-
-  tsCTableRid = sdbOpenTable(&desc);
-  tsChildTableSdb = sdbGetTableByRid(tsCTableRid);
-  if (tsChildTableSdb == NULL) {
-    mError("failed to init child table data");
-    return -1;
-  }
-
-  mDebug("table:ctables is created");
-  return 0;
-}
-
-static void mnodeCleanupChildTables() {
-  sdbCloseTable(tsCTableRid);
-  tsChildTableSdb = NULL;
-}
-
-int64_t mnodeGetSuperTableNum() {
-  return sdbGetNumOfRows(tsSuperTableSdb);
-}
-
-int64_t mnodeGetChildTableNum() {
-  return sdbGetNumOfRows(tsChildTableSdb);
-}
-
-static void mnodeAddTableIntoStable(SSTableObj *pStable, SCTableObj *pCtable) {
-  atomic_add_fetch_32(&pStable->numOfTables, 1);
-
-  if (pStable->vgHash == NULL) {
-    pStable->vgHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK);
-    mDebug("stable:%s, create vgId hash:%p", pStable->info.tableId, pStable->vgHash);
-  }
-
-  if (pStable->vgHash != NULL) {
-    if (taosHashGet(pStable->vgHash, &pCtable->vgId, sizeof(pCtable->vgId)) == NULL) {
-      taosHashPut(pStable->vgHash, &pCtable->vgId, sizeof(pCtable->vgId), &pCtable->vgId, sizeof(pCtable->vgId));
-      mDebug("stable:%s, vgId:%d is put into stable vgId hash:%p, sizeOfVgList:%d", pStable->info.tableId, pCtable->vgId,
-             pStable->vgHash, taosHashGetSize(pStable->vgHash));
-    }
-  }
-}
-
-static void mnodeRemoveTableFromStable(SSTableObj *pStable, SCTableObj *pCtable) {
-  atomic_sub_fetch_32(&pStable->numOfTables, 1);
-
-  if (pStable->vgHash == NULL) return;
-
-  SVgObj *pVgroup = mnodeGetVgroup(pCtable->vgId);
-  if (pVgroup == NULL) {
-    taosHashRemove(pStable->vgHash, &pCtable->vgId, sizeof(pCtable->vgId));
-    mDebug("table:%s, vgId:%d is remove from stable hash:%p sizeOfVgList:%d", pStable->info.tableId, pCtable->vgId,
-           pStable->vgHash, taosHashGetSize(pStable->vgHash));
-  }
-  mnodeDecVgroupRef(pVgroup);
-}
-
-static void mnodeDestroySuperTable(SSTableObj *pStable) {
-  mDebug("table:%s, is destroyed, stable hash:%p", pStable->info.tableId, pStable->vgHash);
-  if (pStable->vgHash != NULL) {
-    taosHashCleanup(pStable->vgHash);
-    pStable->vgHash = NULL;
-  }
-  tfree(pStable->info.tableId);
-  tfree(pStable->schema);
-  tfree(pStable);
-}
-
-static int32_t mnodeSuperTableActionDestroy(SSdbRow *pRow) {
-  mnodeDestroySuperTable(pRow->pObj);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionInsert(SSdbRow *pRow) {
-  SSTableObj *pStable = pRow->pObj;
-  SDbObj *    pDb = mnodeGetDbByTableName(pStable->info.tableId);
-  if (pDb != NULL && pDb->status == TSDB_DB_STATUS_READY) {
-    mnodeAddSuperTableIntoDb(pDb);
-  }
-  mnodeDecDbRef(pDb);
-
-  taosHashPut(tsSTableUidHash, &pStable->uid, sizeof(int64_t), &pStable, sizeof(int64_t));
-
-  mTrace("stable:%s, perform insert action, uid:%" PRIu64, pStable->info.tableId, pStable->uid);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionDelete(SSdbRow *pRow) {
-  SSTableObj *pStable = pRow->pObj;
-  SDbObj *    pDb = mnodeGetDbByTableName(pStable->info.tableId);
-  if (pDb != NULL) {
-    mnodeRemoveSuperTableFromDb(pDb);
-    mnodeDropAllChildTablesInStable((SSTableObj *)pStable);
-  }
-  mnodeDecDbRef(pDb);
-
-  taosHashRemove(tsSTableUidHash, &pStable->uid, sizeof(int64_t));
-
-  mTrace("stable:%s, perform delete action, uid:%" PRIu64, pStable->info.tableId, pStable->uid);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionUpdate(SSdbRow *pRow) {
-  SSTableObj *pNew = pRow->pObj;
-  SSTableObj *pTable = mnodeGetSuperTable(pNew->info.tableId);
-  if (pTable != NULL && pTable != pNew) {
-    mDebug("table:%s, will be updated, hash:%p sizeOfVgList:%d, new hash:%p sizeOfVgList:%d", pTable->info.tableId,
-           pTable->vgHash, taosHashGetSize(pTable->vgHash), pNew->vgHash, taosHashGetSize(pNew->vgHash));
-
-    void *oldTableId = pTable->info.tableId;
-    void *oldSchema = pTable->schema;
-    void *oldVgHash = pTable->vgHash;
-    int32_t oldRefCount = pTable->refCount;
-    int32_t oldNumOfTables = pTable->numOfTables;
-
-    memcpy(pTable, pNew, sizeof(SSTableObj));
-
-    pTable->vgHash = oldVgHash;
-    pTable->refCount = oldRefCount;
-    pTable->schema = pNew->schema;
-    pTable->numOfTables = oldNumOfTables;
-    free(pNew);
-    free(oldTableId);
-    free(oldSchema);
-
-    mDebug("table:%s, update finished, hash:%p sizeOfVgList:%d", pTable->info.tableId, pTable->vgHash,
-           taosHashGetSize(pTable->vgHash));
-  }
-
-  mnodeDecTableRef(pTable);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionEncode(SSdbRow *pRow) {
-  SSTableObj *pStable = pRow->pObj;
-  assert(pRow->pObj != NULL && pRow->rowData != NULL);
-
-  int32_t len = (int32_t)strlen(pStable->info.tableId);
-  if (len >= TSDB_TABLE_FNAME_LEN) len = TSDB_CODE_MND_INVALID_TABLE_ID;
-
-  memcpy(pRow->rowData, pStable->info.tableId, len);
-  memset((char *)pRow->rowData + len, 0, 1);
-  len++;
-
-  memcpy((char *)pRow->rowData + len, (char *)pStable + sizeof(char *), tsSuperTableUpdateSize);
-  len += tsSuperTableUpdateSize;
-
-  int32_t schemaSize = sizeof(SSchema) * (pStable->numOfColumns + pStable->numOfTags);
-  memcpy((char *)pRow->rowData + len, pStable->schema, schemaSize);
-  len += schemaSize;
-
-  pRow->rowSize = len;
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionDecode(SSdbRow *pRow) {
-  assert(pRow->rowData != NULL);
-  SSTableObj *pStable = (SSTableObj *) calloc(1, sizeof(SSTableObj));
-  if (pStable == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
-  int32_t len = (int32_t)strlen(pRow->rowData);
-  if (len >= TSDB_TABLE_FNAME_LEN){
-    free(pStable);
-    return TSDB_CODE_MND_INVALID_TABLE_ID;
-  }
-  pStable->info.tableId = strdup(pRow->rowData);
-  len++;
-
-  memcpy((char *)pStable + sizeof(char *), (char *)pRow->rowData + len, tsSuperTableUpdateSize);
-  len += tsSuperTableUpdateSize;
-
-  int32_t schemaSize = sizeof(SSchema) * (pStable->numOfColumns + pStable->numOfTags);
-  pStable->schema = malloc(schemaSize);
-  if (pStable->schema == NULL) {
-    mnodeDestroySuperTable(pStable);
-    return TSDB_CODE_MND_NOT_SUPER_TABLE;
-  }
-
-  memcpy(pStable->schema, (char *)pRow->rowData + len, schemaSize);
-  pRow->pObj = pStable;
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionRestored() {
-  return 0;
-}
-
-static int32_t mnodeInitSuperTables() {
-  SSTableObj tObj;
-  tsSuperTableUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj.info.type);
-
-  SSdbTableDesc desc = {
-    .id           = SDB_TABLE_STABLE,
-    .name         = "stables",
-    .hashSessions = TSDB_DEFAULT_STABLES_HASH_SIZE,
-    .maxRowSize   = sizeof(SSTableObj) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16) + TSDB_TABLE_FNAME_LEN,
-    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
-    .keyType      = SDB_KEY_VAR_STRING,
-    .fpInsert     = mnodeSuperTableActionInsert,
-    .fpDelete     = mnodeSuperTableActionDelete,
-    .fpUpdate     = mnodeSuperTableActionUpdate,
-    .fpEncode     = mnodeSuperTableActionEncode,
-    .fpDecode     = mnodeSuperTableActionDecode,
-    .fpDestroy    = mnodeSuperTableActionDestroy,
-    .fpRestored   = mnodeSuperTableActionRestored
-  };
-
-  tsSTableUidHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
-  tsSTableRid = sdbOpenTable(&desc);
-  tsSuperTableSdb = sdbGetTableByRid(tsSTableRid);
-  if (tsSuperTableSdb == NULL) {
-    mError("failed to init stables data");
-    return -1;
-  }
-
-  mDebug("table:stables is created");
-  return 0;
-}
-
-static void mnodeCleanupSuperTables() {
-  sdbCloseTable(tsSTableRid);
-  tsSuperTableSdb = NULL;
-
-  taosHashCleanup(tsSTableUidHash);
-  tsSTableUidHash = NULL;
-}
-
-int32_t mnodeInitTables() {
-  int32_t code = mnodeInitSuperTables();
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  code = mnodeInitChildTables();
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_TABLES_META, mnodeProcessMultiTableMetaMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_TABLE, mnodeProcessCreateTableMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_TABLE, mnodeProcessDropTableMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_ALTER_TABLE, mnodeProcessAlterTableMsg);
-  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_TABLE_META, mnodeProcessTableMetaMsg);
-  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_STABLE_VGROUP, mnodeProcessSuperTableVgroupMsg);
-
-  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP, mnodeProcessCreateChildTableRsp);
-  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_DROP_TABLE_RSP, mnodeProcessDropChildTableRsp);
-  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_DROP_STABLE_RSP, mnodeProcessDropSuperTableRsp);
-  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP, mnodeProcessAlterTableRsp);
-
-  mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_TABLE, mnodeProcessTableCfgMsg);
-
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_TABLE, mnodeGetShowTableMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_TABLE, mnodeRetrieveShowTables);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_TABLE, mnodeCancelGetNextChildTable);
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_METRIC, mnodeGetShowSuperTableMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_METRIC, mnodeRetrieveShowSuperTables);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_METRIC, mnodeCancelGetNextSuperTable);
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_STREAMTABLES, mnodeGetStreamTableMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMTABLES, mnodeRetrieveStreamTables);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_STREAMTABLES, mnodeCancelGetNextChildTable);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static void *mnodeGetChildTable(char *tableId) {
-  return sdbGetRow(tsChildTableSdb, tableId);
-}
-
-static void *mnodeGetSuperTable(char *tableId) {
-  return sdbGetRow(tsSuperTableSdb, tableId);
-}
-
-static void *mnodeGetSuperTableByUid(uint64_t uid) {
-  SSTableObj **ppStable = taosHashGet(tsSTableUidHash, &uid, sizeof(int64_t));
-  if (ppStable == NULL || *ppStable == NULL) return NULL;
-
-  SSTableObj *pStable = *ppStable;
-  mnodeIncTableRef(pStable);
-  return pStable;
-}
-
-void *mnodeGetTable(char *tableId) {
-  void *pTable = mnodeGetSuperTable(tableId);
-  if (pTable != NULL) {
-    return pTable;
-  }
-
-  pTable = mnodeGetChildTable(tableId);
-  if (pTable != NULL) {
-    return pTable;
-  }
-
-  return NULL;
-}
-
-void *mnodeGetNextChildTable(void *pIter, SCTableObj **pTable) {
-  return sdbFetchRow(tsChildTableSdb, pIter, (void **)pTable);
-}
-
-void mnodeCancelGetNextChildTable(void *pIter) {
-  sdbFreeIter(tsChildTableSdb, pIter);
-}
-
-void *mnodeGetNextSuperTable(void *pIter, SSTableObj **pTable) {
-  return sdbFetchRow(tsSuperTableSdb, pIter, (void **)pTable);
-}
-
-void mnodeCancelGetNextSuperTable(void *pIter) {
-  sdbFreeIter(tsSuperTableSdb, pIter);
-}
-
-void mnodeIncTableRef(void *p1) {
-  STableObj *pTable = (STableObj *)p1;
-  if (pTable->type == TSDB_SUPER_TABLE) {
-    sdbIncRef(tsSuperTableSdb, pTable);
-  } else {
-    sdbIncRef(tsChildTableSdb, pTable);
-  }
-}
-
-void mnodeDecTableRef(void *p1) {
-  if (p1 == NULL) return;
-
-  STableObj *pTable = (STableObj *)p1;
-  if (pTable->type == TSDB_SUPER_TABLE) {
-    sdbDecRef(tsSuperTableSdb, pTable);
-  } else {
-    sdbDecRef(tsChildTableSdb, pTable);
-  }
-}
-
-void mnodeCleanupTables() {
-  mnodeCleanupChildTables();
-  mnodeCleanupSuperTables();
-}
-
-// todo move to name.h, add length of table name
-static void mnodeExtractTableName(char* tableId, char* name) {
-  int pos = -1;
-  int num = 0;
-  for (pos = 0; tableId[pos] != 0; ++pos) {
-    if (tableId[pos] == '.') num++;
-    if (num == 2) break;
-  }
-
-  if (num == 2) {
-    strcpy(name, tableId + pos + 1);
-  }
-}
-
-static SMnodeMsg *mnodeCreateSubMsg(SMnodeMsg *pBatchMasterMsg, int32_t contSize) {
-  SMnodeMsg *pSubMsg = taosAllocateQitem(sizeof(*pBatchMasterMsg) + contSize);
-  *pSubMsg = *pBatchMasterMsg;
-
-  //pSubMsg->pCont = (char *) pSubMsg + sizeof(SMnodeMsg);
-  pSubMsg->rpcMsg.pCont = pSubMsg->pCont;
-  pSubMsg->successed = 0;
-  pSubMsg->expected = 0;
-  SCMCreateTableMsg *pCM = pSubMsg->rpcMsg.pCont;
-  pCM->numOfTables = htonl(1);
-  pCM->contLen = htonl(contSize);
-
-  return pSubMsg;
-}
-
-void mnodeDestroySubMsg(SMnodeMsg *pSubMsg) {
-  if (pSubMsg) {
-    // pUser is retained in batch master msg
-    if (pSubMsg->pDb) mnodeDecDbRef(pSubMsg->pDb);
-    if (pSubMsg->pVgroup) mnodeDecVgroupRef(pSubMsg->pVgroup);
-    if (pSubMsg->pTable) mnodeDecTableRef(pSubMsg->pTable);
-    if (pSubMsg->pSTable) mnodeDecTableRef(pSubMsg->pSTable);
-    if (pSubMsg->pAcct) mnodeDecAcctRef(pSubMsg->pAcct);
-    if (pSubMsg->pDnode) mnodeDecDnodeRef(pSubMsg->pDnode);
-
-    taosFreeQitem(pSubMsg);
-  }
-}
-
-static int32_t mnodeValidateCreateTableMsg(SCreateTableMsg *pCreateTable, SMnodeMsg *pMsg) {
-  if (pMsg->pDb == NULL) {
-    pMsg->pDb = mnodeGetDbByTableName(pCreateTable->tableName);
-  }
-
-  if (pMsg->pDb == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to create, db not selected", pMsg, pMsg->rpcMsg.ahandle, pCreateTable->tableName);
-    return TSDB_CODE_MND_DB_NOT_SELECTED;
-  }
-
-  if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-  if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pCreateTable->tableName);
-  if (pMsg->pTable != NULL && pMsg->retry == 0) {
-    if (pCreateTable->getMeta) {
-      mDebug("msg:%p, app:%p table:%s, continue to get meta", pMsg, pMsg->rpcMsg.ahandle, pCreateTable->tableName);
-      return mnodeGetChildTableMeta(pMsg);
-    } else if (pCreateTable->igExists) {
-      mDebug("msg:%p, app:%p table:%s, is already exist", pMsg, pMsg->rpcMsg.ahandle, pCreateTable->tableName);
-      return TSDB_CODE_SUCCESS;
-    } else {
-      mError("msg:%p, app:%p table:%s, failed to create, table already exist", pMsg, pMsg->rpcMsg.ahandle,
-             pCreateTable->tableName);
-      return TSDB_CODE_MND_TABLE_ALREADY_EXIST;
-    }
-  }
-
-  if (pCreateTable->numOfTags != 0) {
-    mDebug("msg:%p, app:%p table:%s, batch create stable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
-           pCreateTable->tableName, pMsg->rpcMsg.handle);
-    return mnodeProcessCreateSuperTableMsg(pMsg);
-  } else {
-    mDebug("msg:%p, app:%p table:%s, batch create ctable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
-           pCreateTable->tableName, pMsg->rpcMsg.handle);
-    return mnodeProcessCreateChildTableMsg(pMsg);
-  }
-}
-
-static int32_t mnodeProcessBatchCreateTableMsg(SMnodeMsg *pMsg) {
-  if (pMsg->pBatchMasterMsg == NULL) { // batch master first round
-    pMsg->pBatchMasterMsg = pMsg;
-
-    SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
-    int32_t numOfTables = htonl(pCreate->numOfTables);
-    int32_t contentLen = htonl(pCreate->contLen);
-    pMsg->expected = numOfTables;
-
-    int32_t code = TSDB_CODE_SUCCESS;
-    SCreateTableMsg *pCreateTable = (SCreateTableMsg*) ((char*) pCreate + sizeof(SCMCreateTableMsg));
-    for (SCreateTableMsg *p = pCreateTable; p < (SCreateTableMsg *) ((char *) pCreate + contentLen); p = (SCreateTableMsg *) ((char *) p + htonl(p->len))) {
-      SMnodeMsg *pSubMsg = mnodeCreateSubMsg(pMsg, sizeof(SCMCreateTableMsg) + htonl(p->len));
-      memcpy(pSubMsg->pCont + sizeof(SCMCreateTableMsg), p, htonl(p->len));
-      code = mnodeValidateCreateTableMsg(p, pSubMsg);
-
-      if (code == TSDB_CODE_SUCCESS || code == TSDB_CODE_MND_TABLE_ALREADY_EXIST) {
-	++pSubMsg->pBatchMasterMsg->successed;
-	mnodeDestroySubMsg(pSubMsg);
-	continue;
-      }
-
-      if (code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-	mnodeDestroySubMsg(pSubMsg);
-	return code;
-      }
-    }
-
-    if (pMsg->successed >= pMsg->expected) {
-      return code;
-    } else {
-      return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-    }
-  } else {
-    if (pMsg->pBatchMasterMsg != pMsg) { // batch sub replay
-      SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
-      SCreateTableMsg *pCreateTable = (SCreateTableMsg*) ((char*) pCreate + sizeof(SCMCreateTableMsg));
-      int32_t code = mnodeValidateCreateTableMsg(pCreateTable, pMsg);
-      if (code == TSDB_CODE_SUCCESS || code == TSDB_CODE_MND_TABLE_ALREADY_EXIST) {
-        ++pMsg->pBatchMasterMsg->successed;
-        mnodeDestroySubMsg(pMsg);
-      } else if (code == TSDB_CODE_MND_ACTION_NEED_REPROCESSED) {
-        return code;
-      } else if (code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-        ++pMsg->pBatchMasterMsg->received;
-        pMsg->pBatchMasterMsg->code = code;
-        mnodeDestroySubMsg(pMsg);
-      }
-
-      if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received
-	  >= pMsg->pBatchMasterMsg->expected) {
-        dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, pMsg->pBatchMasterMsg->code);
-      }
-
-      return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-    } else { // batch master replay, reprocess the whole batch
-      assert(0);
-      return TSDB_CODE_MND_MSG_NOT_PROCESSED;
-    }
-  }
-}
-
-static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) {
-  SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
-
-  int32_t numOfTables = htonl(pCreate->numOfTables);
-  int32_t contentLen = htonl(pCreate->contLen);
-  if (numOfTables == 0 || contentLen == 0) {
-    // todo return error
-  }
-
-  // batch master msg first round or reprocessing and batch sub msg reprocessing
-  if (numOfTables > 1 || pMsg->pBatchMasterMsg != NULL) {
-    return mnodeProcessBatchCreateTableMsg(pMsg);
-  }
-
-  SCreateTableMsg *p = (SCreateTableMsg*)((char*) pCreate + sizeof(SCMCreateTableMsg));
-  if (pMsg->pDb == NULL) {
-    pMsg->pDb = mnodeGetDbByTableName(p->tableName);
-  }
-
-  if (pMsg->pDb == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to create, db not selected", pMsg, pMsg->rpcMsg.ahandle, p->tableName);
-    return TSDB_CODE_MND_DB_NOT_SELECTED;
-  }
-
-  if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-  if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(p->tableName);
-  if (pMsg->pTable != NULL && pMsg->retry == 0) {
-    if (p->getMeta) {
-      mDebug("msg:%p, app:%p table:%s, continue to get meta", pMsg, pMsg->rpcMsg.ahandle, p->tableName);
-      return mnodeGetChildTableMeta(pMsg);
-    } else if (p->igExists) {
-      mDebug("msg:%p, app:%p table:%s, is already exist", pMsg, pMsg->rpcMsg.ahandle, p->tableName);
-      return TSDB_CODE_SUCCESS;
-    } else {
-      mError("msg:%p, app:%p table:%s, failed to create, table already exist", pMsg, pMsg->rpcMsg.ahandle, p->tableName);
-      return TSDB_CODE_MND_TABLE_ALREADY_EXIST;
-    }
-  }
-
-  if (p->numOfTags != 0) {
-    mDebug("msg:%p, app:%p table:%s, create stable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
-           p->tableName, pMsg->rpcMsg.handle);
-    return mnodeProcessCreateSuperTableMsg(pMsg);
-  } else {
-    mDebug("msg:%p, app:%p table:%s, create ctable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
-           p->tableName, pMsg->rpcMsg.handle);
-    return mnodeProcessCreateChildTableMsg(pMsg);
-  }
-}
-
-static int32_t mnodeProcessDropTableMsg(SMnodeMsg *pMsg) {
-  SCMDropTableMsg *pDrop = pMsg->rpcMsg.pCont;
-  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableName(pDrop->name);
-  if (pMsg->pDb == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to drop table, db not selected or db in dropping", pMsg,
-           pMsg->rpcMsg.ahandle, pDrop->name);
-    return TSDB_CODE_MND_DB_NOT_SELECTED;
-  }
-
-  if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-#if 0
-  if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) {
-    mError("msg:%p, app:%p table:%s, failed to drop table, in monitor database", pMsg, pMsg->rpcMsg.ahandle,
-           pDrop->name);
-    return TSDB_CODE_MND_MONITOR_DB_FORBIDDEN;
-  }
-#endif
-
-  if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pDrop->name);
-  if (pMsg->pTable == NULL) {
-    if (pDrop->igNotExists) {
-      mDebug("msg:%p, app:%p table:%s is not exist, treat as success", pMsg, pMsg->rpcMsg.ahandle, pDrop->name);
-      return TSDB_CODE_SUCCESS;
-    } else {
-      mError("msg:%p, app:%p table:%s, failed to drop, table not exist", pMsg, pMsg->rpcMsg.ahandle, pDrop->name);
-      return TSDB_CODE_MND_INVALID_TABLE_NAME;
-    }
-  }
-
-  if (pMsg->pTable->type == TSDB_SUPER_TABLE) {
-    SSTableObj *pSTable = (SSTableObj *)pMsg->pTable;
-    mInfo("msg:%p, app:%p table:%s, start to drop stable, uid:%" PRIu64 ", numOfChildTables:%d, sizeOfVgList:%d", pMsg,
-          pMsg->rpcMsg.ahandle, pDrop->name, pSTable->uid, pSTable->numOfTables, taosHashGetSize(pSTable->vgHash));
-    return mnodeProcessDropSuperTableMsg(pMsg);
-  } else {
-    // user specify the "DROP STABLE" sql statement, but it is actually a normal table, return error msg.
-    if (pDrop->supertable) {
-      return TSDB_CODE_MND_INVALID_TABLE_TYPE;
-    }
-
-    SCTableObj *pCTable = (SCTableObj *)pMsg->pTable;
-    mInfo("msg:%p, app:%p table:%s, start to drop ctable, vgId:%d tid:%d uid:%" PRIu64, pMsg, pMsg->rpcMsg.ahandle,
-          pDrop->name, pCTable->vgId, pCTable->tid, pCTable->uid);
-    return mnodeProcessDropChildTableMsg(pMsg);
-  }
-}
-
-static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *pMsg) {
-  STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
-  pInfo->createFlag = htons(pInfo->createFlag);
-  mDebug("msg:%p, app:%p table:%s, table meta msg is received from thandle:%p, createFlag:%d", pMsg, pMsg->rpcMsg.ahandle,
-         pInfo->tableFname, pMsg->rpcMsg.handle, pInfo->createFlag);
-
-  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableName(pInfo->tableFname);
-  if (pMsg->pDb == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to get table meta, db not selected", pMsg, pMsg->rpcMsg.ahandle,
-           pInfo->tableFname);
-    return TSDB_CODE_MND_DB_NOT_SELECTED;
-  }
-
-  if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-  if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pInfo->tableFname);
-  if (pMsg->pTable == NULL) {
-    if (!pInfo->createFlag) {
-      mError("msg:%p, app:%p table:%s, failed to get table meta, table not exist", pMsg, pMsg->rpcMsg.ahandle,
-             pInfo->tableFname);
-      return TSDB_CODE_MND_INVALID_TABLE_NAME;
-    } else {
-      mDebug("msg:%p, app:%p table:%s, failed to get table meta, start auto create table ", pMsg, pMsg->rpcMsg.ahandle,
-             pInfo->tableFname);
-      return mnodeAutoCreateChildTable(pMsg);
-    }
-  } else {
-    if (pMsg->pTable->type != TSDB_SUPER_TABLE) {
-      return mnodeGetChildTableMeta(pMsg);
-    } else {
-      return mnodeGetSuperTableMeta(pMsg);
-    }
-  }
-}
-
-static int32_t mnodeCreateSuperTableCb(SMnodeMsg *pMsg, int32_t code) {
-  SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
-  assert(pTable);
-
-  if (code == TSDB_CODE_SUCCESS) {
-    mLInfo("stable:%s, is created in sdb, uid:%" PRIu64, pTable->info.tableId, pTable->uid);
-  } else {
-    mError("msg:%p, app:%p stable:%s, failed to create in sdb, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
-           tstrerror(code));
-    SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pTable, .pTable = tsSuperTableSdb};
-    sdbDeleteRow(&desc);
-  }
-
-  return code;
-}
-
-static uint64_t mnodeCreateSuperTableUid() {
-  int64_t us = taosGetTimestampUs();
-  uint64_t x = (us & ((((uint64_t)1)<<40) - 1));
-  x = x << 24;
-
-  return x + ((sdbGetVersion() & ((1ul << 16) - 1ul)) << 8) + (taosRand() & ((1ul << 8) - 1ul));
-}
-
-static uint64_t mnodeCreateTableUid(int32_t vgId, int32_t tid) {
-  uint64_t uid = (((uint64_t)vgId) << 48) + ((((uint64_t)tid) & ((1ul << 24) - 1ul)) << 24) +
-                ((sdbGetVersion() & ((1ul << 16) - 1ul)) << 8) + (taosRand() & ((1ul << 8) - 1ul));
-  return uid;
-}
-
-static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) {
-  if (pMsg == NULL) return TSDB_CODE_MND_APP_ERROR;
-
-  SCMCreateTableMsg *pCreate1 = pMsg->rpcMsg.pCont;
-  if (pCreate1->numOfTables == 0) {
-    return TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG;
-  }
-
-  SCreateTableMsg* pCreate = (SCreateTableMsg*)((char*)pCreate1 + sizeof(SCMCreateTableMsg));
-
-  int16_t numOfTags = htons(pCreate->numOfTags);
-  if (numOfTags > TSDB_MAX_TAGS) {
-    mError("msg:%p, app:%p table:%s, failed to create, too many tags", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
-    return TSDB_CODE_MND_TOO_MANY_TAGS;
-  }
-
-  int16_t numOfColumns = htons(pCreate->numOfColumns);
-  int32_t numOfCols = numOfColumns + numOfTags;
-  if (numOfCols > TSDB_MAX_COLUMNS) {
-    mError("msg:%p, app:%p table:%s, failed to create, too many columns", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
-    return TSDB_CODE_MND_TOO_MANY_COLUMNS;
-  }
-
-  SSTableObj *pStable = calloc(1, sizeof(SSTableObj));
-  if (pStable == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to create, no enough memory", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-
-  pStable->info.tableId = strdup(pCreate->tableName);
-  pStable->info.type    = TSDB_SUPER_TABLE;
-  pStable->createdTime  = taosGetTimestampMs();
-  pStable->uid          = mnodeCreateSuperTableUid();
-  pStable->sversion     = 0;
-  pStable->tversion     = 0;
-  pStable->numOfColumns = numOfColumns;
-  pStable->numOfTags    = numOfTags;
-
-  int32_t schemaSize = numOfCols * sizeof(SSchema);
-  pStable->schema = (SSchema *)calloc(1, schemaSize);
-  if (pStable->schema == NULL) {
-    tfree(pStable->info.tableId);
-    tfree(pStable);
-    mError("msg:%p, app:%p table:%s, failed to create, no schema input", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
-    return TSDB_CODE_MND_INVALID_TABLE_NAME;
-  }
-
-  memcpy(pStable->schema, pCreate->schema, numOfCols * sizeof(SSchema));
-
-  pStable->nextColId = 0;
-
-  for (int32_t col = 0; col < numOfCols; col++) {
-    SSchema *tschema = pStable->schema;
-    tschema[col].colId = pStable->nextColId++;
-    tschema[col].bytes = htons(tschema[col].bytes);
-  }
-
-  if (!tIsValidSchema(pStable->schema, pStable->numOfColumns, pStable->numOfTags)) {
-    mError("msg:%p, app:%p table:%s, failed to create table, invalid schema", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
-    tfree(pStable->info.tableId);
-    tfree(pStable->schema);
-    tfree(pStable);
-    return TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG;
-  }
-
-  pMsg->pTable = (STableObj *)pStable;
-  mnodeIncTableRef(pMsg->pTable);
-
-  SSdbRow row = {
-    .type    = SDB_OPER_GLOBAL,
-    .pTable  = tsSuperTableSdb,
-    .pObj    = pStable,
-    .rowSize = sizeof(SSTableObj) + schemaSize,
-    .pMsg    = pMsg,
-    .fpRsp   = mnodeCreateSuperTableCb
-  };
-
-  int32_t code = sdbInsertRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mnodeDestroySuperTable(pStable);
-    pMsg->pTable = NULL;
-    mError("msg:%p, app:%p table:%s, failed to create, sdb error", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
-  }
-
-  return code;
-}
-
-static int32_t mnodeDropSuperTableCb(SMnodeMsg *pMsg, int32_t code) {
-  SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
-  if (code != TSDB_CODE_SUCCESS) {
-    mError("msg:%p, app:%p stable:%s, failed to drop, sdb error", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
-
-    return code;
-  }
-
-  mLInfo("msg:%p, app:%p stable:%s, is dropped from sdb", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
-
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  if (pStable->vgHash != NULL /*pStable->numOfTables != 0*/) {
-    int32_t *pVgId = taosHashIterate(pStable->vgHash, NULL);
-    while (pVgId) {
-      SVgObj *pVgroup = mnodeGetVgroup(*pVgId);
-      pVgId = taosHashIterate(pStable->vgHash, pVgId);
-      if (pVgroup == NULL) break;
-
-      SDropSTableMsg *pDrop = rpcMallocCont(sizeof(SDropSTableMsg));
-      pDrop->contLen = htonl(sizeof(SDropSTableMsg));
-      pDrop->vgId = htonl(pVgroup->vgId);
-      pDrop->uid = htobe64(pStable->uid);
-      mnodeExtractTableName(pStable->info.tableId, pDrop->tableFname);
-
-      mInfo("msg:%p, app:%p stable:%s, send drop stable msg to vgId:%d, hash:%p sizeOfVgList:%d", pMsg,
-            pMsg->rpcMsg.ahandle, pStable->info.tableId, pVgroup->vgId, pStable->vgHash,
-            taosHashGetSize(pStable->vgHash));
-      SRpcEpSet epSet = mnodeGetEpSetFromVgroup(pVgroup);
-      SRpcMsg   rpcMsg = {.pCont = pDrop, .contLen = sizeof(SDropSTableMsg), .msgType = TSDB_MSG_TYPE_MD_DROP_STABLE};
-      dnodeSendMsgToDnode(&epSet, &rpcMsg);
-      mnodeDecVgroupRef(pVgroup);
-    }
-
-    taosHashCancelIterate(pStable->vgHash, pVgId);
-
-    mnodeDropAllChildTablesInStable(pStable);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeProcessDropSuperTableMsg(SMnodeMsg *pMsg) {
-  if (pMsg == NULL) return TSDB_CODE_MND_APP_ERROR;
-
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  mInfo("msg:%p, app:%p stable:%s will be dropped, hash:%p sizeOfVgList:%d", pMsg, pMsg->rpcMsg.ahandle,
-        pStable->info.tableId, pStable->vgHash, taosHashGetSize(pStable->vgHash));
-
-  SSdbRow row = {
-    .type    = SDB_OPER_GLOBAL,
-    .pTable  = tsSuperTableSdb,
-    .pObj    = pStable,
-    .pMsg    = pMsg,
-    .fpRsp   = mnodeDropSuperTableCb
-  };
-
-  int32_t code = sdbDeleteRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("msg:%p, app:%p table:%s, failed to drop, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-           tstrerror(code));
-  }
-
-  return code;
-}
-
-static int32_t mnodeFindSuperTableTagIndex(SSTableObj *pStable, const char *tagName) {
-  SSchema *schema = (SSchema *) pStable->schema;
-  for (int32_t tag = 0; tag < pStable->numOfTags; tag++) {
-    if (strcasecmp(schema[pStable->numOfColumns + tag].name, tagName) == 0) {
-      return tag;
-    }
-  }
-
-  return -1;
-}
-
-static int32_t mnodeAddSuperTableTagCb(SMnodeMsg *pMsg, int32_t code) {
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  mLInfo("msg:%p, app:%p stable %s, add tag result:%s, numOfTags:%d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-          tstrerror(code), pStable->numOfTags);
-  if (code == TSDB_CODE_SUCCESS) {
-    code = mnodeGetSuperTableMeta(pMsg);
-  }
-  return code;
-}
-
-static int32_t mnodeAddSuperTableTag(SMnodeMsg *pMsg, SSchema schema[], int32_t ntags) {
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  if (pStable->numOfTags + ntags > TSDB_MAX_TAGS) {
-    mError("msg:%p, app:%p stable:%s, add tag, too many tags", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId);
-    return TSDB_CODE_MND_TOO_MANY_TAGS;
-  }
-
-  for (int32_t i = 0; i < ntags; i++) {
-    if (mnodeFindSuperTableColumnIndex(pStable, schema[i].name) > 0) {
-      mError("msg:%p, app:%p stable:%s, add tag, column:%s already exist", pMsg, pMsg->rpcMsg.ahandle,
-             pStable->info.tableId, schema[i].name);
-      return TSDB_CODE_MND_TAG_ALREAY_EXIST;
-    }
-
-    if (mnodeFindSuperTableTagIndex(pStable, schema[i].name) > 0) {
-      mError("msg:%p, app:%p stable:%s, add tag, tag:%s already exist", pMsg, pMsg->rpcMsg.ahandle,
-             pStable->info.tableId, schema[i].name);
-      return TSDB_CODE_MND_FIELD_ALREAY_EXIST;
-    }
-  }
-
-  int32_t schemaSize = sizeof(SSchema) * (pStable->numOfTags + pStable->numOfColumns);
-  pStable->schema = realloc(pStable->schema, schemaSize + sizeof(SSchema) * ntags);
-
-  memcpy(pStable->schema + pStable->numOfColumns + pStable->numOfTags, schema, sizeof(SSchema) * ntags);
-
-  SSchema *tschema = (SSchema *)(pStable->schema + pStable->numOfColumns + pStable->numOfTags);
-  for (int32_t i = 0; i < ntags; i++) {
-    tschema[i].colId = pStable->nextColId++;
-  }
-
-  pStable->numOfTags += ntags;
-  pStable->tversion++;
-
-  mInfo("msg:%p, app:%p stable %s, start to add tag %s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-         schema[0].name);
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsSuperTableSdb,
-    .pObj   = pStable,
-    .pMsg   = pMsg,
-    .fpRsp  = mnodeAddSuperTableTagCb
-  };
-
-  return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeDropSuperTableTagCb(SMnodeMsg *pMsg, int32_t code) {
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  mLInfo("msg:%p, app:%p stable %s, drop tag result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-          tstrerror(code));
-  if (code == TSDB_CODE_SUCCESS) {
-    code = mnodeGetSuperTableMeta(pMsg);
-  }
-  return code;
-}
-
-static int32_t mnodeDropSuperTableTag(SMnodeMsg *pMsg, char *tagName) {
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  int32_t col = mnodeFindSuperTableTagIndex(pStable, tagName);
-  if (col < 0) {
-    mError("msg:%p, app:%p stable:%s, drop tag, tag:%s not exist", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-           tagName);
-    return TSDB_CODE_MND_TAG_NOT_EXIST;
-  }
-
-  memmove(pStable->schema + pStable->numOfColumns + col, pStable->schema + pStable->numOfColumns + col + 1,
-          sizeof(SSchema) * (pStable->numOfTags - col - 1));
-  pStable->numOfTags--;
-  pStable->tversion++;
-
-  mInfo("msg:%p, app:%p stable %s, start to drop tag %s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId, tagName);
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsSuperTableSdb,
-    .pObj   = pStable,
-    .pMsg   = pMsg,
-    .fpRsp  = mnodeDropSuperTableTagCb
-  };
-
-  return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeModifySuperTableTagNameCb(SMnodeMsg *pMsg, int32_t code) {
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  mLInfo("msg:%p, app:%p stable %s, modify tag result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-         tstrerror(code));
-  if (code == TSDB_CODE_SUCCESS) {
-    code = mnodeGetSuperTableMeta(pMsg);
-  }
-  return code;
-}
-
-static int32_t mnodeModifySuperTableTagName(SMnodeMsg *pMsg, char *oldTagName, char *newTagName) {
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  int32_t col = mnodeFindSuperTableTagIndex(pStable, oldTagName);
-  if (col < 0) {
-    mError("msg:%p, app:%p stable:%s, failed to modify table tag, oldName: %s, newName: %s", pMsg, pMsg->rpcMsg.ahandle,
-           pStable->info.tableId, oldTagName, newTagName);
-    return TSDB_CODE_MND_TAG_NOT_EXIST;
-  }
-
-  // int32_t  rowSize = 0;
-  uint32_t len = (int32_t)strlen(newTagName);
-  if (len >= TSDB_COL_NAME_LEN) {
-    return TSDB_CODE_MND_COL_NAME_TOO_LONG;
-  }
-
-  if (mnodeFindSuperTableTagIndex(pStable, newTagName) >= 0) {
-    return TSDB_CODE_MND_TAG_ALREAY_EXIST;
-  }
-
-  // update
-  SSchema *schema = (SSchema *) (pStable->schema + pStable->numOfColumns + col);
-  tstrncpy(schema->name, newTagName, sizeof(schema->name));
-
-  mInfo("msg:%p, app:%p stable %s, start to modify tag %s to %s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-         oldTagName, newTagName);
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsSuperTableSdb,
-    .pObj   = pStable,
-    .pMsg   = pMsg,
-    .fpRsp  = mnodeModifySuperTableTagNameCb
-  };
-
-  return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeFindSuperTableColumnIndex(SSTableObj *pStable, char *colName) {
-  SSchema *schema = (SSchema *) pStable->schema;
-  for (int32_t col = 0; col < pStable->numOfColumns; col++) {
-    if (strcasecmp(schema[col].name, colName) == 0) {
-      return col;
-    }
-  }
-
-  return -1;
-}
-
-static int32_t mnodeAddSuperTableColumnCb(SMnodeMsg *pMsg, int32_t code) {
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  mLInfo("msg:%p, app:%p stable %s, add column result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-          tstrerror(code));
-  if (code == TSDB_CODE_SUCCESS) {
-    code = mnodeGetSuperTableMeta(pMsg);
-  }
-  return code;
-}
-
-static int32_t mnodeAddSuperTableColumn(SMnodeMsg *pMsg, SSchema schema[], int32_t ncols) {
-  SDbObj *pDb = pMsg->pDb;
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  if (ncols <= 0) {
-    mError("msg:%p, app:%p stable:%s, add column, ncols:%d <= 0", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId, ncols);
-    return TSDB_CODE_MND_APP_ERROR;
-  }
-
-  if (pStable->numOfColumns + ncols + pStable->numOfTags > TSDB_MAX_COLUMNS) {
-    mError("msg:%p, app:%p stable:%s, add column, too many columns", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId);
-    return TSDB_CODE_MND_TOO_MANY_COLUMNS;
-  }
-
-  for (int32_t i = 0; i < ncols; i++) {
-    if (mnodeFindSuperTableColumnIndex(pStable, schema[i].name) > 0) {
-      mError("msg:%p, app:%p stable:%s, add column, column:%s already exist", pMsg, pMsg->rpcMsg.ahandle,
-             pStable->info.tableId, schema[i].name);
-      return TSDB_CODE_MND_FIELD_ALREAY_EXIST;
-    }
-
-    if (mnodeFindSuperTableTagIndex(pStable, schema[i].name) > 0) {
-      mError("msg:%p, app:%p stable:%s, add column, tag:%s already exist", pMsg, pMsg->rpcMsg.ahandle,
-             pStable->info.tableId, schema[i].name);
-      return TSDB_CODE_MND_TAG_ALREAY_EXIST;
-    }
-  }
-
-  int32_t schemaSize = sizeof(SSchema) * (pStable->numOfTags + pStable->numOfColumns);
-  pStable->schema = realloc(pStable->schema, schemaSize + sizeof(SSchema) * ncols);
-
-  memmove(pStable->schema + pStable->numOfColumns + ncols, pStable->schema + pStable->numOfColumns,
-          sizeof(SSchema) * pStable->numOfTags);
-  memcpy(pStable->schema + pStable->numOfColumns, schema, sizeof(SSchema) * ncols);
-
-  SSchema *tschema = (SSchema *) (pStable->schema + pStable->numOfColumns);
-  for (int32_t i = 0; i < ncols; i++) {
-    tschema[i].colId = pStable->nextColId++;
-  }
-
-  pStable->numOfColumns += ncols;
-  pStable->sversion++;
-
-  SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
-  if (pAcct != NULL) {
-    pAcct->acctInfo.numOfTimeSeries += (ncols * pStable->numOfTables);
-    mnodeDecAcctRef(pAcct);
-  }
-
-  mInfo("msg:%p, app:%p stable %s, start to add column", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId);
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsSuperTableSdb,
-    .pObj   = pStable,
-    .pMsg   = pMsg,
-    .fpRsp  = mnodeAddSuperTableColumnCb
-  };
-
- return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeDropSuperTableColumnCb(SMnodeMsg *pMsg, int32_t code) {
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  mLInfo("msg:%p, app:%p stable %s, delete column result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-         tstrerror(code));
-  if (code == TSDB_CODE_SUCCESS) {
-    code = mnodeGetSuperTableMeta(pMsg);
-  }
-  return code;
-}
-
-static int32_t mnodeDropSuperTableColumn(SMnodeMsg *pMsg, char *colName) {
-  SDbObj *pDb = pMsg->pDb;
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  int32_t col = mnodeFindSuperTableColumnIndex(pStable, colName);
-  if (col <= 0) {
-    mError("msg:%p, app:%p stable:%s, drop column, column:%s not exist", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-           colName);
-    return TSDB_CODE_MND_FIELD_NOT_EXIST;
-  }
-
-  memmove(pStable->schema + col, pStable->schema + col + 1,
-          sizeof(SSchema) * (pStable->numOfColumns + pStable->numOfTags - col - 1));
-
-  pStable->numOfColumns--;
-  pStable->sversion++;
-
-  int32_t schemaSize = sizeof(SSchema) * (pStable->numOfTags + pStable->numOfColumns);
-  pStable->schema = realloc(pStable->schema, schemaSize);
-
-  SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
-  if (pAcct != NULL) {
-    pAcct->acctInfo.numOfTimeSeries -= pStable->numOfTables;
-    mnodeDecAcctRef(pAcct);
-  }
-
-  mInfo("msg:%p, app:%p stable %s, start to delete column", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId);
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsSuperTableSdb,
-    .pObj   = pStable,
-    .pMsg   = pMsg,
-    .fpRsp  = mnodeDropSuperTableColumnCb
-  };
-
-  return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeChangeSuperTableColumnCb(SMnodeMsg *pMsg, int32_t code) {
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  mLInfo("msg:%p, app:%p stable %s, change column result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-         tstrerror(code));
-  if (code == TSDB_CODE_SUCCESS) {
-    code = mnodeGetSuperTableMeta(pMsg);
-  }
-  return code;
-}
-
-static int32_t mnodeChangeSuperTableColumn(SMnodeMsg *pMsg) {
-  SAlterTableMsg *pAlter = pMsg->rpcMsg.pCont;
-  char* name = pAlter->schema[0].name;
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  int32_t col = mnodeFindSuperTableColumnIndex(pStable, name);
-  if (col < 0) {
-    mError("msg:%p, app:%p stable:%s, change column, name:%s", pMsg, pMsg->rpcMsg.ahandle,
-           pStable->info.tableId, name);
-    return TSDB_CODE_MND_FIELD_NOT_EXIST;
-  }
-
-  // check exceed max row bytes
-  int32_t i;
-  uint32_t nLen = 0;
-  for (i = 0; i < pStable->numOfColumns; ++i) {
-    nLen += (pStable->schema[i].colId == col) ? pAlter->schema[0].bytes : pStable->schema[i].bytes;
-  }
-  if (nLen > TSDB_MAX_BYTES_PER_ROW) {
-    mError("msg:%p, app:%p stable:%s, change column, name:%s exceed max row bytes", pMsg, pMsg->rpcMsg.ahandle,
-           pStable->info.tableId, name);
-    return TSDB_CODE_MND_EXCEED_MAX_ROW_BYTES;
-  }
-
-  // update
-  SSchema *schema = (SSchema *) (pStable->schema + col);
-  ASSERT(schema->type == TSDB_DATA_TYPE_BINARY || schema->type == TSDB_DATA_TYPE_NCHAR);
-
-  if (pAlter->schema[0].bytes <= schema->bytes) {
-    mError("msg:%p, app:%p stable:%s, modify column len. column:%s, len from %d to %d", pMsg, pMsg->rpcMsg.ahandle,
-           pStable->info.tableId, name, schema->bytes, pAlter->schema[0].bytes);
-    return TSDB_CODE_MND_INVALID_COLUMN_LENGTH;
-  }
-
-  schema->bytes = pAlter->schema[0].bytes;
-  pStable->sversion++;
-  mInfo("msg:%p, app:%p stable %s, start to modify column %s len to %d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-         name, schema->bytes);
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsSuperTableSdb,
-    .pObj   = pStable,
-    .pMsg   = pMsg,
-    .fpRsp  = mnodeChangeSuperTableColumnCb
-  };
-
-  return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeChangeSuperTableTag(SMnodeMsg *pMsg) {
-  SAlterTableMsg *pAlter = pMsg->rpcMsg.pCont;
-  char* name = pAlter->schema[0].name;
-  SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  int32_t col = mnodeFindSuperTableTagIndex(pStable, name);
-  if (col < 0) {
-    mError("msg:%p, app:%p stable:%s, change column, name:%s", pMsg, pMsg->rpcMsg.ahandle,
-           pStable->info.tableId, name);
-    return TSDB_CODE_MND_FIELD_NOT_EXIST;
-  }
-
-  // update
-  SSchema *schema = (SSchema *) (pStable->schema + col + pStable->numOfColumns);
-  ASSERT(schema->type == TSDB_DATA_TYPE_BINARY || schema->type == TSDB_DATA_TYPE_NCHAR);
-  if (pAlter->schema[0].bytes <= schema->bytes) {
-    mError("msg:%p, app:%p stable:%s, modify tag len. tag:%s, len from %d to %d", pMsg, pMsg->rpcMsg.ahandle,
-           pStable->info.tableId, name, schema->bytes, pAlter->schema[0].bytes);
-    return TSDB_CODE_MND_INVALID_TAG_LENGTH;
-  }
-
-  schema->bytes = pAlter->schema[0].bytes;
-  pStable->tversion++;
-  mInfo("msg:%p, app:%p stable %s, start to modify tag len %s to %d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-         name, schema->bytes);
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsSuperTableSdb,
-    .pObj   = pStable,
-    .pMsg   = pMsg,
-    .fpRsp  = mnodeChangeSuperTableColumnCb
-  };
-
-  return sdbUpdateRow(&row);
-}
-
-// show super tables
-static int32_t mnodeGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SDbObj *pDb = mnodeGetDb(pShow->db);
-  if (pDb == NULL) return TSDB_CODE_MND_DB_NOT_SELECTED;
-
-  if (pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
-    mnodeDecDbRef(pDb);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-  int32_t cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  SSchema* tbnameSchema = tGetTbnameColumnSchema();
-  pShow->bytes[cols] = tbnameSchema->bytes;
-  pSchema[cols].type = tbnameSchema->type;
-  strcpy(pSchema[cols].name, "name");
-  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] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "columns");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "tags");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "tables");
-  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 = pDb->numOfSuperTables;
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  mnodeDecDbRef(pDb);
-  return 0;
-}
-
-// retrieve super tables
-int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  int32_t         numOfRows = 0;
-  char *          pWrite;
-  int32_t         cols = 0;
-  SSTableObj *pTable = NULL;
-  char            prefix[64] = {0};
-  int32_t         prefixLen;
-
-  SDbObj *pDb = mnodeGetDb(pShow->db);
-  if (pDb == NULL) return 0;
-
-  if (pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
-    mnodeDecDbRef(pDb);
-    return 0;
-  }
-
-  tstrncpy(prefix, pDb->name, 64);
-  strcat(prefix, TS_PATH_DELIMITER);
-  prefixLen = (int32_t)strlen(prefix);
-
-  SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
-  char stableName[TSDB_TABLE_NAME_LEN] = {0};
-
-  char* pattern = mnodeGetTableShowPattern(pShow);
-  if (pShow->payloadLen > 0 && pattern == NULL) {
-    return 0;
-  }
-
-  while (numOfRows < rows) {
-    pShow->pIter = mnodeGetNextSuperTable(pShow->pIter, &pTable);
-    if (pTable == NULL) break;
-    if (strncmp(pTable->info.tableId, prefix, prefixLen)) {
-      mnodeDecTableRef(pTable);
-      continue;
-    }
-
-    memset(stableName, 0, tListLen(stableName));
-    mnodeExtractTableName(pTable->info.tableId, stableName);
-
-    if (pShow->payloadLen > 0 && patternMatch(pattern, stableName, sizeof(stableName) - 1, &info) != TSDB_PATTERN_MATCH) {
-      mnodeDecTableRef(pTable);
-      continue;
-    }
-
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
-    int16_t len = (int16_t)strnlen(stableName, TSDB_TABLE_NAME_LEN - 1);
-    *(int16_t*) pWrite = len;
-    pWrite += sizeof(int16_t); // todo refactor
-
-    strncpy(pWrite, stableName, len);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pTable->createdTime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pTable->numOfColumns;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pTable->numOfTags;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *)pWrite = pTable->numOfTables;
-    cols++;
-
-    numOfRows++;
-    mnodeDecTableRef(pTable);
-  }
-
-  pShow->numOfReads += numOfRows;
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  mnodeDecDbRef(pDb);
-  free(pattern);
-
-  return numOfRows;
-}
-
-void mnodeDropAllSuperTables(SDbObj *pDropDb) {
-  void *  pIter= NULL;
-  int32_t numOfTables = 0;
-  SSTableObj *pTable = NULL;
-
-  char prefix[64] = {0};
-  tstrncpy(prefix, pDropDb->name, 64);
-  strcat(prefix, TS_PATH_DELIMITER);
-  int32_t prefixLen = (int32_t)strlen(prefix);
-
-  mInfo("db:%s, all super tables will be dropped from sdb", pDropDb->name);
-
-  while (1) {
-    pIter = mnodeGetNextSuperTable(pIter, &pTable);
-    if (pTable == NULL) break;
-
-    if (strncmp(prefix, pTable->info.tableId, prefixLen) == 0) {
-      SSdbRow row = {
-        .type   = SDB_OPER_LOCAL,
-        .pTable = tsSuperTableSdb,
-        .pObj   = pTable,
-      };
-      sdbDeleteRow(&row);
-      numOfTables ++;
-    }
-
-    mnodeDecTableRef(pTable);
-  }
-
-  mInfo("db:%s, all super tables:%d is dropped from sdb", pDropDb->name, numOfTables);
-}
-
-static int32_t mnodeSetSchemaFromSuperTable(SSchema *pSchema, SSTableObj *pTable) {
-  int32_t numOfCols = pTable->numOfColumns + pTable->numOfTags;
-  assert(numOfCols <= TSDB_MAX_COLUMNS);
-
-  for (int32_t i = 0; i < numOfCols; ++i) {
-    tstrncpy(pSchema->name, pTable->schema[i].name, sizeof(pSchema->name));
-    pSchema->type  = pTable->schema[i].type;
-    pSchema->bytes = htons(pTable->schema[i].bytes);
-    pSchema->colId = htons(pTable->schema[i].colId);
-    pSchema++;
-  }
-
-  return (pTable->numOfColumns + pTable->numOfTags) * sizeof(SSchema);
-}
-
-static int32_t mnodeDoGetSuperTableMeta(SMnodeMsg *pMsg, STableMetaMsg* pMeta) {
-  SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
-
-  pMeta->uid          = htobe64(pTable->uid);
-  pMeta->sversion     = htons(pTable->sversion);
-  pMeta->tversion     = htons(pTable->tversion);
-  pMeta->precision    = pMsg->pDb->cfg.precision;
-  pMeta->numOfTags    = (uint8_t)pTable->numOfTags;
-  pMeta->numOfColumns = htons((int16_t)pTable->numOfColumns);
-  pMeta->tableType    = pTable->info.type;
-  pMeta->contLen      = sizeof(STableMetaMsg) + mnodeSetSchemaFromSuperTable(pMeta->schema, pTable);
-  tstrncpy(pMeta->tableFname, pTable->info.tableId, sizeof(pMeta->tableFname));
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) {
-  SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
-  STableMetaMsg *pMeta   = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16));
-  if (pMeta == NULL) {
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-
-  mnodeDoGetSuperTableMeta(pMsg, pMeta);
-
-  pMsg->rpcRsp.len = pMeta->contLen;
-  pMeta->contLen = htons(pMeta->contLen);
-
-  pMsg->rpcRsp.rsp = pMeta;
-
-  mDebug("msg:%p, app:%p stable:%s, uid:%" PRIu64 " table meta is retrieved, sizeOfVgList:%d numOfTables:%d", pMsg,
-         pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->uid, taosHashGetSize(pTable->vgHash), pTable->numOfTables);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t doGetVgroupInfoLength(char* name) {
-  SSTableObj *pTable = mnodeGetSuperTable(name);
-  int32_t len = 0;
-  if (pTable != NULL && pTable->vgHash != NULL) {
-    len = (taosHashGetSize(pTable->vgHash) * sizeof(SVgroupMsg) + sizeof(SVgroupsMsg));
-  }
-
-  mnodeDecTableRef(pTable);
-  return len;
-}
-
-static int32_t getVgroupInfoLength(SSTableVgroupMsg* pInfo, int32_t numOfTable) {
-  int32_t contLen = sizeof(SSTableVgroupRspMsg) + 32 * sizeof(SVgroupMsg) + sizeof(SVgroupsMsg);
-  for (int32_t i = 0; i < numOfTable; ++i) {
-    char *stableName = (char *)pInfo + sizeof(SSTableVgroupMsg) + (TSDB_TABLE_FNAME_LEN)*i;
-    contLen += doGetVgroupInfoLength(stableName);
-  }
-
-  return contLen;
-}
-
-static char* serializeVgroupInfo(SSTableObj *pTable, char* name, char* msg, SMnodeMsg* pMsgBody, void* handle) {
-  strncpy(msg, name, TSDB_TABLE_FNAME_LEN);
-  msg += TSDB_TABLE_FNAME_LEN;
-
-  if (pTable->vgHash == NULL) {
-    mDebug("msg:%p, app:%p stable:%s, no vgroup exist while get stable vgroup info", pMsgBody, handle, name);
-    mnodeDecTableRef(pTable);
-
-    // even this super table has no corresponding table, still return
-    SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
-    pVgroupMsg->numOfVgroups = 0;
-
-    msg += sizeof(SVgroupsMsg);
-  } else {
-    SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
-    mDebug("msg:%p, app:%p stable:%s, hash:%p sizeOfVgList:%d will be returned", pMsgBody, handle,
-           pTable->info.tableId, pTable->vgHash, taosHashGetSize(pTable->vgHash));
-
-    int32_t *pVgId = taosHashIterate(pTable->vgHash, NULL);
-    int32_t  vgSize = 0;
-    while (pVgId) {
-      SVgObj *pVgroup = mnodeGetVgroup(*pVgId);
-      pVgId = taosHashIterate(pTable->vgHash, pVgId);
-      if (pVgroup == NULL) {
-        continue;
-      }
-
-      pVgroupMsg->vgroups[vgSize].vgId = htonl(pVgroup->vgId);
-      pVgroupMsg->vgroups[vgSize].numOfEps = 0;
-
-      for (int32_t vn = 0; vn < pVgroup->numOfVnodes; ++vn) {
-        SDnodeObj *pDnode = pVgroup->vnodeGid[vn].pDnode;
-        if (pDnode == NULL) break;
-
-        tstrncpy(pVgroupMsg->vgroups[vgSize].epAddr[vn].fqdn, pDnode->dnodeFqdn, TSDB_FQDN_LEN);
-        pVgroupMsg->vgroups[vgSize].epAddr[vn].port = htons(pDnode->dnodePort);
-
-        pVgroupMsg->vgroups[vgSize].numOfEps++;
-      }
-
-      vgSize++;
-      mnodeDecVgroupRef(pVgroup);
-    }
-
-    taosHashCancelIterate(pTable->vgHash, pVgId);
-    mnodeDecTableRef(pTable);
-
-    pVgroupMsg->numOfVgroups = htonl(vgSize);
-
-    // one table is done, try the next table
-    msg += sizeof(SVgroupsMsg) + vgSize * sizeof(SVgroupMsg);
-  }
-
-  return msg;
-}
-
-static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
-  SSTableVgroupMsg *pInfo = pMsg->rpcMsg.pCont;
-  int32_t numOfTable = htonl(pInfo->numOfTables);
-
-  // calculate the required space.
-  int32_t contLen = getVgroupInfoLength(pInfo, numOfTable);
-  SSTableVgroupRspMsg *pRsp = rpcMallocCont(contLen);
-  if (pRsp == NULL) {
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-
-  pRsp->numOfTables = 0;
-  char *msg = (char *)pRsp + sizeof(SSTableVgroupRspMsg);
-
-  for (int32_t i = 0; i < numOfTable; ++i) {
-    char *stableName = (char *)pInfo + sizeof(SSTableVgroupMsg) + (TSDB_TABLE_FNAME_LEN)*i;
-
-    SSTableObj *pTable = mnodeGetSuperTable(stableName);
-    if (pTable == NULL) {
-      mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, stableName);
-      mnodeDecTableRef(pTable);
-      continue;
-    }
-
-    msg = serializeVgroupInfo(pTable, stableName, msg, pMsg, pMsg->rpcMsg.ahandle);
-    pRsp->numOfTables++;
-  }
-
-  if (pRsp->numOfTables != numOfTable) {
-    rpcFreeCont(pRsp);
-    return TSDB_CODE_MND_INVALID_TABLE_NAME;
-  } else {
-    pRsp->numOfTables = (int32_t)htonl(pRsp->numOfTables);
-    pMsg->rpcRsp.rsp = pRsp;
-    pMsg->rpcRsp.len = (int32_t)((char *)msg - (char *)pRsp);
-
-    return TSDB_CODE_SUCCESS;
-  }
-}
-
-static void mnodeProcessDropSuperTableRsp(SRpcMsg *rpcMsg) {
-  mInfo("drop stable rsp received, result:%s", tstrerror(rpcMsg->code));
-}
-
-static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pCreateMsg, SCTableObj *pTable) {
-  SCreateTableMsg* pMsg = (SCreateTableMsg*) ((char*)pCreateMsg + sizeof(SCMCreateTableMsg));
-
-  char* tagData = NULL;
-
-  int32_t tagDataLen = 0;
-  int32_t totalCols = 0;
-  int32_t contLen = 0;
-  if (pTable->info.type == TSDB_CHILD_TABLE) {
-    totalCols = pTable->superTable->numOfColumns + pTable->superTable->numOfTags;
-    contLen = sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema) + pTable->sqlLen;
-    if (pMsg != NULL) {
-      int32_t nameLen = htonl(*(int32_t*)pMsg->schema);
-      char* p = pMsg->schema + nameLen + sizeof(int32_t);
-
-      tagDataLen = htonl(*(int32_t*) p);
-      contLen += tagDataLen;
-
-      tagData = p + sizeof(int32_t);
-    }
-  } else {
-    totalCols = pTable->numOfColumns;
-    contLen = sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema) + pTable->sqlLen;
-  }
-
-  SMDCreateTableMsg *pCreate = rpcMallocCont(contLen);
-  if (pCreate == NULL) {
-    terrno = TSDB_CODE_MND_OUT_OF_MEMORY;
-    return NULL;
-  }
-
-  mnodeExtractTableName(pTable->info.tableId, pCreate->tableFname);
-  pCreate->contLen       = htonl(contLen);
-  pCreate->vgId          = htonl(pTable->vgId);
-  pCreate->tableType     = pTable->info.type;
-  pCreate->createdTime   = htobe64(pTable->createdTime);
-  pCreate->tid           = htonl(pTable->tid);
-  pCreate->sqlDataLen    = htonl(pTable->sqlLen);
-  pCreate->uid           = htobe64(pTable->uid);
-
-  if (pTable->info.type == TSDB_CHILD_TABLE) {
-    mnodeExtractTableName(pTable->superTable->info.tableId, pCreate->stableFname);
-    pCreate->numOfColumns  = htons(pTable->superTable->numOfColumns);
-    pCreate->numOfTags     = htons(pTable->superTable->numOfTags);
-    pCreate->sversion      = htonl(pTable->superTable->sversion);
-    pCreate->tversion      = htonl(pTable->superTable->tversion);
-    pCreate->tagDataLen    = htonl(tagDataLen);
-    pCreate->superTableUid = htobe64(pTable->superTable->uid);
-  } else {
-    pCreate->numOfColumns  = htons(pTable->numOfColumns);
-    pCreate->numOfTags     = 0;
-    pCreate->sversion      = htonl(pTable->sversion);
-    pCreate->tversion      = 0;
-    pCreate->tagDataLen    = 0;
-    pCreate->superTableUid = 0;
-  }
-
-  SSchema *pSchema = (SSchema *) pCreate->data;
-  if (pTable->info.type == TSDB_CHILD_TABLE) {
-    memcpy(pSchema, pTable->superTable->schema, totalCols * sizeof(SSchema));
-  } else {
-    memcpy(pSchema, pTable->schema, totalCols * sizeof(SSchema));
-  }
-  for (int32_t col = 0; col < totalCols; ++col) {
-    pSchema->bytes = htons(pSchema->bytes);
-    pSchema->colId = htons(pSchema->colId);
-    pSchema++;
-  }
-
-  if (pTable->info.type == TSDB_CHILD_TABLE && pMsg != NULL) {
-    memcpy(pCreate->data + totalCols * sizeof(SSchema), tagData, tagDataLen);
-  }
-
-  if (pTable->info.type == TSDB_STREAM_TABLE) {
-    memcpy(pCreate->data + totalCols * sizeof(SSchema), pTable->sql, pTable->sqlLen);
-  }
-
-  return pCreate;
-}
-
-static int32_t mnodeDoCreateChildTableFp(SMnodeMsg *pMsg) {
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  assert(pTable);
-
-  mDebug("msg:%p, app:%p table:%s, created in mnode, vgId:%d sid:%d, uid:%" PRIu64, pMsg, pMsg->rpcMsg.ahandle,
-         pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid);
-
-  SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
-  SMDCreateTableMsg *pMDCreate = mnodeBuildCreateChildTableMsg(pCreate, pTable);
-  if (pMDCreate == NULL) {
-    return terrno;
-  }
-
-  SRpcEpSet epSet = mnodeGetEpSetFromVgroup(pMsg->pVgroup);
-  SRpcMsg rpcMsg = {
-      .ahandle = pMsg,
-      .pCont   = pMDCreate,
-      .contLen = htonl(pMDCreate->contLen),
-      .code    = 0,
-      .msgType = TSDB_MSG_TYPE_MD_CREATE_TABLE
-  };
-
-  dnodeSendMsgToDnode(&epSet, &rpcMsg);
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-static int32_t mnodeDoCreateChildTableCb(SMnodeMsg *pMsg, int32_t code) {
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-
-  SCreateTableMsg *pCreate = (SCreateTableMsg*) ((char*)pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
-  assert(pTable);
-
-  if (code == TSDB_CODE_SUCCESS) {
-    if (pCreate->getMeta) {
-      mDebug("msg:%p, app:%p table:%s, created in dnode and continue to get meta, thandle:%p", pMsg,
-             pMsg->rpcMsg.ahandle, pTable->info.tableId, pMsg->rpcMsg.handle);
-
-      pMsg->retry = 0;
-      dnodeReprocessMWriteMsg(pMsg);
-    } else {
-      mDebug("msg:%p, app:%p table:%s, created in dnode, thandle:%p", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
-             pMsg->rpcMsg.handle);
-
-      if (pMsg->pBatchMasterMsg) {
-        ++pMsg->pBatchMasterMsg->successed;
-        if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received >= pMsg->pBatchMasterMsg->expected) {
-          dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, code);
-        }
-
-        mnodeDestroySubMsg(pMsg);
-
-        return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-      }
-
-      dnodeSendRpcMWriteRsp(pMsg, TSDB_CODE_SUCCESS);
-    }
-    return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-  } else {
-    mError("msg:%p, app:%p table:%s, failed to create table sid:%d, uid:%" PRIu64 ", reason:%s", pMsg,
-           pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->tid, pTable->uid, tstrerror(code));
-    SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pTable, .pTable = tsChildTableSdb};
-    sdbDeleteRow(&desc);
-
-    if (pMsg->pBatchMasterMsg) {
-      ++pMsg->pBatchMasterMsg->received;
-      pMsg->pBatchMasterMsg->code = code;
-      if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received >= pMsg->pBatchMasterMsg->expected) {
-        dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, code);
-      }
-
-      mnodeDestroySubMsg(pMsg);
-
-      return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-    }
-
-    return code;
-  }
-}
-
-static int32_t mnodeDoCreateChildTable(SMnodeMsg *pMsg, int32_t tid) {
-  SVgObj *pVgroup = pMsg->pVgroup;
-
-  SCMCreateTableMsg *p1 = pMsg->rpcMsg.pCont;
-  SCreateTableMsg   *pCreate = (SCreateTableMsg*)((char*)p1 + sizeof(SCMCreateTableMsg));
-
-  SCTableObj *pTable = calloc(1, sizeof(SCTableObj));
-  if (pTable == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to alloc memory", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-
-  pTable->info.type    = (pCreate->numOfColumns == 0)? TSDB_CHILD_TABLE:TSDB_NORMAL_TABLE;
-  pTable->info.tableId = strdup(pCreate->tableName);
-  pTable->createdTime  = taosGetTimestampMs();
-  pTable->tid          = tid;
-  pTable->vgId         = pVgroup->vgId;
-
-  if (pTable->info.type == TSDB_CHILD_TABLE) {
-    int32_t nameLen = htonl(*(int32_t*) pCreate->schema);
-    char* name = (char*)pCreate->schema + sizeof(int32_t);
-
-    char stableName[TSDB_TABLE_FNAME_LEN] = {0};
-    memcpy(stableName, name, nameLen);
-
-    char prefix[64] = {0};
-    size_t prefixLen = tableIdPrefix(pMsg->pDb->name, prefix, 64);
-    if (0 != strncasecmp(prefix, stableName, prefixLen)) {
-      mError("msg:%p, app:%p table:%s, corresponding super table:%s not in this db", pMsg, pMsg->rpcMsg.ahandle,
-             pCreate->tableName, stableName);
-      mnodeDestroyChildTable(pTable);
-      return TSDB_CODE_TDB_INVALID_CREATE_TB_MSG;
-    }
-
-    if (pMsg->pSTable == NULL) pMsg->pSTable = mnodeGetSuperTable(stableName);
-    if (pMsg->pSTable == NULL) {
-      mError("msg:%p, app:%p table:%s, corresponding super table:%s does not exist", pMsg, pMsg->rpcMsg.ahandle,
-             pCreate->tableName, stableName);
-      mnodeDestroyChildTable(pTable);
-      return TSDB_CODE_MND_INVALID_TABLE_NAME;
-    }
-
-    pTable->suid = pMsg->pSTable->uid;
-    pTable->uid  = mnodeCreateTableUid(pTable->vgId, pTable->tid);
-    pTable->superTable = pMsg->pSTable;
-  } else {
-    if (pTable->info.type == TSDB_SUPER_TABLE) {
-      pTable->uid = mnodeCreateSuperTableUid();
-    } else {
-      pTable->uid = mnodeCreateTableUid(pTable->vgId, pTable->tid);
-    }
-
-    pTable->sversion     = 0;
-    pTable->numOfColumns = htons(pCreate->numOfColumns);
-    pTable->sqlLen       = htons(pCreate->sqlLen);
-
-    int32_t numOfCols  = pTable->numOfColumns;
-    int32_t schemaSize = numOfCols * sizeof(SSchema);
-    pTable->schema     = (SSchema *) calloc(1, schemaSize);
-    if (pTable->schema == NULL) {
-      free(pTable);
-      return TSDB_CODE_MND_OUT_OF_MEMORY;
-    }
-    memcpy(pTable->schema, pCreate->schema, numOfCols * sizeof(SSchema));
-
-    pTable->nextColId = 0;
-    for (int32_t col = 0; col < numOfCols; col++) {
-      SSchema *tschema   = pTable->schema;
-      tschema[col].colId = pTable->nextColId++;
-      tschema[col].bytes = htons(tschema[col].bytes);
-    }
-
-    if (pTable->sqlLen != 0) {
-      pTable->info.type = TSDB_STREAM_TABLE;
-      pTable->sql = calloc(1, pTable->sqlLen);
-      if (pTable->sql == NULL) {
-        free(pTable);
-        return TSDB_CODE_MND_OUT_OF_MEMORY;
-      }
-      memcpy(pTable->sql, (char *) (pCreate->schema) + numOfCols * sizeof(SSchema), pTable->sqlLen);
-      pTable->sql[pTable->sqlLen - 1] = 0;
-      mDebug("msg:%p, app:%p table:%s, stream sql len:%d sql:%s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
-             pTable->sqlLen, pTable->sql);
-    }
-  }
-
-  pMsg->pTable = (STableObj *)pTable;
-  mnodeIncTableRef(pMsg->pTable);
-
-  SSdbRow desc = {
-    .type   = SDB_OPER_GLOBAL,
-    .pObj   = pTable,
-    .pTable = tsChildTableSdb,
-    .pMsg   = pMsg,
-    .fpReq  = mnodeDoCreateChildTableFp
-  };
-
-  int32_t code = sdbInsertRow(&desc);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mnodeDestroyChildTable(pTable);
-    pMsg->pTable = NULL;
-    mError("msg:%p, app:%p table:%s, failed to create, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName,
-           tstrerror(code));
-  } else {
-    mDebug("msg:%p, app:%p table:%s, allocated in vgroup, vgId:%d sid:%d uid:%" PRIu64, pMsg, pMsg->rpcMsg.ahandle,
-           pTable->info.tableId, pVgroup->vgId, pTable->tid, pTable->uid);
-  }
-
-  return code;
-}
-
-static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) {
-  //SCMCreateTableMsg* p1 = pMsg->rpcMsg.pCont; // there are several tables here.
-  SCreateTableMsg* pCreate = (SCreateTableMsg*)((char *)pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
-
-  int32_t code = grantCheck(TSDB_GRANT_TIMESERIES);
-  if (code != TSDB_CODE_SUCCESS) {
-    mError("msg:%p, app:%p table:%s, failed to create, grant timeseries failed", pMsg, pMsg->rpcMsg.ahandle,
-           pCreate->tableName);
-    return code;
-  }
-
-  if (pMsg->retry == 0) {
-    if (pMsg->pTable == NULL) {
-      SVgObj *pVgroup = NULL;
-      int32_t tid = 0;
-      code = mnodeGetAvailableVgroup(pMsg, &pVgroup, &tid);
-      if (code != TSDB_CODE_SUCCESS) {
-        mDebug("msg:%p, app:%p table:%s, failed to get available vgroup, reason:%s", pMsg, pMsg->rpcMsg.ahandle,
-               pCreate->tableName, tstrerror(code));
-        return code;
-      }
-
-      if (pMsg->pVgroup != NULL) {
-        mnodeDecVgroupRef(pMsg->pVgroup);
-      }
-
-      pMsg->pVgroup = pVgroup;
-      mnodeIncVgroupRef(pVgroup);
-
-      return mnodeDoCreateChildTable(pMsg, tid);
-    }
-  } else {
-    if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pCreate->tableName);
-  }
-
-  if (pMsg->pTable == NULL) {
-    mError("msg:%p, app:%p table:%s, object not found, retry:%d reason:%s", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName, pMsg->retry,
-           tstrerror(terrno));
-    return terrno;
-  } else {
-    mDebug("msg:%p, app:%p table:%s, send create msg to vnode again", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
-    return mnodeDoCreateChildTableFp(pMsg);
-  }
-}
-
-static int32_t mnodeSendDropChildTableMsg(SMnodeMsg *pMsg, bool needReturn) {
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  mLInfo("msg:%p, app:%p ctable:%s, is dropped from sdb", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
-
-  SMDDropTableMsg *pDrop = rpcMallocCont(sizeof(SMDDropTableMsg));
-  if (pDrop == NULL) {
-    mError("msg:%p, app:%p ctable:%s, failed to drop ctable, no enough memory", pMsg, pMsg->rpcMsg.ahandle,
-           pTable->info.tableId);
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-
-  tstrncpy(pDrop->tableFname, pTable->info.tableId, TSDB_TABLE_FNAME_LEN);
-  pDrop->vgId    = htonl(pTable->vgId);
-  pDrop->contLen = htonl(sizeof(SMDDropTableMsg));
-  pDrop->tid     = htonl(pTable->tid);
-  pDrop->uid     = htobe64(pTable->uid);
-
-  SRpcEpSet epSet = mnodeGetEpSetFromVgroup(pMsg->pVgroup);
-
-  mInfo("msg:%p, app:%p ctable:%s, send drop ctable msg, vgId:%d sid:%d uid:%" PRIu64, pMsg, pMsg->rpcMsg.ahandle,
-        pDrop->tableFname, pTable->vgId, pTable->tid, pTable->uid);
-
-  SRpcMsg rpcMsg = {
-    .ahandle = pMsg,
-    .pCont   = pDrop,
-    .contLen = sizeof(SMDDropTableMsg),
-    .code    = 0,
-    .msgType = TSDB_MSG_TYPE_MD_DROP_TABLE
-  };
-
-  if (!needReturn) rpcMsg.ahandle = NULL;
-
-  dnodeSendMsgToDnode(&epSet, &rpcMsg);
-
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-static int32_t mnodeDropChildTableCb(SMnodeMsg *pMsg, int32_t code) {
-  if (code != TSDB_CODE_SUCCESS) {
-    SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-    mError("msg:%p, app:%p ctable:%s, failed to drop, sdb error", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
-    return code;
-  }
-
-  return mnodeSendDropChildTableMsg(pMsg, true);
-}
-
-static int32_t mnodeProcessDropChildTableMsg(SMnodeMsg *pMsg) {
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  if (pMsg->pVgroup == NULL) pMsg->pVgroup = mnodeGetVgroup(pTable->vgId);
-  if (pMsg->pVgroup == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to drop ctable, vgroup not exist", pMsg, pMsg->rpcMsg.ahandle,
-           pTable->info.tableId);
-    return TSDB_CODE_MND_APP_ERROR;
-  }
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsChildTableSdb,
-    .pObj   = pTable,
-    .pMsg   = pMsg,
-    .fpRsp  = mnodeDropChildTableCb
-  };
-
-  int32_t code = sdbDeleteRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("msg:%p, app:%p ctable:%s, failed to drop, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
-           tstrerror(code));
-  }
-
-  return code;
-}
-
-static int32_t mnodeFindNormalTableColumnIndex(SCTableObj *pTable, char *colName) {
-  SSchema *schema = (SSchema *) pTable->schema;
-  for (int32_t col = 0; col < pTable->numOfColumns; col++) {
-    if (strcasecmp(schema[col].name, colName) == 0) {
-      return col;
-    }
-  }
-
-  return -1;
-}
-
-static int32_t mnodeAlterNormalTableColumnCb(SMnodeMsg *pMsg, int32_t code) {
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  if (code != TSDB_CODE_SUCCESS) {
-    mError("msg:%p, app:%p ctable %s, failed to alter column, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
-           tstrerror(code));
-    return code;
-  }
-
-  SMDCreateTableMsg *pMDCreate = mnodeBuildCreateChildTableMsg(NULL, pTable);
-  if (pMDCreate == NULL) {
-    return terrno;
-  }
-
-  if (pMsg->pVgroup == NULL) {
-    pMsg->pVgroup = mnodeGetVgroup(pTable->vgId);
-    if (pMsg->pVgroup == NULL) {
-      rpcFreeCont(pMDCreate);
-      mError("msg:%p, app:%p ctable %s, vgId:%d not exist in mnode", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
-             pTable->vgId);
-      return TSDB_CODE_MND_VGROUP_NOT_EXIST;
-    }
-  }
-
-  SRpcEpSet epSet = mnodeGetEpSetFromVgroup(pMsg->pVgroup);
-  SRpcMsg rpcMsg = {
-      .ahandle = pMsg,
-      .pCont   = pMDCreate,
-      .contLen = htonl(pMDCreate->contLen),
-      .code    = 0,
-      .msgType = TSDB_MSG_TYPE_MD_ALTER_TABLE
-  };
-
-  mDebug("msg:%p, app:%p ctable %s, send alter column msg to vgId:%d", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
-         pMsg->pVgroup->vgId);
-
-  dnodeSendMsgToDnode(&epSet, &rpcMsg);
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-static int32_t mnodeAddNormalTableColumn(SMnodeMsg *pMsg, SSchema schema[], int32_t ncols) {
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  SDbObj *pDb = pMsg->pDb;
-  if (ncols <= 0) {
-    mError("msg:%p, app:%p ctable:%s, add column, ncols:%d <= 0", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId, ncols);
-    return TSDB_CODE_MND_APP_ERROR;
-  }
-
-  for (int32_t i = 0; i < ncols; i++) {
-    if (mnodeFindNormalTableColumnIndex(pTable, schema[i].name) > 0) {
-      mError("msg:%p, app:%p ctable:%s, add column, column:%s already exist", pMsg, pMsg->rpcMsg.ahandle,
-             pTable->info.tableId, schema[i].name);
-      return TSDB_CODE_MND_FIELD_ALREAY_EXIST;
-    }
-  }
-
-  int32_t schemaSize = pTable->numOfColumns * sizeof(SSchema);
-  pTable->schema = realloc(pTable->schema, schemaSize + sizeof(SSchema) * ncols);
-
-  memcpy(pTable->schema + pTable->numOfColumns, schema, sizeof(SSchema) * ncols);
-
-  SSchema *tschema = (SSchema *) (pTable->schema + pTable->numOfColumns);
-  for (int32_t i = 0; i < ncols; i++) {
-    tschema[i].colId = pTable->nextColId++;
-  }
-
-  pTable->numOfColumns += ncols;
-  pTable->sversion++;
-
-  SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
-  if (pAcct != NULL) {
-    pAcct->acctInfo.numOfTimeSeries += ncols;
-    mnodeDecAcctRef(pAcct);
-  }
-
-  mInfo("msg:%p, app:%p ctable %s, start to add column", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsChildTableSdb,
-    .pObj   = pTable,
-    .pMsg   = pMsg,
-    .fpRsp  = mnodeAlterNormalTableColumnCb
-  };
-
-  return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeDropNormalTableColumn(SMnodeMsg *pMsg, char *colName) {
-  SDbObj *pDb = pMsg->pDb;
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  int32_t col = mnodeFindNormalTableColumnIndex(pTable, colName);
-  if (col <= 0) {
-    mError("msg:%p, app:%p ctable:%s, drop column, column:%s not exist", pMsg, pMsg->rpcMsg.ahandle,
-           pTable->info.tableId, colName);
-    return TSDB_CODE_MND_FIELD_NOT_EXIST;
-  }
-
-  memmove(pTable->schema + col, pTable->schema + col + 1, sizeof(SSchema) * (pTable->numOfColumns - col - 1));
-  pTable->numOfColumns--;
-  pTable->sversion++;
-
-  SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
-  if (pAcct != NULL) {
-    pAcct->acctInfo.numOfTimeSeries--;
-    mnodeDecAcctRef(pAcct);
-  }
-
-  mInfo("msg:%p, app:%p ctable %s, start to drop column %s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId, colName);
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsChildTableSdb,
-    .pObj   = pTable,
-    .pMsg   = pMsg,
-    .fpRsp  = mnodeAlterNormalTableColumnCb
-  };
-
-  return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeChangeNormalTableColumn(SMnodeMsg *pMsg) {
-  SAlterTableMsg *pAlter = pMsg->rpcMsg.pCont;
-  char* name = pAlter->schema[0].name;
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  int32_t col = mnodeFindNormalTableColumnIndex(pTable, name);
-  if (col < 0) {
-    mError("msg:%p, app:%p ctable:%s, change column, name: %s", pMsg, pMsg->rpcMsg.ahandle,
-           pTable->info.tableId, name);
-    return TSDB_CODE_MND_FIELD_NOT_EXIST;
-  }
-
-  SSchema *schema = (SSchema *) (pTable->schema + col);
-  ASSERT(schema->type == TSDB_DATA_TYPE_BINARY || schema->type == TSDB_DATA_TYPE_NCHAR);
-  schema->bytes = pAlter->schema[0].bytes;
-
-  mInfo("msg:%p, app:%p ctable %s, start to modify column %s len to %d", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
-         name, schema->bytes);
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsChildTableSdb,
-    .pObj   = pTable,
-    .pMsg   = pMsg,
-    .fpRsp  = mnodeAlterNormalTableColumnCb
-  };
-
-  return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeSetSchemaFromNormalTable(SSchema *pSchema, SCTableObj *pTable) {
-  int32_t numOfCols = pTable->numOfColumns;
-  for (int32_t i = 0; i < numOfCols; ++i) {
-    strcpy(pSchema->name, pTable->schema[i].name);
-    pSchema->type  = pTable->schema[i].type;
-    pSchema->bytes = htons(pTable->schema[i].bytes);
-    pSchema->colId = htons(pTable->schema[i].colId);
-    pSchema++;
-  }
-
-  return numOfCols * sizeof(SSchema);
-}
-
-static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) {
-  SDbObj *pDb = pMsg->pDb;
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-
-  pMeta->uid       = htobe64(pTable->uid);
-  pMeta->tid       = htonl(pTable->tid);
-  pMeta->precision = pDb->cfg.precision;
-  pMeta->tableType = pTable->info.type;
-  tstrncpy(pMeta->tableFname, pTable->info.tableId, TSDB_TABLE_FNAME_LEN);
-
-  if (pTable->info.type == TSDB_CHILD_TABLE) {
-    assert(pTable->superTable != NULL);
-    tstrncpy(pMeta->sTableName, pTable->superTable->info.tableId, TSDB_TABLE_FNAME_LEN);
-
-    pMeta->suid         = pTable->superTable->uid;
-    pMeta->sversion     = htons(pTable->superTable->sversion);
-    pMeta->tversion     = htons(pTable->superTable->tversion);
-    pMeta->numOfTags    = (int8_t)pTable->superTable->numOfTags;
-    pMeta->numOfColumns = htons((int16_t)pTable->superTable->numOfColumns);
-    pMeta->contLen      = sizeof(STableMetaMsg) + mnodeSetSchemaFromSuperTable(pMeta->schema, pTable->superTable);
-  } else {
-    pMeta->sversion     = htons(pTable->sversion);
-    pMeta->tversion     = 0;
-    pMeta->numOfTags    = 0;
-    pMeta->numOfColumns = htons((int16_t)pTable->numOfColumns);
-    pMeta->contLen      = sizeof(STableMetaMsg) + mnodeSetSchemaFromNormalTable(pMeta->schema, pTable);
-  }
-
-  if (pMsg->pVgroup == NULL) pMsg->pVgroup = mnodeGetVgroup(pTable->vgId);
-  if (pMsg->pVgroup == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to get table meta, vgroup not exist", pMsg, pMsg->rpcMsg.ahandle,
-           pTable->info.tableId);
-    return TSDB_CODE_MND_VGROUP_NOT_EXIST;
-  }
-
-  for (int32_t i = 0; i < pMsg->pVgroup->numOfVnodes; ++i) {
-    SDnodeObj *pDnode = mnodeGetDnode(pMsg->pVgroup->vnodeGid[i].dnodeId);
-    if (pDnode == NULL) break;
-    strcpy(pMeta->vgroup.epAddr[i].fqdn, pDnode->dnodeFqdn);
-    pMeta->vgroup.epAddr[i].port = htons(pDnode->dnodePort + TSDB_PORT_DNODESHELL);
-    pMeta->vgroup.numOfEps++;
-    mnodeDecDnodeRef(pDnode);
-  }
-
-  pMeta->vgroup.vgId = htonl(pMsg->pVgroup->vgId);
-  mDebug("msg:%p, app:%p table:%s, uid:%" PRIu64 " table meta is retrieved, vgId:%d tid:%d", pMsg, pMsg->rpcMsg.ahandle,
-         pTable->info.tableId, pTable->uid, pTable->vgId, pTable->tid);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg) {
-  STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
-
-  if (pMsg->rpcMsg.contLen <= sizeof(*pInfo)) {
-    mError("msg:%p, app:%p table:%s, failed to auto create child table, tags not exist", pMsg, pMsg->rpcMsg.ahandle,
-           pInfo->tableFname);
-    return TSDB_CODE_MND_TAG_NOT_EXIST;
-  }
-
-  char* p = pInfo->tags;
-  int32_t nameLen = htonl(*(int32_t*) p);
-  p += sizeof(int32_t);
-  p += nameLen;
-
-  int32_t tagLen = htonl(*(int32_t*) p);
-  p += sizeof(int32_t);
-
-  int32_t totalLen = nameLen + tagLen + sizeof(int32_t)*2;
-  if (tagLen == 0 || nameLen == 0) {
-    mError("msg:%p, app:%p table:%s, failed to create table on demand for super table is empty, tagLen:%d", pMsg,
-           pMsg->rpcMsg.ahandle, pInfo->tableFname, tagLen);
-    return TSDB_CODE_MND_INVALID_STABLE_NAME;
-  }
-
-  int32_t contLen = sizeof(SCMCreateTableMsg) + sizeof(SCreateTableMsg) + totalLen;
-  SCMCreateTableMsg *pCreateMsg = calloc(1, contLen);
-  if (pCreateMsg == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to create table while get meta info, no enough memory", pMsg,
-           pMsg->rpcMsg.ahandle, pInfo->tableFname);
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-
-  SCreateTableMsg* pCreate = (SCreateTableMsg*) ((char*) pCreateMsg + sizeof(SCMCreateTableMsg));
-
-  size_t size = tListLen(pInfo->tableFname);
-  tstrncpy(pCreate->tableName, pInfo->tableFname, size);
-  pCreate->igExists = 1;
-  pCreate->getMeta = 1;
-
-  pCreateMsg->numOfTables = htonl(1);
-  pCreateMsg->contLen = htonl(contLen);
-
-  memcpy(pCreate->schema, pInfo->tags, totalLen);
-
-  char name[TSDB_TABLE_FNAME_LEN] = {0};
-  memcpy(name, pInfo->tags + sizeof(int32_t), nameLen);
-
-  mDebug("msg:%p, app:%p table:%s, start to create on demand, tagLen:%d stable:%s", pMsg, pMsg->rpcMsg.ahandle,
-         pInfo->tableFname, tagLen, name);
-
-  if (pMsg->rpcMsg.pCont != pMsg->pCont) {
-    tfree(pMsg->rpcMsg.pCont);
-  }
-  pMsg->rpcMsg.msgType = TSDB_MSG_TYPE_CM_CREATE_TABLE;
-  pMsg->rpcMsg.pCont = pCreateMsg;
-  pMsg->rpcMsg.contLen = contLen;
-
-  return TSDB_CODE_MND_ACTION_NEED_REPROCESSED;
-}
-
-static int32_t mnodeGetChildTableMeta(SMnodeMsg *pMsg) {
-  STableMetaMsg *pMeta =
-      rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16));
-  if (pMeta == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to get table meta, no enough memory", pMsg, pMsg->rpcMsg.ahandle,
-           pMsg->pTable->tableId);
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
-
-  mnodeDoGetChildTableMeta(pMsg, pMeta);
-
-  pMsg->rpcRsp.len = pMeta->contLen;
-  pMsg->rpcRsp.rsp = pMeta;
-  pMeta->contLen = htons(pMeta->contLen);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-void mnodeDropAllChildTablesInVgroups(SVgObj *pVgroup) {
-  void *  pIter = NULL;
-  int32_t numOfTables = 0;
-  SCTableObj *pTable = NULL;
-
-  mInfo("vgId:%d, all child tables will be dropped from sdb", pVgroup->vgId);
-
-  while (1) {
-    pIter = mnodeGetNextChildTable(pIter, &pTable);
-    if (pTable == NULL) break;
-
-    if (pTable->vgId == pVgroup->vgId) {
-      SSdbRow row = {
-        .type   = SDB_OPER_LOCAL,
-        .pTable = tsChildTableSdb,
-        .pObj   = pTable,
-      };
-      sdbDeleteRow(&row);
-      numOfTables++;
-    }
-    mnodeDecTableRef(pTable);
-  }
-
-  mInfo("vgId:%d, all child tables is dropped from sdb", pVgroup->vgId);
-}
-
-void mnodeDropAllChildTables(SDbObj *pDropDb) {
-  void *  pIter = NULL;
-  int32_t numOfTables = 0;
-  SCTableObj *pTable = NULL;
-
-  char prefix[64] = {0};
-  tstrncpy(prefix, pDropDb->name, 64);
-  strcat(prefix, TS_PATH_DELIMITER);
-  int32_t prefixLen = (int32_t)strlen(prefix);
-
-  mInfo("db:%s, all child tables will be dropped from sdb", pDropDb->name);
-
-  while (1) {
-    pIter = mnodeGetNextChildTable(pIter, &pTable);
-    if (pTable == NULL) break;
-
-    if (strncmp(prefix, pTable->info.tableId, prefixLen) == 0) {
-      SSdbRow row = {
-        .type   = SDB_OPER_LOCAL,
-        .pTable = tsChildTableSdb,
-        .pObj   = pTable,
-      };
-      sdbDeleteRow(&row);
-      numOfTables++;
-    }
-    mnodeDecTableRef(pTable);
-  }
-
-  mInfo("db:%s, all child tables:%d is dropped from sdb", pDropDb->name, numOfTables);
-}
-
-static void mnodeDropAllChildTablesInStable(SSTableObj *pStable) {
-  void *  pIter = NULL;
-  int32_t numOfTables = 0;
-  SCTableObj *pTable = NULL;
-
-  mInfo("stable:%s uid:%" PRIu64 ", all child tables:%d will be dropped from sdb", pStable->info.tableId, pStable->uid,
-        pStable->numOfTables);
-
-  while (1) {
-    pIter = mnodeGetNextChildTable(pIter, &pTable);
-    if (pTable == NULL) break;
-
-    if (pTable->superTable == pStable) {
-      SSdbRow row = {
-        .type   = SDB_OPER_LOCAL,
-        .pTable = tsChildTableSdb,
-        .pObj   = pTable,
-      };
-      sdbDeleteRow(&row);
-      numOfTables++;
-    }
-
-    mnodeDecTableRef(pTable);
-  }
-
-  mInfo("stable:%s, all child tables:%d is dropped from sdb", pStable->info.tableId, numOfTables);
-}
-
-#if 0
-static SCTableObj* mnodeGetTableByPos(int32_t vnode, int32_t tid) {
-  SVgObj *pVgroup = mnodeGetVgroup(vnode);
-  if (pVgroup == NULL) return NULL;
-
-  SCTableObj *pTable = pVgroup->tableList[tid - 1];
-  mnodeIncTableRef((STableObj *)pTable);
-
-  mnodeDecVgroupRef(pVgroup);
-  return pTable;
-}
-#endif
-
-static int32_t mnodeProcessTableCfgMsg(SMnodeMsg *pMsg) {
-  return TSDB_CODE_COM_OPS_NOT_SUPPORT;
-#if 0
-  SConfigTableMsg *pCfg = pMsg->rpcMsg.pCont;
-  pCfg->dnodeId = htonl(pCfg->dnodeId);
-  pCfg->vgId = htonl(pCfg->vgId);
-  pCfg->sid = htonl(pCfg->sid);
-  mDebug("msg:%p, app:%p dnode:%d, vgId:%d sid:%d, receive table config msg", pMsg, pMsg->rpcMsg.ahandle, pCfg->dnodeId,
-         pCfg->vgId, pCfg->sid);
-
-  SCTableObj *pTable = mnodeGetTableByPos(pCfg->vgId, pCfg->sid);
-  if (pTable == NULL) {
-    mError("msg:%p, app:%p dnode:%d, vgId:%d sid:%d, table not found", pMsg, pMsg->rpcMsg.ahandle, pCfg->dnodeId,
-           pCfg->vgId, pCfg->sid);
-    return TSDB_CODE_MND_INVALID_TABLE_ID;
-  }
-
-  SMDCreateTableMsg *pCreate = NULL;
-  pCreate = mnodeBuildCreateChildTableMsg(NULL, (SCTableObj *)pTable);
-  mnodeDecTableRef(pTable);
-
-  if (pCreate == NULL) return terrno;
-
-  pMsg->rpcRsp.rsp = pCreate;
-  pMsg->rpcRsp.len = htonl(pCreate->contLen);
-  return TSDB_CODE_SUCCESS;
-#endif
-}
-
-// handle drop child response
-static void mnodeProcessDropChildTableRsp(SRpcMsg *rpcMsg) {
-  if (rpcMsg->ahandle == NULL) return;
-
-  SMnodeMsg *pMsg = rpcMsg->ahandle;
-  pMsg->received++;
-
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  assert(pTable);
-
-  mInfo("msg:%p, app:%p table:%s, drop table rsp received, vgId:%d sid:%d uid:%" PRIu64 ", thandle:%p result:%s", pMsg,
-        pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid, pMsg->rpcMsg.handle,
-        tstrerror(rpcMsg->code));
-
-  if (rpcMsg->code != TSDB_CODE_SUCCESS) {
-    mError("msg:%p, app:%p table:%s, failed to drop in dnode, vgId:%d sid:%d uid:%" PRIu64 ", reason:%s", pMsg,
-           pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid, tstrerror(rpcMsg->code));
-    dnodeSendRpcMWriteRsp(pMsg, rpcMsg->code);
-    return;
-  }
-
-  if (pMsg->pVgroup == NULL) pMsg->pVgroup = mnodeGetVgroup(pTable->vgId);
-  if (pMsg->pVgroup == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to get vgroup", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
-    dnodeSendRpcMWriteRsp(pMsg, TSDB_CODE_MND_VGROUP_NOT_EXIST);
-    return;
-  }
-
-  if (pMsg->pVgroup->numOfTables <= 0) {
-    mInfo("msg:%p, app:%p vgId:%d, all tables is dropped, drop vgroup", pMsg, pMsg->rpcMsg.ahandle,
-          pMsg->pVgroup->vgId);
-    mnodeDropVgroup(pMsg->pVgroup, NULL);
-  }
-
-  dnodeSendRpcMWriteRsp(pMsg, TSDB_CODE_SUCCESS);
-}
-
-/*
- * handle create table response from dnode
- *   if failed, drop the table cached
- */
-static void mnodeProcessCreateChildTableRsp(SRpcMsg *rpcMsg) {
-  if (rpcMsg->ahandle == NULL) return;
-
-  SMnodeMsg *pMsg = rpcMsg->ahandle;
-  pMsg->received++;
-
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  assert(pTable);
-
-  // If the table is deleted by another thread during creation, stop creating and send drop msg to vnode
-  if (sdbCheckRowDeleted(tsChildTableSdb, pTable)) {
-    mDebug("msg:%p, app:%p table:%s, create table rsp received, but a deleting opertion incoming, vgId:%d sid:%d uid:%" PRIu64,
-           pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid);
-
-    // if the vgroup is already dropped from hash, it can't be accquired by pTable->vgId
-    // so the refCount of vgroup can not be decreased
-    // SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId);
-    // if (pVgroup == NULL) {
-    //   mnodeRemoveTableFromVgroup(pMsg->pVgroup, pTable);
-    // }
-    // mnodeDecVgroupRef(pVgroup);
-
-    mnodeSendDropChildTableMsg(pMsg, false);
-    rpcMsg->code = TSDB_CODE_SUCCESS;
-
-    if (pMsg->pBatchMasterMsg) {
-      ++pMsg->pBatchMasterMsg->successed;
-      if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received >= pMsg->pBatchMasterMsg->expected) {
-        dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, rpcMsg->code);
-      }
-
-      mnodeDestroySubMsg(pMsg);
-
-      return;
-    }
-
-    dnodeSendRpcMWriteRsp(pMsg, rpcMsg->code);
-    return;
-  }
-
-  if (rpcMsg->code == TSDB_CODE_SUCCESS || rpcMsg->code == TSDB_CODE_TDB_TABLE_ALREADY_EXIST) {
-     SSdbRow desc = {
-      .type   = SDB_OPER_GLOBAL,
-      .pObj   = pTable,
-      .pTable = tsChildTableSdb,
-      .pMsg   = pMsg,
-      .fpRsp  = mnodeDoCreateChildTableCb
-    };
-
-    int32_t code = sdbInsertRowToQueue(&desc);
-    if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-      pMsg->pTable = NULL;
-      mnodeDestroyChildTable(pTable);
-
-      if (pMsg->pBatchMasterMsg) {
-	++pMsg->pBatchMasterMsg->received;
-	pMsg->pBatchMasterMsg->code = code;
-	if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received
-	    >= pMsg->pBatchMasterMsg->expected) {
-	  dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, code);
-	}
-
-	mnodeDestroySubMsg(pMsg);
-
-	return;
-      }
-
-      dnodeSendRpcMWriteRsp(pMsg, code);
-    }
-  } else {
-    pMsg->retry++;
-    int32_t sec = taosGetTimestampSec();
-    if (pMsg->retry < CREATE_CTABLE_RETRY_TIMES && ABS(sec - pMsg->incomingTs) < CREATE_CTABLE_RETRY_SEC) {
-      mDebug("msg:%p, app:%p table:%s, create table rsp received, need retry, times:%d vgId:%d sid:%d uid:%" PRIu64
-             " result:%s thandle:%p",
-             pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId, pMsg->retry, pTable->vgId, pTable->tid, pTable->uid,
-             tstrerror(rpcMsg->code), pMsg->rpcMsg.handle);
-
-      dnodeDelayReprocessMWriteMsg(pMsg);
-    } else {
-      mError("msg:%p, app:%p table:%s, failed to create in dnode, vgId:%d sid:%d uid:%" PRIu64
-             ", result:%s thandle:%p incomingTs:%d curTs:%d retryTimes:%d",
-             pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid,
-             tstrerror(rpcMsg->code), pMsg->rpcMsg.handle, pMsg->incomingTs, sec, pMsg->retry);
-
-      SSdbRow row = {.type = SDB_OPER_GLOBAL, .pTable = tsChildTableSdb, .pObj = pTable};
-      sdbDeleteRow(&row);
-
-      if (rpcMsg->code == TSDB_CODE_APP_NOT_READY) {
-        //Avoid retry again in client
-        rpcMsg->code = TSDB_CODE_MND_VGROUP_NOT_READY;
-      }
-
-      if (pMsg->pBatchMasterMsg) {
-	++pMsg->pBatchMasterMsg->received;
-	pMsg->pBatchMasterMsg->code = rpcMsg->code;
-	if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received
-	    >= pMsg->pBatchMasterMsg->expected) {
-	  dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, rpcMsg->code);
-	}
-
-	mnodeDestroySubMsg(pMsg);
-
-	return;
-      }
-
-      dnodeSendRpcMWriteRsp(pMsg, rpcMsg->code);
-    }
-  }
-}
-
-static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg) {
-  if (rpcMsg->ahandle == NULL) return;
-
-  SMnodeMsg *pMsg = rpcMsg->ahandle;
-  pMsg->received++;
-
-  SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  assert(pTable);
-
-  if (rpcMsg->code == TSDB_CODE_SUCCESS || rpcMsg->code == TSDB_CODE_TDB_TABLE_ALREADY_EXIST) {
-    mDebug("msg:%p, app:%p ctable:%s, altered in dnode, thandle:%p result:%s", pMsg, pMsg->rpcMsg.ahandle,
-           pTable->info.tableId, pMsg->rpcMsg.handle, tstrerror(rpcMsg->code));
-
-    dnodeSendRpcMWriteRsp(pMsg, TSDB_CODE_SUCCESS);
-  } else {
-    if (pMsg->retry++ < ALTER_CTABLE_RETRY_TIMES) {
-      mDebug("msg:%p, app:%p table:%s, alter table rsp received, need retry, times:%d result:%s thandle:%p",
-             pMsg->rpcMsg.ahandle, pMsg, pTable->info.tableId, pMsg->retry, tstrerror(rpcMsg->code),
-             pMsg->rpcMsg.handle);
-
-      dnodeDelayReprocessMWriteMsg(pMsg);
-    } else {
-      mError("msg:%p, app:%p table:%s, failed to alter in dnode, result:%s thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
-             pTable->info.tableId, tstrerror(rpcMsg->code), pMsg->rpcMsg.handle);
-      dnodeSendRpcMWriteRsp(pMsg, rpcMsg->code);
-    }
-  }
-}
-
-static SMultiTableMeta* ensureMsgBufferSpace(SMultiTableMeta *pMultiMeta, SArray* pList, int32_t* totalMallocLen, int32_t numOfVgroupList) {
-  int32_t len = 0;
-  for (int32_t i = 0; i < numOfVgroupList; ++i) {
-    char *name = taosArrayGetP(pList, i);
-    len += doGetVgroupInfoLength(name);
-  }
-
-  if (len + pMultiMeta->contLen > (*totalMallocLen)) {
-    while (len + pMultiMeta->contLen > (*totalMallocLen)) {
-      (*totalMallocLen) *= 2;
-    }
-
-    SMultiTableMeta* pMultiMeta1 = realloc(pMultiMeta, *totalMallocLen);
-    if (pMultiMeta1 == NULL) {
-      return NULL;
-    }
-    pMultiMeta = pMultiMeta1;
-  }
-
-  return pMultiMeta;
-}
-
-static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
-  SMultiTableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
-
-  pInfo->numOfTables  = htonl(pInfo->numOfTables);
-  pInfo->numOfVgroups = htonl(pInfo->numOfVgroups);
-  pInfo->numOfUdfs    = htonl(pInfo->numOfUdfs);
-
-  int32_t contLen = pMsg->rpcMsg.contLen - sizeof(SMultiTableInfoMsg);
-
-  int32_t num      = 0;
-  int32_t code     = TSDB_CODE_SUCCESS;
-  char*   str      = strndup(pInfo->tableNames, contLen);
-  char**  nameList = strsplit(str, ",", &num);
-  SArray* pList    = taosArrayInit(4, POINTER_BYTES);
-
-  SMultiTableMeta *pMultiMeta = NULL;
-  if (num != pInfo->numOfTables + pInfo->numOfVgroups + pInfo->numOfUdfs) {
-    mError("msg:%p, app:%p, failed to get multi-tableMeta, msg inconsistent", pMsg, pMsg->rpcMsg.ahandle);
-    code = TSDB_CODE_MND_INVALID_TABLE_NAME;
-    goto _end;
-  }
-
-  // first malloc 80KB, subsequent reallocation will expand the size as twice of the original size
-  int32_t totalMallocLen = sizeof(SMultiTableMeta) + sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16);
-  pMultiMeta = calloc(1, totalMallocLen);
-  if (pMultiMeta == NULL) {
-    code = TSDB_CODE_MND_OUT_OF_MEMORY;
-    goto _end;
-  }
-
-  pMultiMeta->contLen = sizeof(SMultiTableMeta);
-  pMultiMeta->numOfTables = 0;
-
-  int32_t t = 0;
-  for (; t < pInfo->numOfTables; ++t) {
-    char *fullName = nameList[t];
-
-    pMsg->pTable = mnodeGetTable(fullName);
-    if (pMsg->pTable == NULL) {
-      mError("msg:%p, app:%p table:%s, failed to get table meta, table not exist", pMsg, pMsg->rpcMsg.ahandle, fullName);
-      code = TSDB_CODE_MND_INVALID_TABLE_NAME;
-      goto _end;
-    }
-
-    if (pMsg->pDb == NULL) {
-      pMsg->pDb = mnodeGetDbByTableName(fullName);
-    }
-
-    if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-      mnodeDecTableRef(pMsg->pTable);
-      code = TSDB_CODE_APP_NOT_READY;
-      goto _end;
-    }
-
-    int remain = totalMallocLen - pMultiMeta->contLen;
-    if (remain <= sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16)) {
-      totalMallocLen *= 2;
-      pMultiMeta = realloc(pMultiMeta, totalMallocLen);
-      if (pMultiMeta == NULL) {
-        mnodeDecTableRef(pMsg->pTable);
-        code = TSDB_CODE_MND_OUT_OF_MEMORY;
-        goto _end;
-      }
-    }
-
-    STableMetaMsg *pMeta = (STableMetaMsg *)((char*) pMultiMeta + pMultiMeta->contLen);
-
-    if (pMsg->pTable->type == TSDB_SUPER_TABLE) {
-      code = mnodeDoGetSuperTableMeta(pMsg, pMeta);
-      taosArrayPush(pList, &fullName);  // keep the full name for each super table for retrieve vgroup list
-    } else {
-      code = mnodeDoGetChildTableMeta(pMsg, pMeta);
-      if (pMsg->pVgroup != NULL) {
-        mnodeDecVgroupRef(pMsg->pVgroup);
-        pMsg->pVgroup = NULL;
-      }
-    }
-
-    mnodeDecTableRef(pMsg->pTable);
-    pMsg->pTable = NULL;
-
-    if (code == TSDB_CODE_SUCCESS) {
-      pMultiMeta->numOfTables++;
-      pMultiMeta->contLen += pMeta->contLen;
-    } else {
-      // ignore error and continue.
-      // Otherwise the client may found that the responding message is inconsistent.
-//      goto _end;
-    }
-  }
-
-  int32_t tableNum = pInfo->numOfTables + pInfo->numOfVgroups;
-
-  // add the additional super table names that needs the vgroup info
-  for(;t < tableNum; ++t) {
-    taosArrayPush(pList, &nameList[t]);
-  }
-
-  // add the pVgroupList into the pList
-  int32_t numOfVgroupList = (int32_t) taosArrayGetSize(pList);
-  pMultiMeta->numOfVgroup = htonl(numOfVgroupList);
-
-  pMultiMeta = ensureMsgBufferSpace(pMultiMeta, pList, &totalMallocLen, numOfVgroupList);
-  if (pMultiMeta == NULL) {
-    code = TSDB_CODE_MND_OUT_OF_MEMORY;
-    goto _end;
-  }
-
-  char* msg = (char*) pMultiMeta + pMultiMeta->contLen;
-  for(int32_t i = 0; i < numOfVgroupList; ++i) {
-    char* name = taosArrayGetP(pList, i);
-
-    SSTableObj *pTable = mnodeGetSuperTable(name);
-    if (pTable == NULL) {
-      mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, name);
-      code = TSDB_CODE_MND_INVALID_TABLE_NAME;
-      goto _end;
-    }
-
-    msg = serializeVgroupInfo(pTable, name, msg, pMsg, pMsg->rpcMsg.ahandle);
-  }
-
-  pMultiMeta->contLen = (int32_t) (msg - (char*) pMultiMeta);
-
-  pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
-
-  // add the user-defined-function information
-  for(int32_t i = 0; i < pInfo->numOfUdfs; ++i, ++t) {
-    char buf[TSDB_FUNC_NAME_LEN] = {0};
-    strcpy(buf, nameList[t]);
-
-    SFuncObj* pFuncObj = mnodeGetFunc(buf);
-    if (pFuncObj == NULL) {
-      mError("function %s does not exist", buf);
-      code = TSDB_CODE_MND_INVALID_FUNC;
-      goto _end;
-    }
-
-    SFunctionInfoMsg* pFuncInfo = (SFunctionInfoMsg*) msg;
-
-    strcpy(pFuncInfo->name, buf);
-    pFuncInfo->len = htonl(pFuncObj->contLen);
-    memcpy(pFuncInfo->content, pFuncObj->cont, pFuncObj->contLen);
-
-    pFuncInfo->funcType = htonl(pFuncObj->funcType);
-    pFuncInfo->resType  = pFuncObj->resType;
-    pFuncInfo->resBytes = htons(pFuncObj->resBytes);
-    pFuncInfo->bufSize  = htonl(pFuncObj->bufSize);
-
-    msg += sizeof(SFunctionInfoMsg) + pFuncObj->contLen;
-  }
-
-  pMultiMeta->contLen  = (int32_t) (msg - (char*) pMultiMeta);
-  pMultiMeta->numOfUdf = htonl(pInfo->numOfUdfs);
-
-  pMsg->rpcRsp.rsp = pMultiMeta;
-  pMsg->rpcRsp.len = pMultiMeta->contLen;
-  code = TSDB_CODE_SUCCESS;
-
-  char* tmp = rpcMallocCont(pMultiMeta->contLen + 2);
-  if (tmp == NULL) {
-    code = TSDB_CODE_MND_OUT_OF_MEMORY;
-    goto _end;
-  }
-
-  int32_t dataLen = (int32_t)pMultiMeta->contLen - sizeof(SMultiTableMeta);
-  int32_t len = tsCompressString(pMultiMeta->meta, dataLen, 1, tmp + sizeof(SMultiTableMeta), (int32_t)dataLen + 2,
-                                 ONE_STAGE_COMP, NULL, 0);
-
-  pMultiMeta->metaClone = pInfo->metaClone;
-  pMultiMeta->rawLen = pMultiMeta->contLen;
-  if (len == -1 || len >= dataLen + 2) { // compress failed, do not compress this binary data
-    pMultiMeta->compressed = 0;
-    memcpy(tmp, pMultiMeta, sizeof(SMultiTableMeta) + pMultiMeta->contLen);
-  } else {
-    pMultiMeta->compressed = 1;
-    pMultiMeta->contLen = sizeof(SMultiTableMeta) + len;
-
-    // copy the header and the compressed payload
-    memcpy(tmp, pMultiMeta, sizeof(SMultiTableMeta));
-  }
-
-  pMsg->rpcRsp.rsp = tmp;
-  pMsg->rpcRsp.len = pMultiMeta->contLen;
-
-  SMultiTableMeta* p = (SMultiTableMeta*) tmp;
-
-  mDebug("multiTable info build completed, original:%d, compressed:%d, comp:%d", p->rawLen, p->contLen, p->compressed);
-
-  _end:
-  tfree(str);
-  tfree(nameList);
-  taosArrayDestroy(pList);
-  pMsg->pTable  = NULL;
-  pMsg->pVgroup = NULL;
-  tfree(pMultiMeta);
-
-  return code;
-}
-
-static int32_t mnodeGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SDbObj *pDb = mnodeGetDb(pShow->db);
-  if (pDb == NULL) return TSDB_CODE_MND_DB_NOT_SELECTED;
-
-  if (pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
-    mnodeDecDbRef(pDb);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-  int32_t cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  SSchema* s = tGetTbnameColumnSchema();
-  pShow->bytes[cols] = s->bytes;
-  pSchema[cols].type = s->type;
-  strcpy(pSchema[cols].name, "table_name");
-  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] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "columns");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  SSchema* tbCol = tGetTbnameColumnSchema();
-  pShow->bytes[cols] = tbCol->bytes + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = tbCol->type;
-  strcpy(pSchema[cols].name, "stable_name");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8; // table uid
-  pSchema[cols].type = TSDB_DATA_TYPE_BIGINT;
-  strcpy(pSchema[cols].name, "uid");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "tid");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "vgId");
-  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 = pDb->numOfTables;
-  pShow->rowSize   = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  mnodeDecDbRef(pDb);
-  return 0;
-}
-
-static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  SDbObj *pDb = mnodeGetDb(pShow->db);
-  if (pDb == NULL) return 0;
-
-  if (pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
-    mnodeDecDbRef(pDb);
-    return 0;
-  }
-
-  int32_t cols       = 0;
-  int32_t numOfRows  = 0;
-  SCTableObj *pTable = NULL;
-  SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
-
-  char prefix[64] = {0};
-  int32_t prefixLen = (int32_t)tableIdPrefix(pDb->name, prefix, 64);
-
-  char* pattern = mnodeGetTableShowPattern(pShow);
-  if (pShow->payloadLen > 0 && pattern == NULL) {
-    return 0;
-  }
-
-  while (numOfRows < rows) {
-    pShow->pIter = mnodeGetNextChildTable(pShow->pIter, &pTable);
-    if (pTable == NULL) break;
-
-    // not belong to current db
-    if (strncmp(pTable->info.tableId, prefix, prefixLen)) {
-      mnodeDecTableRef(pTable);
-      continue;
-    }
-
-    char tableName[TSDB_TABLE_NAME_LEN] = {0};
-
-    // pattern compare for table name
-    mnodeExtractTableName(pTable->info.tableId, tableName);
-
-    if (pattern != NULL && patternMatch(pattern, tableName, sizeof(tableName) - 1, &info) != TSDB_PATTERN_MATCH) {
-      mnodeDecTableRef(pTable);
-      continue;
-    }
-
-    cols = 0;
-    char *pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, tableName, pShow->bytes[cols]);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *) pWrite = pTable->createdTime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    if (pTable->info.type == TSDB_CHILD_TABLE) {
-      *(int16_t *)pWrite = pTable->superTable->numOfColumns;
-    } else {
-      *(int16_t *)pWrite = pTable->numOfColumns;
-    }
-
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
-    memset(tableName, 0, sizeof(tableName));
-    if (pTable->info.type == TSDB_CHILD_TABLE) {
-      mnodeExtractTableName(pTable->superTable->info.tableId, tableName);
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, tableName, pShow->bytes[cols]);
-    }
-
-    cols++;
-
-    // uid
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t*) pWrite = pTable->uid;
-    cols++;
-
-
-    // tid
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t*) pWrite = pTable->tid;
-    cols++;
-
-    //vgid
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t*) pWrite = pTable->vgId;
-    cols++;
-
-    numOfRows++;
-    mnodeDecTableRef(pTable);
-  }
-
-  pShow->numOfReads += numOfRows;
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  mnodeDecDbRef(pDb);
-  free(pattern);
-
-  return numOfRows;
-}
-
-static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg) {
-  SAlterTableMsg *pAlter = pMsg->rpcMsg.pCont;
-  mDebug("msg:%p, app:%p table:%s, alter table msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
-         pAlter->tableFname, pMsg->rpcMsg.handle);
-
-  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableName(pAlter->tableFname);
-  if (pMsg->pDb == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to alter table, db not selected", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname);
-    return TSDB_CODE_MND_DB_NOT_SELECTED;
-  }
-
-  if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-#if 0
-  if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) {
-    mError("msg:%p, app:%p table:%s, failed to alter table, its log db", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname);
-    return TSDB_CODE_MND_MONITOR_DB_FORBIDDEN;
-  }
-#endif
-
-  if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pAlter->tableFname);
-  if (pMsg->pTable == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to alter table, table not exist", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname);
-    return TSDB_CODE_MND_INVALID_TABLE_NAME;
-  }
-
-  pAlter->type = htons(pAlter->type);
-  pAlter->numOfCols = htons(pAlter->numOfCols);
-  pAlter->tagValLen = htonl(pAlter->tagValLen);
-
-  if (pAlter->numOfCols > 2) {
-    mError("msg:%p, app:%p table:%s, error numOfCols:%d in alter table", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname,
-           pAlter->numOfCols);
-    return TSDB_CODE_MND_APP_ERROR;
-  }
-
-  for (int32_t i = 0; i < pAlter->numOfCols; ++i) {
-    pAlter->schema[i].bytes = htons(pAlter->schema[i].bytes);
-  }
-
-  int32_t code = TSDB_CODE_COM_OPS_NOT_SUPPORT;
-  if (pMsg->pTable->type == TSDB_SUPER_TABLE) {
-    mDebug("msg:%p, app:%p table:%s, start to alter stable", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname);
-    if (pAlter->type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN) {
-      code = mnodeAddSuperTableTag(pMsg, pAlter->schema, 1);
-    } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_TAG_COLUMN) {
-      code = mnodeDropSuperTableTag(pMsg, pAlter->schema[0].name);
-    } else if (pAlter->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN) {
-      code = mnodeModifySuperTableTagName(pMsg, pAlter->schema[0].name, pAlter->schema[1].name);
-    } else if (pAlter->type == TSDB_ALTER_TABLE_ADD_COLUMN) {
-      code = mnodeAddSuperTableColumn(pMsg, pAlter->schema, 1);
-    } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_COLUMN) {
-      code = mnodeDropSuperTableColumn(pMsg, pAlter->schema[0].name);
-    } else if (pAlter->type == TSDB_ALTER_TABLE_CHANGE_COLUMN) {
-      code = mnodeChangeSuperTableColumn(pMsg);
-    } else if (pAlter->type == TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN) {
-      code = mnodeChangeSuperTableTag(pMsg);
-    } else {
-    }
-  } else {
-    mDebug("msg:%p, app:%p table:%s, start to alter ctable", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname);
-    if (pAlter->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) {
-      return TSDB_CODE_COM_OPS_NOT_SUPPORT;
-    } else if (pAlter->type == TSDB_ALTER_TABLE_ADD_COLUMN) {
-      code = mnodeAddNormalTableColumn(pMsg, pAlter->schema, 1);
-    } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_COLUMN) {
-      code = mnodeDropNormalTableColumn(pMsg, pAlter->schema[0].name);
-    } else if (pAlter->type == TSDB_ALTER_TABLE_CHANGE_COLUMN) {
-      code = mnodeChangeNormalTableColumn(pMsg);
-    } else {
-    }
-  }
-
- return code;
-}
-
-static int32_t mnodeGetStreamTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SDbObj *pDb = mnodeGetDb(pShow->db);
-  if (pDb == NULL) return TSDB_CODE_MND_DB_NOT_SELECTED;
-
-  if (pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
-    mnodeDecDbRef(pDb);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-  int32_t cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  SSchema* tbnameColSchema = tGetTbnameColumnSchema();
-  pShow->bytes[cols] = tbnameColSchema->bytes;
-  pSchema[cols].type = tbnameColSchema->type;
-  strcpy(pSchema[cols].name, "table_name");
-  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] = 2;
-  pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "columns");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_MAX_SQL_SHOW_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "sql");
-  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 = pDb->numOfTables;
-  pShow->rowSize   = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  mnodeDecDbRef(pDb);
-  return 0;
-}
-
-static int32_t mnodeRetrieveStreamTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  SDbObj *pDb = mnodeGetDb(pShow->db);
-  if (pDb == NULL) return 0;
-
-  if (pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
-    mnodeDecDbRef(pDb);
-    return 0;
-  }
-
-  int32_t numOfRows  = 0;
-  SCTableObj *pTable = NULL;
-  SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
-
-  char prefix[64] = {0};
-  tstrncpy(prefix, pDb->name, 64);
-  strcat(prefix, TS_PATH_DELIMITER);
-  int32_t prefixLen = (int32_t)strlen(prefix);
-
-  char* pattern = mnodeGetTableShowPattern(pShow);
-  if (pShow->payloadLen > 0 && pattern == NULL) {
-    return 0;
-  }
-
-  while (numOfRows < rows) {
-    pShow->pIter = mnodeGetNextChildTable(pShow->pIter, &pTable);
-    if (pTable == NULL) break;
-
-    // not belong to current db
-    if (strncmp(pTable->info.tableId, prefix, prefixLen) || pTable->info.type != TSDB_STREAM_TABLE) {
-      mnodeDecTableRef(pTable);
-      continue;
-    }
-
-    char tableName[TSDB_TABLE_NAME_LEN] = {0};
-
-    // pattern compare for table name
-    mnodeExtractTableName(pTable->info.tableId, tableName);
-
-    if (pShow->payloadLen > 0 && patternMatch(pattern, tableName, sizeof(tableName) - 1, &info) != TSDB_PATTERN_MATCH) {
-      mnodeDecTableRef(pTable);
-      continue;
-    }
-
-    int32_t cols = 0;
-
-    char *pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, tableName, pShow->bytes[cols]);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *) pWrite = pTable->createdTime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pTable->numOfColumns;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pTable->sql, pShow->bytes[cols]);    
-    cols++;
-
-    numOfRows++;
-    mnodeDecTableRef(pTable);
-  }
-
-  pShow->numOfReads += numOfRows;
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  mnodeDecDbRef(pDb);
-  free(pattern);
-
-  return numOfRows;
-}
-
-static int32_t mnodeCompactSuperTables() {
-  void *pIter = NULL;
-  SSTableObj *pTable = NULL;
-
-  mInfo("start to compact super table...");
-
-  while (1) {
-    pIter = mnodeGetNextSuperTable(pIter, &pTable);
-    if (pTable == NULL) break;
-
-    int32_t schemaSize = (pTable->numOfColumns + pTable->numOfTags) * sizeof(SSchema);
-    SSdbRow row = {
-      .type    = SDB_OPER_GLOBAL,
-      .pTable  = tsSuperTableSdb,
-      .pObj    = pTable,
-      .rowSize = sizeof(SSTableObj) + schemaSize,
-    };
-
-    //mInfo("compact super %" PRIu64, pTable->uid);
-    
-    sdbInsertCompactRow(&row);
-  }
-
-  mInfo("end to compact super table...");
-
-  return 0; 
-}
-
-static int32_t mnodeCompactChildTables() {
-  void *pIter = NULL;
-  SCTableObj *pTable = NULL;
-
-  mInfo("start to compact child table...");
-
-  while (1) {
-    pIter = mnodeGetNextChildTable(pIter, &pTable);
-    if (pTable == NULL) break;
-
-    SSdbRow row = {
-      .type   = SDB_OPER_GLOBAL,
-      .pObj   = pTable,
-      .pTable = tsChildTableSdb,
-    };
-
-    //mInfo("compact child %" PRIu64 ":%d", pTable->uid, pTable->tid);
-    
-    sdbInsertCompactRow(&row);
-  }
-
-  mInfo("end to compact child table...");
-
-  return 0; 
-}
-
-int32_t mnodeCompactTables() {
-  mnodeCompactSuperTables();
-
-  mnodeCompactChildTables();
-
-  return 0;
-}

src/mnode/src/mnodeUser.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "trpc.h"
-#include "tutil.h"
-#include "tglobal.h"
-#include "tgrant.h"
-#include "tdataformat.h"
-#include "tkey.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeMnode.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeUser.h"
-#include "mnodeWrite.h"
-#include "mnodePeer.h"
-
-int64_t        tsUserRid = -1;
-static void *  tsUserSdb = NULL;
-static int32_t tsUserUpdateSize = 0;
-static int32_t mnodeGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeProcessCreateUserMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessAlterUserMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessAuthMsg(SMnodeMsg *pMsg);
-
-static int32_t mnodeUserActionDestroy(SSdbRow *pRow) {
-  tfree(pRow->pObj);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeUserActionInsert(SSdbRow *pRow) {
-  SUserObj *pUser = pRow->pObj;
-  SAcctObj *pAcct = mnodeGetAcct(pUser->acct);
-
-  if (pAcct != NULL) {
-    mnodeAddUserToAcct(pAcct, pUser);
-    mnodeDecAcctRef(pAcct);
-  } else {
-    mError("user:%s, acct:%s info not exist in sdb", pUser->user, pUser->acct);
-    return TSDB_CODE_MND_INVALID_ACCT;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeUserActionDelete(SSdbRow *pRow) {
-  SUserObj *pUser = pRow->pObj;
-  SAcctObj *pAcct = mnodeGetAcct(pUser->acct);
-
-  if (pAcct != NULL) {
-    mnodeDropUserFromAcct(pAcct, pUser);
-    mnodeDecAcctRef(pAcct);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeUserActionUpdate(SSdbRow *pRow) {
-  SUserObj *pUser = pRow->pObj;
-  SUserObj *pSaved = mnodeGetUser(pUser->user);
-  if (pUser != pSaved) {
-    memcpy(pSaved, pUser, tsUserUpdateSize);
-    free(pUser);
-  }
-  mnodeDecUserRef(pSaved);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeUserActionEncode(SSdbRow *pRow) {
-  SUserObj *pUser = pRow->pObj;
-  memcpy(pRow->rowData, pUser, tsUserUpdateSize);
-  pRow->rowSize = tsUserUpdateSize;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeUserActionDecode(SSdbRow *pRow) {
-  SUserObj *pUser = (SUserObj *)calloc(1, sizeof(SUserObj));
-  if (pUser == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
-  memcpy(pUser, pRow->rowData, tsUserUpdateSize);
-  pRow->pObj = pUser;
-  return TSDB_CODE_SUCCESS;
-}
-
-static void mnodePrintUserAuth() {
-  FILE *fp = fopen("auth.txt", "w");
-  if (!fp) {
-    mDebug("failed to auth.txt for write");
-    return;
-  }
-  
-  void *    pIter = NULL;
-  SUserObj *pUser = NULL;
-
-  while (1) {
-    pIter = mnodeGetNextUser(pIter, &pUser);
-    if (pUser == NULL) break;
-
-    char *base64 = base64_encode((const unsigned char *)pUser->pass, TSDB_KEY_LEN * 2);
-    fprintf(fp, "user:%24s auth:%s\n", pUser->user, base64);
-    free(base64);
-
-    mnodeDecUserRef(pUser);
-  }
-
-  taosFsync(fileno(fp));
-  fclose(fp);
-}
-
-static int32_t mnodeUserActionRestored() {
-  int64_t numOfRows = sdbGetNumOfRows(tsUserSdb);
-  if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
-    mInfo("dnode first deploy, create root user");
-    SAcctObj *pAcct = mnodeGetAcct(TSDB_DEFAULT_USER);
-    mnodeCreateUser(pAcct, TSDB_DEFAULT_USER, TSDB_DEFAULT_PASS, NULL);
-    mnodeCreateUser(pAcct, "monitor", tsInternalPass, NULL);
-    mnodeCreateUser(pAcct, "_"TSDB_DEFAULT_USER, tsInternalPass, NULL);
-    mnodeDecAcctRef(pAcct);
-  }
-
-  if (tsPrintAuth != 0) {
-    mInfo("print user auth, for -A parameter is set");
-    mnodePrintUserAuth();
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitUsers() {
-  SUserObj tObj;
-  tsUserUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
-  SSdbTableDesc desc = {
-    .id           = SDB_TABLE_USER,
-    .name         = "users",
-    .hashSessions = TSDB_DEFAULT_USERS_HASH_SIZE,
-    .maxRowSize   = tsUserUpdateSize,
-    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
-    .keyType      = SDB_KEY_STRING,
-    .fpInsert     = mnodeUserActionInsert,
-    .fpDelete     = mnodeUserActionDelete,
-    .fpUpdate     = mnodeUserActionUpdate,
-    .fpEncode     = mnodeUserActionEncode,
-    .fpDecode     = mnodeUserActionDecode,
-    .fpDestroy    = mnodeUserActionDestroy,
-    .fpRestored   = mnodeUserActionRestored
-  };
-
-  tsUserRid = sdbOpenTable(&desc);
-  tsUserSdb = sdbGetTableByRid(tsUserRid);
-  if (tsUserSdb == NULL) {
-    mError("table:%s, failed to create hash", desc.name);
-    return -1;
-  }
-
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_USER, mnodeProcessCreateUserMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_ALTER_USER, mnodeProcessAlterUserMsg);
-  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_USER, mnodeProcessDropUserMsg);
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_USER, mnodeGetUserMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_USER, mnodeRetrieveUsers);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_USER, mnodeCancelGetNextUser);
-
-  mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_AUTH, mnodeProcessAuthMsg);
-   
-  mDebug("table:%s, hash is created", desc.name);
-  return 0;
-}
-
-void mnodeCleanupUsers() {
-  sdbCloseTable(tsUserRid);
-  tsUserSdb = NULL;
-}
-
-SUserObj *mnodeGetUser(char *name) {
-  return (SUserObj *)sdbGetRow(tsUserSdb, name);
-}
-
-void *mnodeGetNextUser(void *pIter, SUserObj **pUser) { 
-  return sdbFetchRow(tsUserSdb, pIter, (void **)pUser); 
-}
-
-void mnodeCancelGetNextUser(void *pIter) {
- sdbFreeIter(tsUserSdb, pIter);
-}
-
-void mnodeIncUserRef(SUserObj *pUser) { 
-  sdbIncRef(tsUserSdb, pUser); 
-}
-
-void mnodeDecUserRef(SUserObj *pUser) { 
-  sdbDecRef(tsUserSdb, pUser); 
-}
-
-static int32_t mnodeUpdateUser(SUserObj *pUser, void *pMsg) {
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsUserSdb,
-    .pObj   = pUser,
-    .pMsg   = pMsg
-  };
-
-  int32_t code = sdbUpdateRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("user:%s, failed to alter by %s, reason:%s", pUser->user, mnodeGetUserFromMsg(pMsg), tstrerror(code));
-  } else {
-    mLInfo("user:%s, is altered by %s", pUser->user, mnodeGetUserFromMsg(pMsg));
-  }
-
-  return code;
-}
-
-int32_t mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass, void *pMsg) {
-  int32_t code = acctCheck(pAcct, ACCT_GRANT_USER);
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  if (name[0] == 0) {
-    return TSDB_CODE_MND_INVALID_USER_FORMAT;
-  }
-
-  if (pass[0] == 0) {
-    return TSDB_CODE_MND_INVALID_PASS_FORMAT;
-  }
-
-  SUserObj *pUser = mnodeGetUser(name);
-  if (pUser != NULL) {
-    mDebug("user:%s, is already there", name);
-    mnodeDecUserRef(pUser);
-    return TSDB_CODE_MND_USER_ALREADY_EXIST;
-  }
-
-  code = grantCheck(TSDB_GRANT_USER);
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  pUser = calloc(1, sizeof(SUserObj));
-  tstrncpy(pUser->user, name, TSDB_USER_LEN);
-  taosEncryptPass((uint8_t*) pass, strlen(pass), pUser->pass);
-  strcpy(pUser->acct, pAcct->user);
-  pUser->createdTime = taosGetTimestampMs();
-  pUser->superAuth = 0;
-  pUser->writeAuth = 1;
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0 || strcmp(pUser->user, pUser->acct) == 0) {
-    pUser->superAuth = 1;
-  }
-
-  SSdbRow row = {
-    .type     = SDB_OPER_GLOBAL,
-    .pTable   = tsUserSdb,
-    .pObj     = pUser,
-    .rowSize  = sizeof(SUserObj),
-    .pMsg     = pMsg
-  };
-
-  code = sdbInsertRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("user:%s, failed to create by %s, reason:%s", pUser->user, mnodeGetUserFromMsg(pMsg), tstrerror(code));
-    tfree(pUser);
-  } else {
-    mLInfo("user:%s, is created by %s", pUser->user, mnodeGetUserFromMsg(pMsg));
-  }
-
-  return code;
-}
-
-static int32_t mnodeDropUser(SUserObj *pUser, void *pMsg) {
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsUserSdb,
-    .pObj   = pUser,
-    .pMsg   = pMsg
-  };
-
-  int32_t code = sdbDeleteRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("user:%s, failed to drop by %s, reason:%s", pUser->user, mnodeGetUserFromMsg(pMsg), tstrerror(code));
-  } else {
-    mLInfo("user:%s, is dropped by %s", pUser->user, mnodeGetUserFromMsg(pMsg));
-  }
-
-  return code;
-}
-
-static int32_t mnodeGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SUserObj *pUser = mnodeGetUserFromConn(pConn);
-  if (pUser == NULL) {
-    return TSDB_CODE_MND_NO_USER_FROM_CONN;
-  }
-
-  int32_t cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "name");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "privilege");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8;
-  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "create_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "account");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pMeta->numOfColumns = htons(cols);
-  strcpy(pMeta->tableFname, "show users");
-  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 = pUser->pAcct->acctInfo.numOfUsers;
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  mnodeDecUserRef(pUser);
-  return 0;
-}
-
-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 = mnodeGetNextUser(pShow->pIter, &pUser);
-    if (pUser == NULL) break;
-    
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pUser->user, pShow->bytes[cols]);
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    if (pUser->superAuth) {
-      const char *src = "super";
-      STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
-    } else if (pUser->writeAuth) {
-      const char *src = "writable";
-      STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
-    } else {
-      const char *src = "readable";
-      STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
-    }
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int64_t *)pWrite = pUser->createdTime;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pUser->acct, pShow->bytes[cols]);
-    cols++;
-
-    numOfRows++;
-    mnodeDecUserRef(pUser);
-  }
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-  pShow->numOfReads += numOfRows;
-  return numOfRows;
-}
-
-SUserObj *mnodeGetUserFromConn(void *pConn) {
-  SRpcConnInfo connInfo = {0};
-  if (rpcGetConnInfo(pConn, &connInfo) == 0) {
-    return mnodeGetUser(connInfo.user);
-  } else {
-    mError("can not get user from conn:%p", pConn);
-    return NULL;
-  }
-}
-
-char *mnodeGetUserFromMsg(void *pMsg) {
-  SMnodeMsg *pMnodeMsg = pMsg;
-  if (pMnodeMsg != NULL && pMnodeMsg->pUser != NULL) {
-    return pMnodeMsg->pUser->user;
-  } else {
-    return "system";
-  }
-}
-
-static int32_t mnodeProcessCreateUserMsg(SMnodeMsg *pMsg) {
-  SUserObj *pOperUser = pMsg->pUser;
-  
-  if (pOperUser->superAuth) {
-    SCreateUserMsg *pCreate = pMsg->rpcMsg.pCont;
-    return mnodeCreateUser(pOperUser->pAcct, pCreate->user, pCreate->pass, pMsg);
-  } else {
-    mError("user:%s, no rights to create user", pOperUser->user);
-    return TSDB_CODE_MND_NO_RIGHTS;
-  }
-}
-
-static int32_t mnodeProcessAlterUserMsg(SMnodeMsg *pMsg) {
-  int32_t code;
-  SUserObj *pOperUser = pMsg->pUser;
-  
-  SAlterUserMsg *pAlter = pMsg->rpcMsg.pCont;
-  SUserObj *pUser = mnodeGetUser(pAlter->user);
-  if (pUser == NULL) {
-    return TSDB_CODE_MND_INVALID_USER;
-  }
-
-  if (strcmp(pUser->user, "monitor") == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) {
-    mnodeDecUserRef(pUser);
-    return TSDB_CODE_MND_NO_RIGHTS;
-  }
-
-  if ((pAlter->flag & TSDB_ALTER_USER_PASSWD) != 0) {
-    bool hasRight = false;
-    if (strcmp(pOperUser->user, TSDB_DEFAULT_USER) == 0) {
-      hasRight = true;
-    } else if (strcmp(pUser->user, pOperUser->user) == 0) {
-      hasRight = true;
-    } else if (pOperUser->superAuth) {
-      if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-        hasRight = false;
-      } else if (strcmp(pOperUser->acct, pUser->acct) != 0) {
-        hasRight = false;
-      } else {
-        hasRight = true;
-      }
-    }
-
-    if (hasRight) {
-      memset(pUser->pass, 0, sizeof(pUser->pass));
-      taosEncryptPass((uint8_t*)pAlter->pass, strlen(pAlter->pass), pUser->pass);
-      code = mnodeUpdateUser(pUser, pMsg);
-    } else {
-      mError("user:%s, no rights to alter user", pOperUser->user);
-      code = TSDB_CODE_MND_NO_RIGHTS;
-    }
-  } else if ((pAlter->flag & TSDB_ALTER_USER_PRIVILEGES) != 0) {
-    bool hasRight = false;
-
-    if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-      hasRight = false;
-    } else if (strcmp(pUser->user, pUser->acct) == 0) {
-      hasRight = false;
-    } else if (strcmp(pOperUser->user, TSDB_DEFAULT_USER) == 0) {
-      hasRight = true;
-    } else if (strcmp(pUser->user, pOperUser->user) == 0) {
-      hasRight = false;
-    } else if (pOperUser->superAuth) {
-      if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-        hasRight = false;
-      } else if (strcmp(pOperUser->acct, pUser->acct) != 0) {
-        hasRight = false;
-      } else {
-        hasRight = true;
-      }
-    }
-
-    if (pAlter->privilege == 1) { // super
-      hasRight = false;
-    }
-
-    if (hasRight) {
-      if (pAlter->privilege == 2) {  // read
-        pUser->superAuth = 0;
-        pUser->writeAuth = 0;
-      }
-      if (pAlter->privilege == 3) {  // write
-        pUser->superAuth = 0;
-        pUser->writeAuth = 1;
-      }
-
-      code = mnodeUpdateUser(pUser, pMsg);
-    } else {
-      mError("user:%s, no rights to alter user", pOperUser->user);
-      code = TSDB_CODE_MND_NO_RIGHTS;
-    }
-  } else {
-    mError("user:%s, no rights to alter user", pOperUser->user);
-    code = TSDB_CODE_MND_NO_RIGHTS;
-  }
-
-  mnodeDecUserRef(pUser);
-  return code;
-}
-
-static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg) {
-  int32_t code;
-  SUserObj *pOperUser = pMsg->pUser;
-
-  SDropUserMsg *pDrop = pMsg->rpcMsg.pCont;
-  SUserObj *pUser = mnodeGetUser(pDrop->user);
-  if (pUser == NULL) {
-    return TSDB_CODE_MND_INVALID_USER;
-  }
-
-  if (strcmp(pUser->user, "monitor") == 0 || strcmp(pUser->user, pUser->acct) == 0 ||
-    (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) {
-    mnodeDecUserRef(pUser);
-    return TSDB_CODE_MND_NO_RIGHTS;
-  }
-
-  bool hasRight = false;
-  if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-    hasRight = false;
-  } else if (strcmp(pOperUser->user, TSDB_DEFAULT_USER) == 0) {
-    hasRight = true;
-  } else if (strcmp(pUser->user, pOperUser->user) == 0) {
-    hasRight = false;
-  } else if (pOperUser->superAuth) {
-    if (strcmp(pOperUser->acct, pUser->acct) != 0) {
-      hasRight = false;
-    } else {
-      hasRight = true;
-    }
-  }
-
-  if (hasRight) {
-    code = mnodeDropUser(pUser, pMsg);
-  } else {
-    code = TSDB_CODE_MND_NO_RIGHTS;
-  }
-
-  mnodeDecUserRef(pUser);
-  return code;
-}
-
-void mnodeDropAllUsers(SAcctObj *pAcct)  {
-  void *    pIter = NULL;
-  int32_t   numOfUsers = 0;
-  int32_t   acctNameLen = (int32_t)strlen(pAcct->user);
-  SUserObj *pUser = NULL;
-
-  while (1) {
-    pIter = mnodeGetNextUser(pIter, &pUser);
-    if (pUser == NULL) break;
-
-    if (strncmp(pUser->acct, pAcct->user, acctNameLen) == 0) {
-      SSdbRow row = {
-        .type   = SDB_OPER_LOCAL,
-        .pTable = tsUserSdb,
-        .pObj   = pUser,
-      };
-      sdbDeleteRow(&row);
-      numOfUsers++;
-    }
-
-    mnodeDecUserRef(pUser);
-  }
-
-  mDebug("acct:%s, all users:%d is dropped from sdb", pAcct->user, numOfUsers);
-}
-
-int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
-  if (!sdbIsMaster()) {
-    *secret = 0;
-    mDebug("user:%s, failed to auth user, mnode is not master", user);
-    return TSDB_CODE_APP_NOT_READY;
-  }
-
-  SUserObj *pUser = mnodeGetUser(user);
-  if (pUser == NULL) {
-    *secret = 0;
-    mError("user:%s, failed to auth user, reason:%s", user, tstrerror(TSDB_CODE_MND_INVALID_USER));
-    return TSDB_CODE_MND_INVALID_USER;
-  } else {
-    *spi = 1;
-    *encrypt = 0;
-    *ckey = 0;
-
-    memcpy(secret, pUser->pass, TSDB_KEY_LEN);
-    mnodeDecUserRef(pUser);
-    mDebug("user:%s, auth info is returned", user);
-    return TSDB_CODE_SUCCESS;
-  }
-}
-
-static int32_t mnodeProcessAuthMsg(SMnodeMsg *pMsg) {
-  SAuthMsg *pAuthMsg = pMsg->rpcMsg.pCont;
-  SAuthRsp *pAuthRsp = rpcMallocCont(sizeof(SAuthRsp));
-  
-  pMsg->rpcRsp.rsp = pAuthRsp;
-  pMsg->rpcRsp.len = sizeof(SAuthRsp);
-  
-  return mnodeRetriveAuth(pAuthMsg->user, &pAuthRsp->spi, &pAuthRsp->encrypt, pAuthRsp->secret, pAuthRsp->ckey);
-}
-
-int32_t mnodeCompactUsers() {
-  void *pIter = NULL;
-  SUserObj *pUser = NULL;
-
-  mInfo("start to compact users table...");
-
-  while (1) {
-    pIter = mnodeGetNextUser(pIter, &pUser);
-    if (pUser == NULL) break;
-
-    SSdbRow row = {
-      .type     = SDB_OPER_GLOBAL,
-      .pTable   = tsUserSdb,
-      .pObj     = pUser,
-      .rowSize  = sizeof(SUserObj),
-    };
-
-    mInfo("compact users %s", pUser->user);
-    
-    sdbInsertCompactRow(&row);
-  }
-
-  mInfo("end to compact users table...");
-
-  return 0;
-}
\ No newline at end of file

src/mnode/src/mnodeVgroup.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "tutil.h"
-#include "tsocket.h"
-#include "tidpool.h"
-#include "tsync.h"
-#include "tbn.h"
-#include "tglobal.h"
-#include "tdataformat.h"
-#include "dnode.h"
-#include "mnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeDb.h"
-#include "mnodeDnode.h"
-#include "mnodeMnode.h"
-#include "mnodeProfile.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeTable.h"
-#include "mnodeVgroup.h"
-#include "mnodePeer.h"
-
-typedef enum {
-  TAOS_VG_STATUS_READY,
-  TAOS_VG_STATUS_DROPPING,
-  TAOS_VG_STATUS_CREATING,
-  TAOS_VG_STATUS_UPDATING,
-} EVgroupStatus;
-
-char* vgroupStatus[] = {
-  "ready",
-  "dropping",
-  "creating",
-  "updating"
-};
-
-int64_t        tsVgroupRid = -1;
-static void   *tsVgroupSdb = NULL;
-static int32_t tsVgUpdateSize = 0;
-
-static int32_t mnodeAllocVgroupIdPool(SVgObj *pInputVgroup);
-static int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void    mnodeProcessCreateVnodeRsp(SRpcMsg *rpcMsg);
-static void    mnodeProcessAlterVnodeRsp(SRpcMsg *rpcMsg);
-static void    mnodeProcessCompactVnodeRsp(SRpcMsg *rpcMsg);
-static void    mnodeProcessDropVnodeRsp(SRpcMsg *rpcMsg);
-static int32_t mnodeProcessVnodeCfgMsg(SMnodeMsg *pMsg) ;
-static void    mnodeSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle);
-
-static void mnodeDestroyVgroup(SVgObj *pVgroup) {
-  if (pVgroup->idPool) {
-    taosIdPoolCleanUp(pVgroup->idPool);
-    pVgroup->idPool = NULL;
-  }
-
-  tfree(pVgroup);
-}
-
-static int32_t mnodeVgroupActionDestroy(SSdbRow *pRow) {
-  mnodeDestroyVgroup(pRow->pObj);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionInsert(SSdbRow *pRow) {
-  SVgObj *pVgroup = pRow->pObj;
-
-  // refer to db
-  SDbObj *pDb = mnodeGetDb(pVgroup->dbName);
-  if (pDb == NULL) {
-    mError("vgId:%d, db:%s is not exist while insert into hash", pVgroup->vgId, pVgroup->dbName);
-    return TSDB_CODE_MND_INVALID_DB;
-  }
-  
-  if (pDb->status != TSDB_DB_STATUS_READY) {
-    mError("vgId:%d, db:%s status:%d, in dropping", pVgroup->vgId, pDb->name, pDb->status);
-    mnodeDecDbRef(pDb);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-  pVgroup->pDb = pDb;
-  pVgroup->status = TAOS_VG_STATUS_CREATING;
-  pVgroup->accessState = TSDB_VN_ALL_ACCCESS;
-  if (mnodeAllocVgroupIdPool(pVgroup) < 0) {
-    mError("vgId:%d, failed to init idpool for vgroups", pVgroup->vgId);
-    return -1;
-  }
-
-  for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId);
-    if (pDnode != NULL) {
-      pVgroup->vnodeGid[i].pDnode = pDnode;
-      atomic_add_fetch_32(&pDnode->openVnodes, 1);
-      mnodeDecDnodeRef(pDnode);
-    }
-  }
-
-  mnodeAddVgroupIntoDb(pVgroup);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionDelete(SSdbRow *pRow) {
-  SVgObj *pVgroup = pRow->pObj;
-
-  if (pVgroup->pDb == NULL) {
-    mError("vgId:%d, db:%s is not exist while delete from hash", pVgroup->vgId, pVgroup->dbName);
-    return TSDB_CODE_MND_VGROUP_NOT_EXIST;
-  }
-
-  mnodeRemoveVgroupFromDb(pVgroup);
-  mnodeDecDbRef(pVgroup->pDb);
-
-  for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId);
-    if (pDnode != NULL) {
-      atomic_sub_fetch_32(&pDnode->openVnodes, 1);
-    }
-    mnodeDecDnodeRef(pDnode);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionUpdate(SSdbRow *pRow) {
-  SVgObj *pNew = pRow->pObj;
-  SVgObj *pVgroup = mnodeGetVgroup(pNew->vgId);
-
-  if (pVgroup != pNew) {
-    for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-      SDnodeObj *pDnode = pVgroup->vnodeGid[i].pDnode;
-      if (pDnode != NULL) {
-        atomic_sub_fetch_32(&pDnode->openVnodes, 1);
-      }
-    }
-
-    memcpy(pVgroup, pNew, tsVgUpdateSize);
-
-    for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-      SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId);
-      pVgroup->vnodeGid[i].pDnode = pDnode;
-      if (pDnode != NULL) {
-        atomic_add_fetch_32(&pDnode->openVnodes, 1);
-      }
-      mnodeDecDnodeRef(pDnode);
-    }
-
-    free(pNew);
-  }
-
-
-  // reset vgid status on vgroup changed
-  mDebug("vgId:%d, reset sync status to offline", pVgroup->vgId);
-  for (int32_t v = 0; v < pVgroup->numOfVnodes; ++v) {
-    pVgroup->vnodeGid[v].role = TAOS_SYNC_ROLE_OFFLINE;
-  }
-
-  mnodeDecVgroupRef(pVgroup);
-
-  mDebug("vgId:%d, is updated, numOfVnode:%d", pVgroup->vgId, pVgroup->numOfVnodes);
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionEncode(SSdbRow *pRow) {
-  SVgObj *pVgroup = pRow->pObj;
-  memcpy(pRow->rowData, pVgroup, tsVgUpdateSize);
-  SVgObj *pTmpVgroup = pRow->rowData;
-  for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
-    pTmpVgroup->vnodeGid[i].pDnode = NULL;
-    pTmpVgroup->vnodeGid[i].role = 0;
-    memset(pTmpVgroup->vnodeGid[i].vver, 0, sizeof(pTmpVgroup->vnodeGid[i].vver));
-  }
-
-  pRow->rowSize = tsVgUpdateSize;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionDecode(SSdbRow *pRow) {
-  SVgObj *pVgroup = (SVgObj *) calloc(1, sizeof(SVgObj));
-  if (pVgroup == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
-  memcpy(pVgroup, pRow->rowData, tsVgUpdateSize);
-  pRow->pObj = pVgroup;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionRestored() {
-  return 0;
-}
-
-int32_t mnodeInitVgroups() {
-  SVgObj tObj;
-  tsVgUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
-  SSdbTableDesc desc = {
-    .id           = SDB_TABLE_VGROUP,
-    .name         = "vgroups",
-    .hashSessions = TSDB_DEFAULT_VGROUPS_HASH_SIZE,
-    .maxRowSize   = tsVgUpdateSize,
-    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
-    .keyType      = SDB_KEY_AUTO,
-    .fpInsert     = mnodeVgroupActionInsert,
-    .fpDelete     = mnodeVgroupActionDelete,
-    .fpUpdate     = mnodeVgroupActionUpdate,
-    .fpEncode     = mnodeVgroupActionEncode,
-    .fpDecode     = mnodeVgroupActionDecode,
-    .fpDestroy    = mnodeVgroupActionDestroy,
-    .fpRestored   = mnodeVgroupActionRestored,
-  };
-
-  tsVgroupRid = sdbOpenTable(&desc);
-  tsVgroupSdb = sdbGetTableByRid(tsVgroupRid);
-  if (tsVgroupSdb == NULL) {
-    mError("failed to init vgroups data");
-    return -1;
-  }
-
-  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VGROUP, mnodeGetVgroupMeta);
-  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VGROUP, mnodeRetrieveVgroups);
-  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_VGROUP, mnodeCancelGetNextVgroup);
-  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP, mnodeProcessCreateVnodeRsp);
-  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_ALTER_VNODE_RSP, mnodeProcessAlterVnodeRsp);
-  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_COMPACT_VNODE_RSP, mnodeProcessCompactVnodeRsp);
-  mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_DROP_VNODE_RSP, mnodeProcessDropVnodeRsp);
-  mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_VNODE, mnodeProcessVnodeCfgMsg);
-
-  mDebug("table:vgroups is created");
-  
-  return 0;
-}
-
-void mnodeIncVgroupRef(SVgObj *pVgroup) {
-  sdbIncRef(tsVgroupSdb, pVgroup); 
-}
-
-void mnodeDecVgroupRef(SVgObj *pVgroup) { 
-  sdbDecRef(tsVgroupSdb, pVgroup); 
-}
-
-SVgObj *mnodeGetVgroup(int32_t vgId) {
-  return (SVgObj *)sdbGetRow(tsVgroupSdb, &vgId);
-}
-
-void mnodeUpdateVgroup(SVgObj *pVgroup) {
-  pVgroup->vgCfgVersion++;
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsVgroupSdb,
-    .pObj   = pVgroup
-  };
-
-  int32_t code = sdbUpdateRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    mError("vgId:%d, failed to update vgroup", pVgroup->vgId);
-  }
-  mnodeSendAlterVgroupMsg(pVgroup,NULL);
-}
-
-/*
-  Traverse all vgroups on mnode, if there no such vgId on a dnode, so send msg to this dnode for re-creating this vgId/vnode 
-*/
-void mnodeCheckUnCreatedVgroup(SDnodeObj *pDnode, SVnodeLoad *pVloads, int32_t openVnodes) {
-  void *pIter = NULL;
-  while (1) {
-    SVgObj *pVgroup;
-    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
-    if (pVgroup == NULL) break;
-
-    for (int v = 0; v < pVgroup->numOfVnodes; ++v) {
-      if (pVgroup->vnodeGid[v].dnodeId == pDnode->dnodeId) {
-        // vgroup should have a vnode on this dnode
-        bool have = false;
-        for (int32_t i = 0; i < openVnodes; ++i) {
-          SVnodeLoad *pVload = pVloads + i;
-          if (pVgroup->vgId == pVload->vgId) {
-            have = true;
-            break;
-          }
-        }
-
-        if (have) continue;
-
-        if (pVgroup->status == TAOS_VG_STATUS_CREATING || pVgroup->status == TAOS_VG_STATUS_DROPPING) {
-          mDebug("vgId:%d, not exist in dnode:%d and status is %s, do nothing", pVgroup->vgId, pDnode->dnodeId,
-                 vgroupStatus[pVgroup->status]);
-        } else {
-          mDebug("vgId:%d, not exist in dnode:%d and status is %s, send create msg", pVgroup->vgId, pDnode->dnodeId,
-                 vgroupStatus[pVgroup->status]);
-          mnodeSendCreateVgroupMsg(pVgroup, NULL);
-        }
-      }
-    }
-
-    mnodeDecVgroupRef(pVgroup);
-  }
-
-  mnodeCancelGetNextVgroup(pIter);
-}
-
-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];
-    if (pVgid->pDnode == pDnode) {
-      mTrace("vgId:%d, receive vnode status from dnode:%d, status:%s last:%s vver:%" PRIu64, pVgroup->vgId,
-             pDnode->dnodeId, syncRole[pVload->role], syncRole[pVgid->role], pVload->vnodeVersion);
-      pVgid->role = pVload->role;
-      mnodeSetVgidVer(pVgid->vver, pVload->vnodeVersion);
-      if (pVload->role == TAOS_SYNC_ROLE_MASTER) {
-        pVgroup->inUse = i;
-      }
-      dnodeExist = true;
-      break;
-    }
-  }
-
-  if (!dnodeExist) {
-    SRpcEpSet epSet = mnodeGetEpSetFromIp(pDnode->dnodeEp);
-    mError("vgId:%d, dnode:%d not exist in mnode, drop it", pVload->vgId, pDnode->dnodeId);
-    mnodeSendDropVnodeMsg(pVload->vgId, &epSet, NULL);
-    return;
-  }
-
-  if (pVload->role == TAOS_SYNC_ROLE_MASTER) {
-    pVgroup->totalStorage = htobe64(pVload->totalStorage);
-    pVgroup->compStorage = htobe64(pVload->compStorage);
-    pVgroup->pointsWritten = htobe64(pVload->pointsWritten);
-  }
-
-  if (pVload->dbCfgVersion != pVgroup->pDb->dbCfgVersion || pVload->replica != pVgroup->numOfVnodes ||
-      pVload->vgCfgVersion != pVgroup->vgCfgVersion) {
-    mError("dnode:%d, vgId:%d, vnode cfgVersion:%d:%d repica:%d not match with mnode cfgVersion:%d:%d replica:%d",
-           pDnode->dnodeId, pVload->vgId, pVload->dbCfgVersion, pVload->vgCfgVersion, pVload->replica,
-           pVgroup->pDb->dbCfgVersion, pVgroup->vgCfgVersion, pVgroup->numOfVnodes);
-    mnodeSendAlterVgroupMsg(pVgroup,NULL);
-  }
-  pVgroup->compact = pVload->compact; 
-}
-
-static int32_t mnodeAllocVgroupIdPool(SVgObj *pInputVgroup) {
-  SDbObj *pDb = pInputVgroup->pDb;
-  if (pDb == NULL) return TSDB_CODE_MND_APP_ERROR;
-
-  int32_t minIdPoolSize = TSDB_MAX_TABLES;
-  int32_t maxIdPoolSize = tsMinTablePerVnode;
-  for (int32_t v = 0; v < pDb->numOfVgroups; ++v) {
-    SVgObj *pVgroup = pDb->vgList[v];
-    if (pVgroup == NULL) continue;
-
-    int32_t idPoolSize = taosIdPoolMaxSize(pVgroup->idPool);
-    minIdPoolSize = MIN(minIdPoolSize, idPoolSize);
-    maxIdPoolSize = MAX(maxIdPoolSize, idPoolSize);
-  }
-
-  // create one table each vnode
-  if (pDb->cfg.dbType == TSDB_DB_TYPE_TOPIC) {
-    maxIdPoolSize = 1;
-  }
-
-  // new vgroup
-  if (pInputVgroup->idPool == NULL) {
-    pInputVgroup->idPool = taosInitIdPool(maxIdPoolSize);
-    if (pInputVgroup->idPool == NULL) {
-      mError("vgId:%d, failed to init idPool for vgroup, size:%d", pInputVgroup->vgId, maxIdPoolSize);
-      return TSDB_CODE_MND_OUT_OF_MEMORY;
-    } else {
-      mDebug("vgId:%d, init idPool for vgroup, size:%d", pInputVgroup->vgId, maxIdPoolSize);
-      return TSDB_CODE_SUCCESS;
-    }
-  }
-
-  // create one table each vnode
-  if (pDb->cfg.dbType == TSDB_DB_TYPE_TOPIC) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  // realloc all vgroups in db
-  int32_t newIdPoolSize;
-  if (minIdPoolSize * 4 < tsTableIncStepPerVnode) {
-    newIdPoolSize = minIdPoolSize * 4;
-  } else {
-    newIdPoolSize = ((minIdPoolSize / tsTableIncStepPerVnode) + 1) * tsTableIncStepPerVnode;
-  }
-
-  if (newIdPoolSize > tsMaxTablePerVnode) {
-    if (minIdPoolSize >= tsMaxTablePerVnode) {
-      mError("db:%s, minIdPoolSize:%d newIdPoolSize:%d larger than maxTablesPerVnode:%d", pDb->name, minIdPoolSize, newIdPoolSize,
-             tsMaxTablePerVnode);
-      return TSDB_CODE_MND_NO_ENOUGH_DNODES;
-    } else {
-      newIdPoolSize = tsMaxTablePerVnode;
-    }
-  }
-
-  for (int32_t v = 0; v < pDb->numOfVgroups; ++v) {
-    SVgObj *pVgroup = pDb->vgList[v];
-    if (pVgroup == NULL) continue;
-
-    int32_t oldIdPoolSize = taosIdPoolMaxSize(pVgroup->idPool);
-    if (newIdPoolSize == oldIdPoolSize) continue;
-
-    if (taosUpdateIdPool(pVgroup->idPool, newIdPoolSize) < 0) {
-      mError("vgId:%d, failed to update idPoolSize from %d to %d", pVgroup->vgId, oldIdPoolSize, newIdPoolSize);
-      return TSDB_CODE_MND_NO_ENOUGH_DNODES;
-    } else {
-      mDebug("vgId:%d, idPoolSize update from %d to %d", pVgroup->vgId, oldIdPoolSize, newIdPoolSize);
-    }
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeGetAvailableVgroup(SMnodeMsg *pMsg, SVgObj **ppVgroup, int32_t *pSid) {
-  SDbObj *pDb = pMsg->pDb;
-  pthread_mutex_lock(&pDb->mutex);
-  
-  for (int32_t v = 0; v < pDb->numOfVgroups; ++v) {
-    int vgIndex = (v + pDb->vgListIndex) % pDb->numOfVgroups;
-    SVgObj *pVgroup = pDb->vgList[vgIndex];
-    if (pVgroup == NULL) {
-      mError("db:%s, index:%d vgroup is null", pDb->name, vgIndex);
-      pthread_mutex_unlock(&pDb->mutex);
-      return TSDB_CODE_MND_APP_ERROR;
-    }
-
-    int32_t sid = taosAllocateId(pVgroup->idPool);
-    if (sid <= 0) {
-      mDebug("msg:%p, app:%p db:%s, no enough sid in vgId:%d", pMsg, pMsg->rpcMsg.ahandle, pDb->name, pVgroup->vgId);
-      continue;
-    }
-    mTrace("vgId:%d, alloc tid:%d", pVgroup->vgId, sid);
-
-    *pSid = sid;
-    *ppVgroup = pVgroup;
-    pDb->vgListIndex = vgIndex;
-
-    pthread_mutex_unlock(&pDb->mutex);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  int maxVgroupsPerDb = tsMaxVgroupsPerDb;
-  if (maxVgroupsPerDb <= 0) {
-    maxVgroupsPerDb = mnodeGetOnlinDnodesCpuCoreNum();
-    maxVgroupsPerDb = MAX(maxVgroupsPerDb, TSDB_MIN_VNODES_PER_DB);
-    maxVgroupsPerDb = MIN(maxVgroupsPerDb, TSDB_MAX_VNODES_PER_DB);
-  }
-
-  if (pDb->cfg.dbType == TSDB_DB_TYPE_TOPIC) {
-    maxVgroupsPerDb = TSDB_MAX_DB_PARTITON_OPTION;
-  }
-
-  int32_t code = TSDB_CODE_MND_NO_ENOUGH_DNODES;
-  if (pDb->numOfVgroups < maxVgroupsPerDb) {
-    mDebug("msg:%p, app:%p db:%s, try to create a new vgroup, numOfVgroups:%d maxVgroupsPerDb:%d", pMsg,
-           pMsg->rpcMsg.ahandle, pDb->name, pDb->numOfVgroups, maxVgroupsPerDb);
-    pthread_mutex_unlock(&pDb->mutex);
-    code = mnodeCreateVgroup(pMsg);
-    if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-      return code;
-    } else {
-      pthread_mutex_lock(&pDb->mutex);
-    }
-  }
-
-  if (pDb->numOfVgroups < 1) {
-    pthread_mutex_unlock(&pDb->mutex);
-    mDebug("msg:%p, app:%p db:%s, failed create new vgroup since:%s, numOfVgroups:%d maxVgroupsPerDb:%d ", pMsg,
-           pMsg->rpcMsg.ahandle, pDb->name, tstrerror(code), pDb->numOfVgroups, maxVgroupsPerDb);
-    return code;
-  }
-
-  SVgObj *pVgroup = pDb->vgList[0];
-  if (pVgroup == NULL) {
-    pthread_mutex_unlock(&pDb->mutex);
-    return code;
-  }
-
-  code = mnodeAllocVgroupIdPool(pVgroup);
-  if (code != TSDB_CODE_SUCCESS) {
-    pthread_mutex_unlock(&pDb->mutex);
-    return code;
-  }
-
-  int32_t sid = taosAllocateId(pVgroup->idPool);
-  if (sid <= 0) {
-    mError("msg:%p, app:%p db:%s, no enough sid in vgId:%d", pMsg, pMsg->rpcMsg.ahandle, pDb->name, pVgroup->vgId);
-    pthread_mutex_unlock(&pDb->mutex);
-    return TSDB_CODE_MND_NO_ENOUGH_DNODES;
-  }
-
-  *pSid = sid;
-  *ppVgroup = pVgroup;
-  pDb->vgListIndex = 0;
-  pthread_mutex_unlock(&pDb->mutex);
-
-  mTrace("vgId:%d, alloc tid:%d", pVgroup->vgId, sid);
-  return TSDB_CODE_SUCCESS;
-}
-
-void *mnodeGetNextVgroup(void *pIter, SVgObj **pVgroup) { 
-  return sdbFetchRow(tsVgroupSdb, pIter, (void **)pVgroup); 
-}
-
-void mnodeCancelGetNextVgroup(void *pIter) {
-  sdbFreeIter(tsVgroupSdb, pIter);
-}
-
-static int32_t mnodeCreateVgroupFp(SMnodeMsg *pMsg) {
-  SVgObj *pVgroup = pMsg->pVgroup;
-  SDbObj *pDb = pMsg->pDb;
-  assert(pVgroup);
-
-  mInfo("msg:%p, app:%p vgId:%d, is created in mnode, db:%s replica:%d", pMsg, pMsg->rpcMsg.ahandle, pVgroup->vgId,
-        pDb->name, pVgroup->numOfVnodes);
-  for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    mInfo("msg:%p, app:%p vgId:%d, index:%d, dnode:%d", pMsg, pMsg->rpcMsg.ahandle, pVgroup->vgId, i,
-          pVgroup->vnodeGid[i].dnodeId);
-  }
-
-  pMsg->expected = pVgroup->numOfVnodes;
-  pMsg->successed = 0;
-  pMsg->received = 0;
-  mnodeSendCreateVgroupMsg(pVgroup, pMsg);
-
-  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-static int32_t mnodeCreateVgroupCb(SMnodeMsg *pMsg, int32_t code) {
-  SVgObj *pVgroup = pMsg->pVgroup;
-  SDbObj *pDb = pMsg->pDb;
-  assert(pVgroup);
-
-  if (code != TSDB_CODE_SUCCESS) {
-    mError("msg:%p, app:%p vgId:%d, failed to create in sdb, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pVgroup->vgId,
-           tstrerror(code));
-    SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pVgroup, .pTable = tsVgroupSdb};
-    sdbDeleteRow(&desc);
-
-    if (pMsg->pBatchMasterMsg) {
-      ++pMsg->pBatchMasterMsg->received;
-      pMsg->pBatchMasterMsg->code = pMsg->code;
-      if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received
-          >= pMsg->pBatchMasterMsg->expected) {
-        dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, pMsg->code);
-      }
-
-      mnodeDestroySubMsg(pMsg);
-
-      return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-    }
-
-    return code;
-  } else {
-    mInfo("msg:%p, app:%p vgId:%d, is created in sdb, db:%s replica:%d", pMsg, pMsg->rpcMsg.ahandle, pVgroup->vgId,
-          pDb->name, pVgroup->numOfVnodes);
-    pVgroup->status = TAOS_VG_STATUS_READY;
-    SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pVgroup, .pTable = tsVgroupSdb};
-    (void)sdbUpdateRow(&desc);
-
-    dnodeReprocessMWriteMsg(pMsg);
-    return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-    // if (pVgroup->status == TAOS_VG_STATUS_CREATING || pVgroup->status == TAOS_VG_STATUS_READY) {
-    //   mInfo("msg:%p, app:%p vgId:%d, is created in sdb, db:%s replica:%d", pMsg, pMsg->rpcMsg.ahandle, pVgroup->vgId,
-    //         pDb->name, pVgroup->numOfVnodes);
-    //   pVgroup->status = TAOS_VG_STATUS_READY;
-    //   SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pVgroup, .pTable = tsVgroupSdb};
-    //   (void)sdbUpdateRow(&desc);
-    //   dnodeReprocessMWriteMsg(pMsg);
-    //   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-    // } else {
-    //   mError("msg:%p, app:%p vgId:%d, is created in sdb, db:%s replica:%d, but vgroup is dropping", pMsg->rpcMsg.ahandle,
-    //          pMsg, pVgroup->vgId, pDb->name, pVgroup->numOfVnodes);
-    //   return TSDB_CODE_MND_VGROUP_NOT_EXIST;
-    // }
-  }
-}
-
-int32_t mnodeCreateVgroup(SMnodeMsg *pMsg) {
-  if (pMsg == NULL) return TSDB_CODE_MND_APP_ERROR;
-  SDbObj *pDb = pMsg->pDb;
-
-  SVgObj *pVgroup = (SVgObj *)calloc(1, sizeof(SVgObj));
-  tstrncpy(pVgroup->dbName, pDb->name, TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN);
-  pVgroup->numOfVnodes = pDb->cfg.replications;
-  pVgroup->createdTime = taosGetTimestampMs();
-  pVgroup->accessState = TSDB_VN_ALL_ACCCESS;
-  int32_t code = bnAllocVnodes(pVgroup);
-  if (code != TSDB_CODE_SUCCESS) {
-    mError("db:%s, no enough dnode to alloc %d vnodes to vgroup, reason:%s", pDb->name, pVgroup->numOfVnodes,
-           tstrerror(code));
-    free(pVgroup);
-    return code;
-  }
-
-  if (pMsg->pVgroup != NULL) {
-    mnodeDecVgroupRef(pMsg->pVgroup);
-  }
-
-  pMsg->pVgroup = pVgroup;
-  mnodeIncVgroupRef(pVgroup);
-
-  SSdbRow row = {
-    .type     = SDB_OPER_GLOBAL,
-    .pTable   = tsVgroupSdb,
-    .pObj     = pVgroup,
-    .rowSize  = sizeof(SVgObj),
-    .pMsg     = pMsg,
-    .fpReq    = mnodeCreateVgroupFp
-  };
-
-  code = sdbInsertRow(&row);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    pMsg->pVgroup = NULL;
-    mnodeDestroyVgroup(pVgroup);
-  }
-
-  return code;
-}
-
-void mnodeDropVgroup(SVgObj *pVgroup, void *ahandle) {
-  if (ahandle != NULL) {
-    mnodeSendDropVgroupMsg(pVgroup, ahandle);
-  } else {
-    mDebug("vgId:%d, replica:%d is deleting from sdb", pVgroup->vgId, pVgroup->numOfVnodes);
-    mnodeSendDropVgroupMsg(pVgroup, NULL);
-    SSdbRow row = {
-      .type   = SDB_OPER_GLOBAL,
-      .pTable = tsVgroupSdb,
-      .pObj   = pVgroup
-    };
-    sdbDeleteRow(&row);
-  }
-}
-
-void mnodeCleanupVgroups() {
-  sdbCloseTable(tsVgroupRid);
-  tsVgroupSdb = NULL;
-}
-
-int64_t mnodeGetVgroupNum() {
-  return sdbGetNumOfRows(tsVgroupSdb);
-}
-
-static int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
-  SDbObj *pDb = mnodeGetDb(pShow->db);
-  if (pDb == NULL) {
-    return TSDB_CODE_MND_DB_NOT_SELECTED;
-  }
-  
-  if (pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
-    mnodeDecDbRef(pDb);
-    return TSDB_CODE_MND_DB_IN_DROPPING;
-  }
-
-  int32_t cols = 0;
-  SSchema *pSchema = pMeta->schema;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "vgId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "tables");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 8 + VARSTR_HEADER_SIZE;
-  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "status");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "onlines");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
-  cols++;
-
-  pShow->maxReplica = 1;
-  for (int32_t v = 0; v < pDb->numOfVgroups; ++v) {
-    SVgObj *pVgroup = pDb->vgList[v];
-    if (pVgroup != NULL) {
-      pShow->maxReplica = pVgroup->numOfVnodes > pShow->maxReplica ? pVgroup->numOfVnodes : pShow->maxReplica;
-    }
-  }
-
-  for (int32_t i = 0; i < pShow->maxReplica; ++i) {
-    pShow->bytes[cols] = 2;
-    pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-    snprintf(pSchema[cols].name, TSDB_COL_NAME_LEN, "v%d_dnode", i + 1);
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-
-    pShow->bytes[cols] = 9 + VARSTR_HEADER_SIZE;
-    pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-    snprintf(pSchema[cols].name, TSDB_COL_NAME_LEN, "v%d_status", i + 1);
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
-    cols++;
-  }
-
-  pShow->bytes[cols] = 4;
-  pSchema[cols].type = TSDB_DATA_TYPE_INT;
-  strcpy(pSchema[cols].name, "compacting");
-  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 = pDb->numOfVgroups;
-  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
-  mnodeDecDbRef(pDb);
-  return 0;
-}
-
-static bool mnodeFilterVgroups(SVgObj *pVgroup, STableObj *pTable) {
-  if (NULL == pTable || pTable->type == TSDB_SUPER_TABLE) {
-    return true;
-  }
-
-  SCTableObj *pCTable = (SCTableObj *)pTable;
-  if (pVgroup->vgId == pCTable->vgId) {
-    return true;
-  } else {
-    return false;
-  }
-}
-
-static int32_t mnodeRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
-  int32_t numOfRows = 0;
-  SVgObj *pVgroup = NULL;
-  int32_t cols = 0;
-  char *  pWrite;
-
-  SDbObj *pDb = mnodeGetDb(pShow->db);
-  if (pDb == NULL) return 0;
-
-  if (pDb->status != TSDB_DB_STATUS_READY) {
-    mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
-    mnodeDecDbRef(pDb);
-    return 0;
-  }
-
-  STableObj *pTable = NULL;
-  if (pShow->payloadLen > 0 ) {
-    pTable = mnodeGetTable(pShow->payload);
-  }
-
-  while (numOfRows < rows) {
-    pShow->pIter = mnodeGetNextVgroup(pShow->pIter, &pVgroup);
-    if (pVgroup == NULL) break;
-
-    if (pVgroup->pDb != pDb) {
-      mnodeDecVgroupRef(pVgroup);
-      continue;
-    }
-
-    if (!mnodeFilterVgroups(pVgroup, pTable)) {
-      mnodeDecVgroupRef(pVgroup);
-      continue;
-    }
-
-    cols = 0;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *) pWrite = pVgroup->vgId;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *) pWrite = pVgroup->numOfTables;
-    cols++;
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;  
-    char* status = vgroupStatus[pVgroup->status];
-    STR_TO_VARSTR(pWrite, status);
-    cols++;
-
-    int32_t onlineVnodes = 0;
-    for (int32_t i = 0; i < pShow->maxReplica; ++i) {
-      if (pVgroup->vnodeGid[i].role == TAOS_SYNC_ROLE_SLAVE || pVgroup->vnodeGid[i].role == TAOS_SYNC_ROLE_MASTER) {
-        onlineVnodes++;
-      }
-    }
-
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int32_t *)pWrite = onlineVnodes;
-    cols++;
-
-    for (int32_t i = 0; i < pShow->maxReplica; ++i) {
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      *(int16_t *) pWrite = pVgroup->vnodeGid[i].dnodeId;
-      cols++;
-
-      SDnodeObj * pDnode = pVgroup->vnodeGid[i].pDnode;
-      const char *role = "NULL";
-      if (pDnode != NULL) {
-        role = syncRole[pVgroup->vnodeGid[i].role];
-      }
-
-      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-      STR_WITH_MAXSIZE_TO_VARSTR(pWrite, role, pShow->bytes[cols]);
-      cols++;
-    }
-      
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int8_t *)pWrite = pVgroup->compact; 
-    cols++;
-    
-    mnodeDecVgroupRef(pVgroup);
-    numOfRows++;
-  }
-
-  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-
-  pShow->numOfReads += numOfRows;
-  mnodeDecTableRef(pTable);
-  mnodeDecDbRef(pDb);
-
-  return numOfRows;
-}
-
-int32_t mnodeAddTableIntoVgroup(SVgObj *pVgroup, SCTableObj *pTable, bool needCheck) {
-  int32_t idPoolSize = taosIdPoolMaxSize(pVgroup->idPool);
-  if (pTable->tid > idPoolSize) {
-    mnodeAllocVgroupIdPool(pVgroup);
-  }
-
-  if (pTable->tid >= 1) {
-    if (taosIdPoolMarkStatus(pVgroup->idPool, pTable->tid) || !needCheck) {
-      pVgroup->numOfTables++;
-      mTrace("table:%s, vgId:%d tid:%d, mark tid used, uid:%" PRIu64, pTable->info.tableId, pTable->vgId, pTable->tid,
-             pTable->uid);
-      // The create vgroup message may be received later than the create table message
-      // and the writing order in sdb is therefore uncertain
-      // which will cause the reference count of the vgroup to be incorrect when restarting
-      // mnodeIncVgroupRef(pVgroup);
-    } else {
-      mError("table:%s, vgId:%d tid:%d, failed to mark tid, uid:%" PRIu64, pTable->info.tableId, pTable->vgId,
-             pTable->tid, pTable->uid);
-      return -1;
-    }
-  }
-
-  return 0;
-}
-
-void mnodeRemoveTableFromVgroup(SVgObj *pVgroup, SCTableObj *pTable) {
-  if (pTable->tid >= 1) {
-    taosFreeId(pVgroup->idPool, pTable->tid);
-    pVgroup->numOfTables--;
-    mTrace("table:%s, vgId:%d tid:%d, put tid back uid:%" PRIu64, pTable->info.tableId, pTable->vgId, pTable->tid,
-           pTable->uid);
-    // The create vgroup message may be received later than the create table message
-    // and the writing order in sdb is therefore uncertain
-    // which will cause the reference count of the vgroup to be incorrect when restarting
-    // mnodeDecVgroupRef(pVgroup);
-  }
-}
-
-static SCreateVnodeMsg *mnodeBuildVnodeMsg(SVgObj *pVgroup) {
-  SDbObj *pDb = pVgroup->pDb;
-  if (pDb == NULL) return NULL;
-
-  SCreateVnodeMsg *pVnode = rpcMallocCont(sizeof(SCreateVnodeMsg));
-  if (pVnode == NULL) return NULL;
-
-  strcpy(pVnode->db, pVgroup->dbName);
-  int32_t maxTables = taosIdPoolMaxSize(pVgroup->idPool);
-  //TODO: dynamic alloc tables in tsdb
-  maxTables = MAX(10000, tsMaxTablePerVnode);
-
-  SVnodeCfg *pCfg = &pVnode->cfg;
-  pCfg->vgId                = htonl(pVgroup->vgId);
-  pCfg->dbCfgVersion        = htonl(pDb->dbCfgVersion);
-  pCfg->vgCfgVersion        = htonl(pVgroup->vgCfgVersion);
-  pCfg->cacheBlockSize      = htonl(pDb->cfg.cacheBlockSize);
-  pCfg->totalBlocks         = htonl(pDb->cfg.totalBlocks);
-  pCfg->maxTables           = htonl(maxTables + 1);
-  pCfg->daysPerFile         = htonl(pDb->cfg.daysPerFile);
-  pCfg->daysToKeep          = htonl(pDb->cfg.daysToKeep2);        //FROM DB TO VNODE MAP:
-  pCfg->daysToKeep1         = htonl(pDb->cfg.daysToKeep0);        //keep0,keep1,keep2 in SQL is mapped to keep1,keep2,keep in vnode
-  pCfg->daysToKeep2         = htonl(pDb->cfg.daysToKeep1);        //user,client,mnode use keep0,keep1,keep2; vnode use keep1,keep2,keep
-  pCfg->minRowsPerFileBlock = htonl(pDb->cfg.minRowsPerFileBlock);
-  pCfg->maxRowsPerFileBlock = htonl(pDb->cfg.maxRowsPerFileBlock);
-  pCfg->fsyncPeriod         = htonl(pDb->cfg.fsyncPeriod);
-  pCfg->commitTime          = htonl(pDb->cfg.commitTime);
-  pCfg->precision           = pDb->cfg.precision;
-  pCfg->compression         = pDb->cfg.compression;
-  pCfg->walLevel            = pDb->cfg.walLevel;
-  pCfg->vgReplica           = (int8_t) pVgroup->numOfVnodes;
-  pCfg->wals                = 3;
-  pCfg->quorum              = pDb->cfg.quorum;
-  pCfg->update              = pDb->cfg.update;
-  pCfg->cacheLastRow        = pDb->cfg.cacheLastRow;
-  pCfg->dbReplica           = pDb->cfg.replications;
-  pCfg->dbType              = pDb->cfg.dbType;
-  
-  SVnodeDesc *pNodes = pVnode->nodes;
-  for (int32_t j = 0; j < pVgroup->numOfVnodes; ++j) {
-    SDnodeObj *pDnode = pVgroup->vnodeGid[j].pDnode;
-    if (pDnode != NULL) {
-      pNodes[j].nodeId = htonl(pDnode->dnodeId);
-      strcpy(pNodes[j].nodeEp, pDnode->dnodeEp);
-    }
-  }
-
-  return pVnode;
-}
-
-SRpcEpSet mnodeGetEpSetFromVgroup(SVgObj *pVgroup) {
-  SRpcEpSet epSet = {
-    .numOfEps = pVgroup->numOfVnodes,
-    .inUse = pVgroup->inUse,
-  };
-  for (int i = 0; i < pVgroup->numOfVnodes; ++i) {
-    strcpy(epSet.fqdn[i], pVgroup->vnodeGid[i].pDnode->dnodeFqdn);
-    epSet.port[i] = pVgroup->vnodeGid[i].pDnode->dnodePort + TSDB_PORT_DNODEDNODE;
-  }
-  return epSet;
-}
-
-SRpcEpSet mnodeGetEpSetFromIp(char *ep) {
-  SRpcEpSet epSet;
-
-  epSet.numOfEps = 1;
-  epSet.inUse = 0;
-  taosGetFqdnPortFromEp(ep, epSet.fqdn[0], &epSet.port[0]);
-  epSet.port[0] += TSDB_PORT_DNODEDNODE;
-  return epSet;
-}
-
-static void mnodeSendAlterVnodeMsg(SVgObj *pVgroup, SRpcEpSet *epSet, SMnodeMsg *pMsg) {
-  SAlterVnodeMsg *pAlter = mnodeBuildVnodeMsg(pVgroup);
-  SRpcMsg rpcMsg = {
-    .ahandle = pMsg,
-    .pCont   = pAlter,
-    .contLen = pAlter ? sizeof(SAlterVnodeMsg) : 0,
-    .code    = 0,
-    .msgType = TSDB_MSG_TYPE_MD_ALTER_VNODE
-  };
-  dnodeSendMsgToDnode(epSet, &rpcMsg);
-}
-
-void mnodeSendAlterVgroupMsg(SVgObj *pVgroup,SMnodeMsg *pMsg) {
-  mDebug("vgId:%d, send alter all vnodes msg, numOfVnodes:%d db:%s", pVgroup->vgId, pVgroup->numOfVnodes,
-         pVgroup->dbName);
-  if (pMsg) {
-    pMsg->pVgroup = pVgroup;
-    mnodeIncVgroupRef(pVgroup);
-  }
-  for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    SRpcEpSet epSet = mnodeGetEpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
-    mDebug("vgId:%d, index:%d, send alter vnode msg to dnode %s", pVgroup->vgId, i,
-           pVgroup->vnodeGid[i].pDnode->dnodeEp);
-    mnodeSendAlterVnodeMsg(pVgroup, &epSet,pMsg);
-  }
-}
-
-static SSyncVnodeMsg *mnodeBuildSyncVnodeMsg(int32_t vgId) {
-  SSyncVnodeMsg *pSyncVnode = rpcMallocCont(sizeof(SSyncVnodeMsg));
-  if (pSyncVnode == NULL) return NULL;
-
-  pSyncVnode->vgId = htonl(vgId);
-  return pSyncVnode;
-}
-
-
-static void mnodeSendSyncVnodeMsg(SVgObj *pVgroup, SRpcEpSet *epSet) {
-  SSyncVnodeMsg *pSyncVnode = mnodeBuildSyncVnodeMsg(pVgroup->vgId);
-  SRpcMsg rpcMsg = {
-    .ahandle = NULL,
-    .pCont   = pSyncVnode,
-    .contLen = pSyncVnode ? sizeof(SSyncVnodeMsg) : 0,
-    .code    = 0,
-    .msgType = TSDB_MSG_TYPE_MD_SYNC_VNODE
-  };
-
-  dnodeSendMsgToDnode(epSet, &rpcMsg);
-}
-static void mnodeSendCompactVnodeMsg(SVgObj *pVgroup, SRpcEpSet *epSet) {
-  SCompactVnodeMsg *pCompactVnode = mnodeBuildSyncVnodeMsg(pVgroup->vgId);
-  SRpcMsg rpcMsg = {
-    .ahandle = NULL,
-    .pCont   = pCompactVnode,
-    .contLen = pCompactVnode ? sizeof(SCompactVnodeMsg) : 0,
-    .code    = 0,
-    .msgType = TSDB_MSG_TYPE_MD_COMPACT_VNODE
-  };
-
-  dnodeSendMsgToDnode(epSet, &rpcMsg);
-}
-
-void mnodeSendSyncVgroupMsg(SVgObj *pVgroup) {
-  mDebug("vgId:%d, send sync all vnodes msg, numOfVnodes:%d db:%s", pVgroup->vgId, pVgroup->numOfVnodes,
-         pVgroup->dbName);
-  for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    if (pVgroup->vnodeGid[i].role != TAOS_SYNC_ROLE_SLAVE) continue;
-    SRpcEpSet epSet = mnodeGetEpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
-    mDebug("vgId:%d, index:%d, send sync vnode msg to dnode %s", pVgroup->vgId, i,
-           pVgroup->vnodeGid[i].pDnode->dnodeEp);
-    mnodeSendSyncVnodeMsg(pVgroup, &epSet);
-  }
-}
-
-void mnodeSendCompactVgroupMsg(SVgObj *pVgroup) {
-  mDebug("vgId:%d, send compact all vnodes msg, numOfVnodes:%d db:%s", pVgroup->vgId, pVgroup->numOfVnodes, pVgroup->dbName);
-  for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    //if (pVgroup->vnodeGid[i].role != TAOS_SYNC_ROLE_SLAVE) continue; //TODO(yihaoDeng): compact slave or not ? 
-    SRpcEpSet epSet = mnodeGetEpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
-    mDebug("vgId:%d, index:%d, send compact vnode msg to dnode %s", pVgroup->vgId, i,
-           pVgroup->vnodeGid[i].pDnode->dnodeEp);
-    mnodeSendCompactVnodeMsg(pVgroup, &epSet);
-  }
-
-}
-static void mnodeSendCreateVnodeMsg(SVgObj *pVgroup, SRpcEpSet *epSet, void *ahandle) {
-  SCreateVnodeMsg *pCreate = mnodeBuildVnodeMsg(pVgroup);
-  SRpcMsg rpcMsg = {
-    .ahandle = ahandle,
-    .pCont   = pCreate,
-    .contLen = pCreate ? sizeof(SCreateVnodeMsg) : 0,
-    .code    = 0,
-    .msgType = TSDB_MSG_TYPE_MD_CREATE_VNODE
-  };
-  dnodeSendMsgToDnode(epSet, &rpcMsg);
-}
-
-void mnodeSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle) {
-  mDebug("vgId:%d, send create all vnodes msg, numOfVnodes:%d db:%s", pVgroup->vgId, pVgroup->numOfVnodes,
-         pVgroup->dbName);
-  for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    SRpcEpSet epSet = mnodeGetEpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
-    mDebug("vgId:%d, index:%d, send create vnode msg to dnode %s, ahandle:%p", pVgroup->vgId,
-           i, pVgroup->vnodeGid[i].pDnode->dnodeEp, ahandle);
-    mnodeSendCreateVnodeMsg(pVgroup, &epSet, ahandle);
-  }
-}
-
-static void mnodeProcessAlterVnodeRsp(SRpcMsg *rpcMsg) {
-  mDebug("alter vnode rsp is received, handle:%p", rpcMsg->ahandle);
-  if (rpcMsg->ahandle == NULL) return;
-
-  SMnodeMsg *mnodeMsg = rpcMsg->ahandle;
-  mnodeMsg->received++;
-  if (rpcMsg->code == TSDB_CODE_SUCCESS) {
-    mnodeMsg->code = rpcMsg->code;
-    mnodeMsg->successed++;
-  }
-
-  SVgObj *pVgroup = mnodeMsg->pVgroup;
-  mDebug("vgId:%d, alter vnode rsp received, result:%s received:%d successed:%d expected:%d, thandle:%p ahandle:%p",
-         pVgroup->vgId, tstrerror(rpcMsg->code), mnodeMsg->received, mnodeMsg->successed, mnodeMsg->expected,
-         mnodeMsg->rpcMsg.handle, rpcMsg->ahandle);
-
-  if (mnodeMsg->received != mnodeMsg->expected) return;
-
-  int32_t code = mnodeInsertAlterDbRow(pVgroup->pDb, mnodeMsg);
-  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    dnodeSendRpcMWriteRsp(mnodeMsg, code);
-  }
-}
-static void mnodeProcessCompactVnodeRsp(SRpcMsg *rpcMsg) {
-  mDebug("compact vnode rsp received");
-}
-
-static void mnodeProcessCreateVnodeRsp(SRpcMsg *rpcMsg) {
-  if (rpcMsg->ahandle == NULL) return;
-
-  SMnodeMsg *mnodeMsg = rpcMsg->ahandle;
-  atomic_add_fetch_8(&mnodeMsg->received, 1);
-  if (rpcMsg->code == TSDB_CODE_SUCCESS) {
-    atomic_add_fetch_8(&mnodeMsg->successed, 1);
-  } else {
-    mnodeMsg->code = rpcMsg->code;
-  }
-
-  SVgObj *pVgroup = mnodeMsg->pVgroup;
-  mDebug("vgId:%d, create vnode rsp received, result:%s received:%d successed:%d expected:%d, thandle:%p ahandle:%p",
-         pVgroup->vgId, tstrerror(rpcMsg->code), mnodeMsg->received, mnodeMsg->successed, mnodeMsg->expected,
-         mnodeMsg->rpcMsg.handle, rpcMsg->ahandle);
-
-  assert(mnodeMsg->received <= mnodeMsg->expected);
-
-  if (mnodeMsg->received != mnodeMsg->expected) return;
-
-  if (mnodeMsg->received == mnodeMsg->successed) {
-     SSdbRow row = {
-      .type    = SDB_OPER_GLOBAL,
-      .pTable  = tsVgroupSdb,
-      .pObj    = pVgroup,
-      .rowSize = sizeof(SVgObj),
-      .pMsg    = mnodeMsg,
-      .fpRsp   = mnodeCreateVgroupCb
-    };
-
-    int32_t code = sdbInsertRowToQueue(&row);
-    if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-      mnodeMsg->pVgroup = NULL;
-      mnodeDestroyVgroup(pVgroup);
-
-      if (mnodeMsg->pBatchMasterMsg) {
-        ++mnodeMsg->pBatchMasterMsg->received;
-        mnodeMsg->pBatchMasterMsg->code = code;
-        if (mnodeMsg->pBatchMasterMsg->successed + mnodeMsg->pBatchMasterMsg->received
-            >= mnodeMsg->pBatchMasterMsg->expected) {
-          dnodeSendRpcMWriteRsp(mnodeMsg->pBatchMasterMsg, code);
-        }
-
-        mnodeDestroySubMsg(mnodeMsg);
-
-        return;
-      }
-
-      dnodeSendRpcMWriteRsp(mnodeMsg, code);
-    }
-  } else {
-    SSdbRow row = {
-      .type   = SDB_OPER_GLOBAL,
-      .pTable = tsVgroupSdb,
-      .pObj   = pVgroup
-    };
-    sdbDeleteRow(&row);
-
-    if (mnodeMsg->pBatchMasterMsg) {
-      ++mnodeMsg->pBatchMasterMsg->received;
-      mnodeMsg->pBatchMasterMsg->code = mnodeMsg->code;
-      if (mnodeMsg->pBatchMasterMsg->successed + mnodeMsg->pBatchMasterMsg->received
-          >= mnodeMsg->pBatchMasterMsg->expected) {
-        dnodeSendRpcMWriteRsp(mnodeMsg->pBatchMasterMsg, mnodeMsg->code);
-      }
-
-      mnodeDestroySubMsg(mnodeMsg);
-
-      return;
-    }
-
-    dnodeSendRpcMWriteRsp(mnodeMsg, mnodeMsg->code);
-  }
-}
-
-static SDropVnodeMsg *mnodeBuildDropVnodeMsg(int32_t vgId) {
-  SDropVnodeMsg *pDrop = rpcMallocCont(sizeof(SDropVnodeMsg));
-  if (pDrop == NULL) return NULL;
-
-  pDrop->vgId = htonl(vgId);
-  return pDrop;
-}
-
-void mnodeSendDropVnodeMsg(int32_t vgId, SRpcEpSet *epSet, void *ahandle) {
-  SDropVnodeMsg *pDrop = mnodeBuildDropVnodeMsg(vgId);
-  SRpcMsg rpcMsg = {
-      .ahandle = ahandle,
-      .pCont   = pDrop,
-      .contLen = pDrop ? sizeof(SDropVnodeMsg) : 0,
-      .code    = 0,
-      .msgType = TSDB_MSG_TYPE_MD_DROP_VNODE
-  };
-  dnodeSendMsgToDnode(epSet, &rpcMsg);
-}
-
-static void mnodeSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle) {
-  pVgroup->status = TAOS_VG_STATUS_DROPPING; // deleting
-  mDebug("vgId:%d, send drop all vnodes msg, ahandle:%p db:%s", pVgroup->vgId, ahandle, pVgroup->dbName);
-  for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
-    SRpcEpSet epSet = mnodeGetEpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
-    mDebug("vgId:%d, send drop vnode msg to dnode:%d, ahandle:%p", pVgroup->vgId, pVgroup->vnodeGid[i].dnodeId, ahandle);
-    mnodeSendDropVnodeMsg(pVgroup->vgId, &epSet, ahandle);
-  }
-}
-
-static void mnodeProcessDropVnodeRsp(SRpcMsg *rpcMsg) {
-  mDebug("drop vnode rsp is received, handle:%p", rpcMsg->ahandle);
-  if (rpcMsg->ahandle == NULL) return;
-
-  SMnodeMsg *mnodeMsg = rpcMsg->ahandle;
-  mnodeMsg->received++;
-  if (rpcMsg->code == TSDB_CODE_SUCCESS) {
-    mnodeMsg->code = rpcMsg->code;
-    mnodeMsg->successed++;
-  }
-
-  SVgObj *pVgroup = mnodeMsg->pVgroup;
-  mDebug("vgId:%d, drop vnode rsp received, result:%s received:%d successed:%d expected:%d, thandle:%p ahandle:%p",
-         pVgroup->vgId, tstrerror(rpcMsg->code), mnodeMsg->received, mnodeMsg->successed, mnodeMsg->expected,
-         mnodeMsg->rpcMsg.handle, rpcMsg->ahandle);
-
-  if (mnodeMsg->received != mnodeMsg->expected) return;
-
-  SSdbRow row = {
-    .type   = SDB_OPER_GLOBAL,
-    .pTable = tsVgroupSdb,
-    .pObj   = pVgroup
-  };
-  int32_t code = sdbDeleteRow(&row);
-  if (code != 0) {
-    code = TSDB_CODE_MND_SDB_ERROR;
-  }
-
-  dnodeReprocessMWriteMsg(mnodeMsg);
-}
-
-static int32_t mnodeProcessVnodeCfgMsg(SMnodeMsg *pMsg) {
-  SConfigVnodeMsg *pCfg = pMsg->rpcMsg.pCont;
-  pCfg->dnodeId = htonl(pCfg->dnodeId);
-  pCfg->vgId    = htonl(pCfg->vgId);
-
-  SDnodeObj *pDnode = mnodeGetDnode(pCfg->dnodeId);
-  if (pDnode == NULL) {
-    mDebug("dnode:%s, vgId:%d, invalid dnode", taosIpStr(pCfg->dnodeId), pCfg->vgId);
-    return TSDB_CODE_MND_VGROUP_NOT_EXIST;
-  }
-
-  SVgObj *pVgroup = mnodeGetVgroup(pCfg->vgId);
-  if (pVgroup == NULL) {
-    mDebug("dnode:%s, vgId:%d, no vgroup info", taosIpStr(pCfg->dnodeId), pCfg->vgId);
-    mnodeDecDnodeRef(pDnode);
-    return TSDB_CODE_MND_VGROUP_NOT_EXIST;
-  }
-
-  mDebug("vgId:%d, send create vnode msg to dnode %s for vnode cfg msg", pVgroup->vgId, pDnode->dnodeEp);
-  SRpcEpSet epSet = mnodeGetEpSetFromIp(pDnode->dnodeEp);
-  mnodeSendCreateVnodeMsg(pVgroup, &epSet, NULL);
-
-  mnodeDecDnodeRef(pDnode);
-  mnodeDecVgroupRef(pVgroup);
-  return TSDB_CODE_SUCCESS;
-}
-
-void mnodeDropAllDnodeVgroups(SDnodeObj *pDropDnode) {
-  void *  pIter = NULL;
-  SVgObj *pVgroup = NULL;
-  int32_t numOfVgroups = 0;
-
-  mInfo("dnode:%d, all vgroups will be dropped from sdb", pDropDnode->dnodeId);
-
-  while (1) {
-    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
-    if (pVgroup == NULL) break;
-
-    if (pVgroup->vnodeGid[0].dnodeId == pDropDnode->dnodeId) {
-      mnodeDropAllChildTablesInVgroups(pVgroup);
-      SSdbRow row = {
-        .type   = SDB_OPER_LOCAL,
-        .pTable = tsVgroupSdb,
-        .pObj   = pVgroup,
-      };
-      sdbDeleteRow(&row);
-      numOfVgroups++;
-    }
-    mnodeDecVgroupRef(pVgroup);
-  }
-
-  mInfo("dnode:%d, all vgroups:%d is dropped from sdb", pDropDnode->dnodeId, numOfVgroups);
-}
-
-#if 0
-void mnodeUpdateAllDbVgroups(SDbObj *pAlterDb) {
-  void *  pIter = NULL;
-  SVgObj *pVgroup = NULL;
-
-  mInfo("db:%s, all vgroups will be update in sdb", pAlterDb->name);
-
-  while (1) {
-    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
-    if (pVgroup == NULL) break;
-
-    if (pVgroup->pDb == pAlterDb) {
-      mnodeVgroupUpdateIdPool(pVgroup);
-    }
-
-    mnodeDecVgroupRef(pVgroup);
-  }
-
-  mInfo("db:%s, all vgroups is updated in sdb", pAlterDb->name);
-}
-#endif
-
-void mnodeDropAllDbVgroups(SDbObj *pDropDb) {
-  void *  pIter = NULL;
-  int32_t numOfVgroups = 0;
-  SVgObj *pVgroup = NULL;
-
-  mInfo("db:%s, all vgroups will be dropped from sdb", pDropDb->name);
-  while (1) {
-    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
-    if (pVgroup == NULL) break;
-
-    if (pVgroup->pDb == pDropDb) {
-      SSdbRow row = {
-        .type   = SDB_OPER_LOCAL,
-        .pTable = tsVgroupSdb,
-        .pObj   = pVgroup,
-      };
-      sdbDeleteRow(&row);
-      numOfVgroups++;
-    }
-
-    mnodeDecVgroupRef(pVgroup);
-  }
-
-  mInfo("db:%s, all vgroups:%d is dropped from sdb", pDropDb->name, numOfVgroups);
-}
-
-void mnodeSendDropAllDbVgroupsMsg(SDbObj *pDropDb) {
-  void *  pIter = NULL;
-  int32_t numOfVgroups = 0;
-  SVgObj *pVgroup = NULL;
-
-  mInfo("db:%s, all vgroups will be dropped in dnode", pDropDb->name);
-  while (1) {
-    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
-    if (pVgroup == NULL) break;
-
-    if (pVgroup->pDb == pDropDb) {
-      mnodeSendDropVgroupMsg(pVgroup, NULL);
-    }
-
-    mnodeDecVgroupRef(pVgroup);
-    numOfVgroups++;
-  }
-
-  mInfo("db:%s, all vgroups:%d drop msg is sent to dnode", pDropDb->name, numOfVgroups);
-}
-
-int32_t mnodeGetVgidVer(int8_t *cver) {
-  int32_t iver = ((int32_t)cver[0]) * 10000 + ((int32_t)cver[1]) * 100 + (int32_t)cver[2];
-  return iver;
-}
-
-void mnodeSetVgidVer(int8_t *cver, uint64_t iver) {
-  cver[0] = (int8_t)((int32_t)(iver % 1000000) / 10000);
-  cver[1] = (int8_t)((int32_t)(iver % 100000) / 100);
-  cver[2] = (int8_t)(iver % 100);
-}
-
-int32_t mnodeCompactVgroups() {
-  void *pIter = NULL;
-  SVgObj *pVgroup = NULL;
-
-  mInfo("start to compact vgroups table...");
-
-  while (1) {
-    pIter = mnodeGetNextVgroup(pIter, &pVgroup);
-    if (pVgroup == NULL) break;
-
-    SSdbRow row = {
-      .type     = SDB_OPER_GLOBAL,
-      .pTable   = tsVgroupSdb,
-      .pObj     = pVgroup,
-      .rowSize  = sizeof(SVgObj),
-    };
-
-    mInfo("compact vgroups %d", pVgroup->vgId);
-    
-    sdbInsertCompactRow(&row);
-  }
-
-  mInfo("end to compact vgroups table...");
-
-  return 0; 
-}

src/mnode/src/mnodeWrite.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosdef.h"
-#include "tsched.h"
-#include "tbn.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("msg:%p, app:%p type:%s content is null", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
-    return TSDB_CODE_MND_INVALID_MSG_LEN;
-  }
-
-  if (!sdbIsMaster()) {
-    SMnodeRsp *rpcRsp = &pMsg->rpcRsp;
-    SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
-    mnodeGetMnodeEpSetForShell(epSet, true);
-    rpcRsp->rsp = epSet;
-    rpcRsp->len = sizeof(SRpcEpSet);
-
-    mDebug("msg:%p, app:%p type:%s in write queue, is redirected, numOfEps:%d inUse:%d", pMsg,
-           pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], epSet->numOfEps, epSet->inUse);
-
-    return TSDB_CODE_RPC_REDIRECT;
-  }
-
-  if (tsMnodeProcessWriteMsgFp[pMsg->rpcMsg.msgType] == NULL) {
-    mError("msg:%p, app:%p type:%s not processed", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
-    return TSDB_CODE_MND_MSG_NOT_PROCESSED;
-  }
-
-  int32_t code = grantCheck(TSDB_GRANT_TIME);
-  if (code != TSDB_CODE_SUCCESS) {
-    mError("msg:%p, app:%p type:%s not processed, reason:%s", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType],
-           tstrerror(code));
-    return code;
-  }
-
-  code = mnodeInitMsg(pMsg);
-  if (code != TSDB_CODE_SUCCESS) {
-    mError("msg:%p, app:%p type:%s not processed, reason:%s", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType],
-           tstrerror(code));
-    return code;
-  }
-
-  if (!pMsg->pUser->writeAuth) {
-    mError("msg:%p, app:%p type:%s not processed, no write auth", pMsg, pMsg->rpcMsg.ahandle,
-           taosMsg[pMsg->rpcMsg.msgType]);
-    return TSDB_CODE_MND_NO_RIGHTS;
-  }
-
-  return (*tsMnodeProcessWriteMsgFp[pMsg->rpcMsg.msgType])(pMsg);
-}