Merge pull request #8407 from taosdata/feature/dnode3

Feature/dnode3

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/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/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/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_*/

src/mnode/inc/mnodePeer.h → source/server/mnode/inc/mnodeMnode.h

@@ -13,21 +13,22 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_MNODE_PEER_H
-#define TDENGINE_MNODE_PEER_H
+#ifndef _TD_MNODE_MNODE_H_
+#define _TD_MNODE_MNODE_H_
+
+#include "mnodeInt.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "mnodeDef.h"
 
-void    mnodeAddPeerRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg));
-void    mnodeAddPeerMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg));
-int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg);
-void    mnodeProcessPeerRsp(SRpcMsg *pMsg);
+int32_t mnodeInitMnode();
+void    mnodeCleanupMnode();
+void    mnodeGetMnodeEpSetForPeer(SRpcEpSet *epSet, bool redirect);
+void    mnodeGetMnodeEpSetForShell(SRpcEpSet *epSet, bool redirect);
 
 #ifdef __cplusplus
 }
 #endif
 
-#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/util/src/terror.c

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

source/util/src/tstep.c

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

source/util/src/tworker.c

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

src/mnode/CMakeLists.txt

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

src/mnode/CMakeLists.txt.in

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

src/mnode/inc/mnodeAcct.h

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

src/mnode/inc/mnodeDb.h

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

src/mnode/inc/mnodeDnode.h

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

src/mnode/inc/mnodeInt.h

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

src/mnode/inc/mnodeMnode.h

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

src/mnode/inc/mnodeProfile.h

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TDENGINE_MNODE_PROFILE_H
-#define TDENGINE_MNODE_PROFILE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "mnodeDef.h"
-
-typedef struct {
-  char     user[TSDB_USER_LEN];
-  char     appName[TSDB_APPNAME_LEN];  // app name that invokes taosc
-  uint32_t pid;                        // pid of app that invokes taosc
-  int8_t   killed;
-  uint16_t port;
-  uint32_t ip;
-  uint32_t connId;
-  uint64_t stime;
-  uint64_t lastAccess;
-  uint32_t queryId;
-  uint32_t streamId;
-  int32_t  numOfQueries;
-  int32_t  numOfStreams;
-  SStreamDesc *pStreams;
-  SQueryDesc * pQueries;
-} SConnObj;
-
-int32_t mnodeInitProfile();
-void    mnodeCleanupProfile();
-
-SConnObj *mnodeCreateConn(char *user, uint32_t ip, uint16_t port, int32_t pid, const char* app);
-SConnObj *mnodeAccquireConn(int32_t connId, char *user, uint32_t ip, uint16_t port);
-void      mnodeReleaseConn(SConnObj *pConn);
-int32_t   mnodeSaveQueryStreamList(SConnObj *pConn, SHeartBeatMsg *pHBMsg);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
\ No newline at end of file

src/mnode/inc/mnodeSdb.h

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

src/mnode/inc/mnodeShow.h

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

src/mnode/inc/mnodeTable.h

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

src/mnode/inc/mnodeUser.h

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

src/mnode/inc/mnodeVgroup.h

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

src/mnode/src/mnodeAcct.c

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

src/mnode/src/mnodeGrant.c

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

src/mnode/src/mnodeInt.c

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

src/mnode/src/mnodePeer.c

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