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.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_*/
\ No newline at end of file
+#endif /*_TD_MNODE_INT_H_*/

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