Merge branch '3.0' into 3.0_refact

.gitignore

@@ -18,6 +18,7 @@ mac/
 .mypy_cache
 *.tmp
 *.swp
+*.orig
 src/connector/nodejs/node_modules/
 src/connector/nodejs/out/
 tests/test/

Jenkinsfile

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

include/common/taosmsg.h

@@ -363,6 +363,8 @@ typedef struct {
 } SConnectRsp;
 
 typedef struct {
+  char    user[TSDB_USER_LEN];
+  char    pass[TSDB_KEY_LEN];
   int32_t maxUsers;
   int32_t maxDbs;
   int32_t maxTimeSeries;
@@ -374,12 +376,6 @@ typedef struct {
   int64_t maxInbound;
   int64_t maxOutbound;
   int8_t  accessState;  // Configured only by command
-} SAcctCfg;
-
-typedef struct {
-  char     user[TSDB_USER_LEN];
-  char     pass[TSDB_KEY_LEN];
-  SAcctCfg cfg;
 } SCreateAcctMsg, SAlterAcctMsg;
 
 typedef struct {
@@ -661,15 +657,18 @@ typedef struct SVgroupAccess {
 } SVgroupAccess;
 
 typedef struct {
-  int32_t  dnodeId;
-  uint32_t moduleStatus;
-  uint32_t numOfVnodes;
-  char     clusterId[TSDB_CLUSTER_ID_LEN];
-  char     reserved[16];
+  int32_t dnodeId;
+  int8_t  dropped;
+  char    reserved[19];
+  int64_t clusterId;
+  int32_t numOfDnodes;
+  int32_t numOfVnodes;
 } SDnodeCfg;
 
 typedef struct {
   int32_t  dnodeId;
+  int8_t   isMnode;
+  int8_t   reserved;
   uint16_t dnodePort;
   char     dnodeFqdn[TSDB_FQDN_LEN];
 } SDnodeEp;
@@ -680,55 +679,29 @@ typedef struct {
 } SDnodeEps;
 
 typedef struct {
-  int32_t mnodeId;
-  char    mnodeEp[TSDB_EP_LEN];
-} SMInfo;
-
-typedef struct SMInfos {
-  int8_t inUse;
-  int8_t mnodeNum;
-  SMInfo mnodeInfos[TSDB_MAX_REPLICA];
-} SMInfos;
-
-typedef struct {
-  int32_t  numOfMnodes;               // tsNumOfMnodes
-  int32_t  mnodeEqualVnodeNum;        // tsMnodeEqualVnodeNum
-  int32_t  offlineThreshold;          // tsOfflineThreshold
-  int32_t  statusInterval;            // tsStatusInterval
-  int32_t  maxtablesPerVnode;
-  int32_t  maxVgroupsPerDb;
-  char     arbitrator[TSDB_EP_LEN];   // tsArbitrator
-  char     reserve[2];                // to solve arm32 bus error
-  char     timezone[64];              // tsTimezone
-  int64_t  checkTime;                 // 1970-01-01 00:00:00.000
-  char     locale[TSDB_LOCALE_LEN];   // tsLocale
-  char     charset[TSDB_LOCALE_LEN];  // tsCharset
-  int8_t   enableBalance;             // tsEnableBalance
-  int8_t   flowCtrl;
-  int8_t   slaveQuery;
-  int8_t   adjustMaster;
-  int8_t   reserved[4];
+  int32_t statusInterval;  // tsStatusInterval
+  int8_t  reserved[36];
+  int64_t checkTime;                 // 1970-01-01 00:00:00.000
+  char    timezone[64];              // tsTimezone
+  char    locale[TSDB_LOCALE_LEN];   // tsLocale
+  char    charset[TSDB_LOCALE_LEN];  // tsCharset
 } SClusterCfg;
 
 typedef struct SStatusMsg {
   uint32_t    version;
   int32_t     dnodeId;
+  uint32_t    lastReboot;  // time stamp for last reboot
+  int32_t     openVnodes;
+  int32_t     numOfCores;
+  float       diskAvailable;
+  int8_t      reserved[36];
   char        dnodeEp[TSDB_EP_LEN];
-  uint32_t    moduleStatus;
-  uint32_t    lastReboot;        // time stamp for last reboot
-  uint16_t    reserve1;          // from config file
-  uint16_t    openVnodes;
-  uint16_t    numOfCores;
-  float       diskAvailable;  // GB
-  char        clusterId[TSDB_CLUSTER_ID_LEN];
-  uint8_t     alternativeRole;
-  uint8_t     reserve2[15];
+  int64_t     clusterId;
   SClusterCfg clusterCfg;
   SVnodeLoad  load[];
 } SStatusMsg;
 
 typedef struct {
-  SMInfos       mnodes;
   SDnodeCfg     dnodeCfg;
   SVgroupAccess vgAccess[];
 } SStatusRsp;
@@ -864,9 +837,9 @@ typedef struct {
 } SCreateDnodeMsg, SDropDnodeMsg;
 
 typedef struct {
-  int32_t dnodeId;
-  char    dnodeEp[TSDB_EP_LEN];  // end point, hostname:port
-  SMInfos mnodes;
+  int32_t  dnodeId;
+  int32_t  mnodeNum;
+  SDnodeEp mnodeEps[];
 } SCreateMnodeMsg;
 
 typedef struct {

include/common/tglobal.h

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

include/libs/sync/sync.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_RAFT_SYNC_H
-#define TDENGINE_RAFT_SYNC_H
+#ifndef _TD_LIBS_SYNC_H
+#define _TD_LIBS_SYNC_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -24,9 +24,9 @@ extern "C" {
 #include "taosdef.h"
 #include "wal.h"
 
-typedef uint32_t SyncNodeId;
-typedef int32_t  SyncGroupId;
-typedef int64_t  SyncIndex;
+typedef int64_t SyncNodeId;
+typedef int32_t SyncGroupId;
+typedef int64_t   SyncIndex;
 typedef uint64_t SSyncTerm;
 
 typedef enum {
@@ -41,9 +41,8 @@ typedef struct {
 } SSyncBuffer;
 
 typedef struct {
-  SyncNodeId nodeId;                   // node ID assigned by TDengine
-  uint16_t   nodePort;                 // node sync Port
-  char       nodeFqdn[TSDB_FQDN_LEN];  // node FQDN
+  uint16_t  nodePort;  // node sync Port
+  char      nodeFqdn[TSDB_FQDN_LEN]; // node FQDN  
 } SNodeInfo;
 
 typedef struct {
@@ -53,13 +52,12 @@ typedef struct {
 } SSyncCluster;
 
 typedef struct {
-  int32_t     selfIndex;
-  int         nNode;
-  SyncNodeId* nodeId;
+  int32_t  selfIndex;
+  int nNode;
+  SNodeInfo* node;
   ESyncRole*  role;
 } SNodesRole;
 
-struct SSyncFSM;
 typedef struct SSyncFSM {
   void* pData;
 
@@ -86,8 +84,8 @@ typedef struct SSyncFSM {
 } SSyncFSM;
 
 typedef struct SSyncServerState {
-  SyncNodeId voteFor;
-  SSyncTerm  term;
+  SNodeInfo voteFor;
+  SSyncTerm term;
 } SSyncServerState;
 
 typedef struct SStateManager {
@@ -107,8 +105,8 @@ typedef struct {
 
   twalh walHandle;
 
-  SyncIndex    snapshotIndex;  // initial version
-  SSyncCluster syncCfg;        // configuration from mgmt
+  SyncIndex snapshotIndex;
+  SSyncCluster syncCfg;
 
   SSyncFSM fsm;
 
@@ -123,10 +121,14 @@ void       syncStop(SyncNodeId);
 
 int32_t syncPropose(SyncNodeId nodeId, SSyncBuffer buffer, void* pData, bool isWeak);
 
-extern int32_t raftDebugFlag;
+int32_t syncAddNode(SyncNodeId nodeId, const SNodeInfo *pNode);
+
+int32_t syncRemoveNode(SyncNodeId nodeId, const SNodeInfo *pNode);
+
+extern int32_t  syncDebugFlag;
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // TDENGINE_RAFT_SYNC_H
+#endif  /*_TD_LIBS_SYNC_H*/

include/libs/wal/wal.h

@@ -58,9 +58,9 @@ void     walStop(twalh);
 void     walClose(twalh);
 
 //write
-int64_t  walWriteWithMsgType(twalh, int8_t msgType, void* body, int32_t bodyLen);
+//int64_t  walWriteWithMsgType(twalh, int8_t msgType, void* body, int32_t bodyLen);
 int64_t  walWrite(twalh, void* body, int32_t bodyLen);
-int64_t  walWriteBatch(twalh, void* body, int32_t* bodyLen, int32_t batchSize);
+int64_t  walWriteBatch(twalh, void** bodies, int32_t* bodyLen, int32_t batchSize);
 
 //apis for lifecycle management
 void     walFsync(twalh, bool force);

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

@@ -65,7 +65,7 @@ void dnodeSendRedirectMsg(struct SRpcMsg *rpcMsg, bool forShell);
  * @param fqdn, the fqdn of dnode.
  * @param port, the port of dnode.
  */
-void dnodeGetDnodeEp(int32_t dnodeId, char *ep, char *fqdn, uint16_t *port);
+void dnodeGetEp(int32_t dnodeId, char *ep, char *fqdn, uint16_t *port);
 
 #ifdef __cplusplus
 }

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;
+  int64_t  clusterId;
+  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/server/vnode/tq/tq.h

@@ -24,9 +24,10 @@ extern "C" {
 
 typedef struct tmqMsgHead {
   int32_t headLen;
-  int32_t msgVer;
+  int32_t protoVer;
   int64_t cgId;
   int64_t topicId;
+  int64_t clientId;
   int32_t checksum;
   int32_t msgType;
 } tmqMsgHead;
@@ -34,35 +35,43 @@ typedef struct tmqMsgHead {
 //TODO: put msgs into common
 typedef struct tmqConnectReq {
   tmqMsgHead head;
-
 } tmqConnectReq;
 
 typedef struct tmqConnectResp {
-
+  tmqMsgHead head;
+  int8_t status;
 } tmqConnectResp;
 
 typedef struct tmqDisconnectReq {
-
+  tmqMsgHead head;
 } tmqDisconnectReq;
 
 typedef struct tmqDisconnectResp {
-
+  tmqMsgHead head;
+  int8_t status;
 } tmqDiconnectResp;
 
 typedef struct tmqConsumeReq {
-
+  tmqMsgHead head;
+  int64_t commitOffset;
 } tmqConsumeReq;
 
 typedef struct tmqConsumeResp {
-
+  tmqMsgHead head;
+  char content[];
 } tmqConsumeResp;
 
-typedef struct tmqSubscribeReq {
-
+//
+typedef struct tmqMnodeSubscribeReq {
+  tmqMsgHead head;
+  int64_t topicLen;
+  char topic[];
 } tmqSubscribeReq;
 
-typedef struct tmqSubscribeResp {
-
+typedef struct tmqMnodeSubscribeResp {
+  tmqMsgHead head;
+  int64_t vgId;
+  char ep[]; //TSDB_EP_LEN
 } tmqSubscribeResp;
 
 typedef struct tmqHeartbeatReq {
@@ -92,6 +101,24 @@ typedef struct STQ {
   //value=consumeOffset: int64_t
 } STQ;
 
+#define TQ_BUFFER_SIZE 8
+
+typedef struct tqBufferItem {
+  int64_t offset;
+  void* executor;
+  void* content;
+} tqBufferItem;
+
+typedef struct tqGroupHandle {
+  char* topic; //c style, end with '\0'
+  int64_t cgId;
+  void* ahandle;
+  int64_t consumeOffset;
+  int32_t head;
+  int32_t tail;
+  tqBufferItem buffer[TQ_BUFFER_SIZE];
+} tqGroupHandle;
+
 //init in each vnode
 STQ* tqInit(void* ref_func(void*), void* unref_func(void*));
 void tqCleanUp(STQ*);
@@ -103,6 +130,17 @@ int tqCommit(STQ*);
 //void* will be replace by a msg type
 int tqHandleConsumeMsg(STQ*, tmqConsumeReq* msg);
 
+tqGroupHandle* tqFindGHandleBycId(STQ*, int64_t cId);
+
+int tqOpenTCGroup(STQ*, int64_t topicId, int64_t cgId, int64_t cId);
+int tqCloseTCGroup(STQ*, int64_t topicId, int64_t cgId, int64_t cId);
+int tqMoveOffsetToNext(tqGroupHandle*);
+int tqResetOffset(STQ*, int64_t topicId, int64_t cgId, int64_t offset);
+int tqFetchMsg(tqGroupHandle*, void*);
+int tqRegisterContext(tqGroupHandle*, void*);
+int tqLaunchQuery(STQ*, int64_t topicId, int64_t cgId, void* query);
+int tqSendLaunchQuery(STQ*, int64_t topicId, int64_t cgId, void* query);
+
 #ifdef __cplusplus
 }
 #endif

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/client/CMakeLists.txt

@@ -7,4 +7,4 @@ target_include_directories(
 target_link_libraries(
     taos
     INTERFACE api
-)
\ No newline at end of file
+)

source/client/src/client.c

@@ -19,3 +19,5 @@
 //
 //}
 
+int  taos_init() { return 0; }
+void taos_cleanup(void) {}

source/common/src/tglobal.c

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

source/libs/sync/src/sync.c

@@ -13,4 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "sync.h"
\ No newline at end of file
+#include "sync.h"
+
+int32_t  syncInit() {return 0;}
+void syncCleanUp() {}
\ No newline at end of file

source/libs/wal/src/wal.c

@@ -11,4 +11,9 @@
  *
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
\ No newline at end of file
+ */
+
+#include "wal.h"
+
+int32_t  walInit() {return 0;}
+void walCleanUp() {}
\ No newline at end of file

source/server/dnode/CMakeLists.txt

@@ -5,6 +5,9 @@ target_link_libraries(
     PUBLIC cjson
     PUBLIC mnode
     PUBLIC vnode
+    PUBLIC wal
+    PUBLIC sync
+    PUBLIC taos
 )
 target_include_directories(
     dnode

source/server/dnode/inc/dnodeCfg.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_DNODE_CFG_H_
-#define _TD_DNODE_CFG_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "dnodeInt.h"
-
-
-int32_t dnodeInitCfg();
-void    dnodeCleanupCfg();
-void    dnodeUpdateCfg(SDnodeCfg *data);
-int32_t dnodeGetDnodeId();
-void    dnodeGetClusterId(char *clusterId);
-void    dnodeGetCfg(int32_t *dnodeId, char *clusterId);
-void    dnodeSetDropped();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DNODE_CFG_H_*/

source/server/dnode/inc/dnodeCheck.h

@@ -21,7 +21,6 @@ extern "C" {
 #endif
 #include "dnodeInt.h"
 
-
 int32_t dnodeInitCheck();
 void    dnodeCleanupCheck();
 

source/server/dnode/inc/dnodeEps.h

@@ -23,9 +23,17 @@ extern "C" {
 
 int32_t dnodeInitEps();
 void    dnodeCleanupEps();
-void    dnodeUpdateEps(SDnodeEps *data);
-bool    dnodeIsDnodeEpChanged(int32_t dnodeId, char *epstr);
-void    dnodeGetDnodeEp(int32_t dnodeId, char *epstr, char *fqdn, uint16_t *port);
+
+void    dnodeUpdateCfg(SDnodeCfg *data);
+void    dnodeUpdateDnodeEps(SDnodeEps *data);
+void    dnodeUpdateMnodeEps(SRpcEpSet *pEpSet);
+int32_t dnodeGetDnodeId();
+int64_t dnodeGetClusterId();
+void    dnodeGetEp(int32_t dnodeId, char *epstr, char *fqdn, uint16_t *port);
+
+void dnodeGetEpSetForPeer(SRpcEpSet *epSet);
+void dnodeGetEpSetForShell(SRpcEpSet *epSet);
+void dnodeSendRedirectMsg(SRpcMsg *rpcMsg, bool forShell);
 
 #ifdef __cplusplus
 }

source/server/dnode/inc/dnodeInt.h

@@ -19,9 +19,12 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+#include "os.h"
 #include "taosmsg.h"
+#include "tglobal.h"
 #include "tlog.h"
 #include "trpc.h"
+#include "ttimer.h"
 #include "dnode.h"
 
 extern int32_t dDebugFlag;
@@ -33,6 +36,12 @@ extern int32_t dDebugFlag;
 #define dDebug(...) { if (dDebugFlag & DEBUG_DEBUG) { taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); }}
 #define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); }}
 
+typedef enum { DN_RUN_STAT_INIT, DN_RUN_STAT_RUNNING, DN_RUN_STAT_STOPPED } EDnStat;
+
+EDnStat dnodeGetRunStat();
+void    dnodeSetRunStat();
+void    dnodeGetStartup(SStartupStep *);
+
 #ifdef __cplusplus
 }
 #endif

source/server/dnode/inc/dnodeMain.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_DNODE_MAIN_H_
-#define _TD_DNODE_MAIN_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "dnodeInt.h"
-
-typedef enum {
-  TD_RUN_STAT_INIT,
-  TD_RUN_STAT_RUNNING,
-  TD_RUN_STAT_STOPPED
-} RunStat;
-
-int32_t dnodeInitMain();
-void    dnodeCleanupMain();
-int32_t dnodeInitStorage();
-void    dnodeCleanupStorage();
-void    dnodeReportStartup(char *name, char *desc);
-void    dnodeReportStartupFinished(char *name, char *desc);
-void    dnodeProcessStartupReq(SRpcMsg *pMsg);
-void    dnodeProcessCreateMnodeReq(SRpcMsg *pMsg);
-void    dnodeProcessConfigDnodeReq(SRpcMsg *pMsg);
-RunStat dnodeGetRunStat();
-void    dnodeSetRunStat();
-void*   dnodeGetTimer();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DNODE_MAIN_H_*/

source/server/dnode/inc/dnodeMnodeEps.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_DNODE_MNODE_EP_H_
-#define _TD_DNODE_MNODE_EP_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "dnodeInt.h"
-
-int32_t dnodeInitMnodeEps();
-void    dnodeCleanupMnodeEps();
-void    dnodeUpdateMnodeFromStatus(SMInfos *pMinfos);
-void    dnodeUpdateMnodeFromPeer(SRpcEpSet *pEpSet);
-void    dnodeGetEpSetForPeer(SRpcEpSet *epSet);
-void    dnodeGetEpSetForShell(SRpcEpSet *epSet);
-void    dnodeSendRedirectMsg(SRpcMsg *rpcMsg, bool forShell);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DNODE_MNODE_EP_H_*/

source/server/dnode/inc/dnodeStatus.h → source/server/dnode/inc/dnodeMsg.h

@@ -21,9 +21,12 @@ extern "C" {
 #endif
 #include "dnodeInt.h"
 
-int32_t dnodeInitStatus();
-void    dnodeCleanupStatus();
+int32_t dnodeInitMsg();
+void    dnodeCleanupMsg();
 void    dnodeProcessStatusRsp(SRpcMsg *pMsg);
+void    dnodeProcessStartupReq(SRpcMsg *pMsg);
+void    dnodeProcessCreateMnodeReq(SRpcMsg *pMsg);
+void    dnodeProcessConfigDnodeReq(SRpcMsg *pMsg);
 
 #ifdef __cplusplus
 }

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/dnodeCfg.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 "cJSON.h"
-#include "tglobal.h"
-#include "dnodeCfg.h"
-
-static struct DnCfg {
-  int32_t         dnodeId;
-  int32_t         dropped;
-  char            clusterId[TSDB_CLUSTER_ID_LEN];
-  char            file[PATH_MAX + 20];
-  pthread_mutex_t mutex;
-} tsDcfg;
-
-static int32_t dnodeReadCfg() {
-  int32_t len = 0;
-  int32_t maxLen = 200;
-  char *  content = calloc(1, maxLen + 1);
-  cJSON * root = NULL;
-  FILE *  fp = NULL;
-
-  fp = fopen(tsDcfg.file, "r");
-  if (!fp) {
-    dDebug("file %s not exist", tsDcfg.file);
-    goto PARSE_CFG_OVER;
-  }
-
-  len = (int32_t)fread(content, 1, maxLen, fp);
-  if (len <= 0) {
-    dError("failed to read %s since content is null", tsDcfg.file);
-    goto PARSE_CFG_OVER;
-  }
-
-  content[len] = 0;
-  root = cJSON_Parse(content);
-  if (root == NULL) {
-    dError("failed to read %s since invalid json format", tsDcfg.file);
-    goto PARSE_CFG_OVER;
-  }
-
-  cJSON *dnodeId = cJSON_GetObjectItem(root, "dnodeId");
-  if (!dnodeId || dnodeId->type != cJSON_Number) {
-    dError("failed to read %s since dnodeId not found", tsDcfg.file);
-    goto PARSE_CFG_OVER;
-  }
-  tsDcfg.dnodeId = (int32_t)dnodeId->valueint;
-
-  cJSON *dropped = cJSON_GetObjectItem(root, "dropped");
-  if (!dropped || dropped->type != cJSON_Number) {
-    dError("failed to read %s since dropped not found", tsDcfg.file);
-    goto PARSE_CFG_OVER;
-  }
-  tsDcfg.dropped = (int32_t)dropped->valueint;
-
-  cJSON *clusterId = cJSON_GetObjectItem(root, "clusterId");
-  if (!clusterId || clusterId->type != cJSON_String) {
-    dError("failed to read %s since clusterId not found", tsDcfg.file);
-    goto PARSE_CFG_OVER;
-  }
-  tstrncpy(tsDcfg.clusterId, clusterId->valuestring, TSDB_CLUSTER_ID_LEN);
-
-  dInfo("successed to read %s", tsDcfg.file);
-
-PARSE_CFG_OVER:
-  if (content != NULL) free(content);
-  if (root != NULL) cJSON_Delete(root);
-  if (fp != NULL) fclose(fp);
-  terrno = 0;
-
-  return 0;
-}
-
-static int32_t dnodeWriteCfg() {
-  FILE *fp = fopen(tsDcfg.file, "w");
-  if (!fp) {
-    dError("failed to write %s since %s", tsDcfg.file, strerror(errno));
-    return -1;
-  }
-
-  int32_t len = 0;
-  int32_t maxLen = 200;
-  char *  content = calloc(1, maxLen + 1);
-
-  len += snprintf(content + len, maxLen - len, "{\n");
-  len += snprintf(content + len, maxLen - len, "  \"dnodeId\": %d,\n", tsDcfg.dnodeId);
-  len += snprintf(content + len, maxLen - len, "  \"dropped\": %d,\n", tsDcfg.dropped);
-  len += snprintf(content + len, maxLen - len, "  \"clusterId\": \"%s\"\n", tsDcfg.clusterId);
-  len += snprintf(content + len, maxLen - len, "}\n");
-
-  fwrite(content, 1, len, fp);
-  taosFsyncFile(fileno(fp));
-  fclose(fp);
-  free(content);
-  terrno = 0;
-
-  dInfo("successed to write %s", tsDcfg.file);
-  return 0;
-}
-
-int32_t dnodeInitCfg() {
-  tsDcfg.dnodeId = 0;
-  tsDcfg.dropped = 0;
-  tsDcfg.clusterId[0] = 0;
-  snprintf(tsDcfg.file, sizeof(tsDcfg.file), "%s/dnodeCfg.json", tsDnodeDir);
-  pthread_mutex_init(&tsDcfg.mutex, NULL);
-  
-  int32_t ret = dnodeReadCfg();
-  if (ret == 0) {
-    dInfo("dnode cfg is initialized");
-  }
-
-  if (tsDcfg.dropped) {
-    dInfo("dnode is dropped and start to exit");
-    return -1;
-  }
-
-  return ret;
-}
-
-void dnodeCleanupCfg() {
-  pthread_mutex_destroy(&tsDcfg.mutex);
-}
-
-void dnodeUpdateCfg(SDnodeCfg *data) {
-  if (tsDcfg.dnodeId != 0) return;
-
-  pthread_mutex_lock(&tsDcfg.mutex);
-
-  tsDcfg.dnodeId = data->dnodeId;
-  tstrncpy(tsDcfg.clusterId, data->clusterId, TSDB_CLUSTER_ID_LEN);
-  dInfo("dnodeId is set to %d, clusterId is set to %s", data->dnodeId, data->clusterId);
-
-  dnodeWriteCfg();
-  pthread_mutex_unlock(&tsDcfg.mutex);
-}
-
-void dnodeSetDropped() {
-  pthread_mutex_lock(&tsDcfg.mutex);
-  tsDcfg.dropped = 1;
-  dnodeWriteCfg();
-  pthread_mutex_unlock(&tsDcfg.mutex);
-}
-
-int32_t dnodeGetDnodeId() {
-  int32_t dnodeId = 0;
-  pthread_mutex_lock(&tsDcfg.mutex);
-  dnodeId = tsDcfg.dnodeId;
-  pthread_mutex_unlock(&tsDcfg.mutex);
-  return dnodeId;
-}
-
-void dnodeGetClusterId(char *clusterId) {
-  pthread_mutex_lock(&tsDcfg.mutex);
-  tstrncpy(clusterId, tsDcfg.clusterId, TSDB_CLUSTER_ID_LEN);
-  pthread_mutex_unlock(&tsDcfg.mutex);
-}
-
-void dnodeGetCfg(int32_t *dnodeId, char *clusterId) {
-  pthread_mutex_lock(&tsDcfg.mutex);
-  *dnodeId = tsDcfg.dnodeId;
-  tstrncpy(clusterId, tsDcfg.clusterId, TSDB_CLUSTER_ID_LEN);
-  pthread_mutex_unlock(&tsDcfg.mutex);
-}

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

@@ -14,131 +14,250 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "os.h"
+#include "dnodeEps.h"
 #include "cJSON.h"
 #include "thash.h"
-#include "tglobal.h"
-#include "dnodeEps.h"
-#include "dnodeCfg.h"
 
 static struct {
-  int32_t         dnodeId;
-  int32_t         dnodeNum;
-  SDnodeEp *      dnodeList;
-  SHashObj *      dnodeHash;
-  char            file[PATH_MAX + 20];
+  int32_t    dnodeId;
+  int32_t    dropped;
+  int64_t    clusterId;
+  SDnodeEps *dnodeEps;
+  SHashObj  *dnodeHash;
+  SRpcEpSet  mnodeEpSetForShell;
+  SRpcEpSet  mnodeEpSetForPeer;
+  char       file[PATH_MAX + 20];
   pthread_mutex_t mutex;
-} tsDeps;
+} tsEps;
+
+void dnodeGetEpSetForPeer(SRpcEpSet *epSet) {
+  pthread_mutex_lock(&tsEps.mutex);
+  *epSet = tsEps.mnodeEpSetForPeer;
+  pthread_mutex_unlock(&tsEps.mutex);
+}
+
+void dnodeGetEpSetForShell(SRpcEpSet *epSet) {
+  pthread_mutex_lock(&tsEps.mutex);
+  *epSet = tsEps.mnodeEpSetForShell;
+  pthread_mutex_unlock(&tsEps.mutex);
+}
+
+void dnodeUpdateMnodeEps(SRpcEpSet *ep) {
+  if (ep != NULL || ep->numOfEps <= 0) {
+    dError("mnode is changed, but content is invalid, discard it");
+    return;
+  }
+
+  pthread_mutex_lock(&tsEps.mutex);
+
+  dInfo("mnode is changed, num:%d use:%d", ep->numOfEps, ep->inUse);
+
+  tsEps.mnodeEpSetForPeer = *ep;
+  for (int32_t i = 0; i < ep->numOfEps; ++i) {
+    ep->port[i] -= TSDB_PORT_DNODEDNODE;
+    dInfo("mnode index:%d %s:%u", i, ep->fqdn[i], ep->port[i]);
+  }
+  tsEps.mnodeEpSetForShell = *ep;
+
+  pthread_mutex_unlock(&tsEps.mutex);
+}
+
+void dnodeSendRedirectMsg(SRpcMsg *rpcMsg, bool forShell) {
+  SRpcConnInfo connInfo = {0};
+  rpcGetConnInfo(rpcMsg->handle, &connInfo);
+
+  SRpcEpSet epSet = {0};
+  if (forShell) {
+    dnodeGetEpSetForShell(&epSet);
+  } else {
+    dnodeGetEpSetForPeer(&epSet);
+  }
+
+  dDebug("msg:%s will be redirected, num:%d use:%d", taosMsg[rpcMsg->msgType], epSet.numOfEps, epSet.inUse);
+
+  for (int32_t i = 0; i < epSet.numOfEps; ++i) {
+    dDebug("mnode index:%d %s:%d", i, epSet.fqdn[i], epSet.port[i]);
+    if (strcmp(epSet.fqdn[i], tsLocalFqdn) == 0) {
+      if ((epSet.port[i] == tsServerPort + TSDB_PORT_DNODEDNODE && !forShell) ||
+          (epSet.port[i] == tsServerPort && forShell)) {
+        epSet.inUse = (i + 1) % epSet.numOfEps;
+        dDebug("mnode index:%d %s:%d set inUse to %d", i, epSet.fqdn[i], epSet.port[i], epSet.inUse);
+      }
+    }
+
+    epSet.port[i] = htons(epSet.port[i]);
+  }
+
+  rpcSendRedirectRsp(rpcMsg->handle, &epSet);
+}
 
 static void dnodePrintEps() {
-  dDebug("print dnodeEp, dnodeNum:%d", tsDeps.dnodeNum);
-  for (int32_t i = 0; i < tsDeps.dnodeNum; i++) {
-    SDnodeEp *ep = &tsDeps.dnodeList[i];
-    dDebug("dnode:%d, dnodeFqdn:%s dnodePort:%u", ep->dnodeId, ep->dnodeFqdn, ep->dnodePort);
+  dDebug("print dnode list, num:%d", tsEps.dnodeEps->dnodeNum);
+  for (int32_t i = 0; i < tsEps.dnodeEps->dnodeNum; i++) {
+    SDnodeEp *ep = &tsEps.dnodeEps->dnodeEps[i];
+    dDebug("dnode:%d, fqdn:%s port:%u isMnode:%d", ep->dnodeId, ep->dnodeFqdn, ep->dnodePort, ep->isMnode);
   }
 }
 
 static void dnodeResetEps(SDnodeEps *data) {
   assert(data != NULL);
 
-  if (data->dnodeNum > tsDeps.dnodeNum) {
-    SDnodeEp *tmp = calloc(data->dnodeNum, sizeof(SDnodeEp));
+  int32_t size = sizeof(SDnodeEps) + data->dnodeNum * sizeof(SDnodeEp);
+
+  if (data->dnodeNum > tsEps.dnodeEps->dnodeNum) {
+    SDnodeEps *tmp = calloc(1, size);
     if (tmp == NULL) return;
 
-    tfree(tsDeps.dnodeList);
-    tsDeps.dnodeList = tmp;
-    tsDeps.dnodeNum = data->dnodeNum;
-    memcpy(tsDeps.dnodeList, data->dnodeEps, tsDeps.dnodeNum * sizeof(SDnodeEp));
-    dnodePrintEps();
+    tfree(tsEps.dnodeEps);
+    tsEps.dnodeEps = tmp;
+  }
 
-    for (int32_t i = 0; i < tsDeps.dnodeNum; ++i) {
-      SDnodeEp *ep = &tsDeps.dnodeList[i];
-      taosHashPut(tsDeps.dnodeHash, &ep->dnodeId, sizeof(int32_t), ep, sizeof(SDnodeEp));
-    }
+  if (tsEps.dnodeEps != data) {
+    memcpy(tsEps.dnodeEps, data, size);
+  }
+
+  tsEps.mnodeEpSetForPeer.inUse = 0;
+  tsEps.mnodeEpSetForShell.inUse = 0;
+  int32_t index = 0;
+  for (int32_t i = 0; i < tsEps.dnodeEps->dnodeNum; i++) {
+    SDnodeEp *ep = &tsEps.dnodeEps->dnodeEps[i];
+    if (!ep->isMnode) continue;
+    if (index >= TSDB_MAX_REPLICA) continue;
+    strcpy(tsEps.mnodeEpSetForShell.fqdn[index], ep->dnodeFqdn);
+    strcpy(tsEps.mnodeEpSetForPeer.fqdn[index], ep->dnodeFqdn);
+    tsEps.mnodeEpSetForShell.port[index] = ep->dnodePort;
+    tsEps.mnodeEpSetForShell.port[index] = ep->dnodePort + tsDnodeDnodePort;
+    index++;
+  }
+
+  for (int32_t i = 0; i < tsEps.dnodeEps->dnodeNum; ++i) {
+    SDnodeEp *ep = &tsEps.dnodeEps->dnodeEps[i];
+    taosHashPut(tsEps.dnodeHash, &ep->dnodeId, sizeof(int32_t), ep, sizeof(SDnodeEp));
   }
+
+  dnodePrintEps();
+}
+
+static bool dnodeIsDnodeEpChanged(int32_t dnodeId, char *epstr) {
+  bool changed = false;
+
+  pthread_mutex_lock(&tsEps.mutex);
+
+  SDnodeEp *ep = taosHashGet(tsEps.dnodeHash, &dnodeId, sizeof(int32_t));
+  if (ep != NULL) {
+    char epSaved[TSDB_EP_LEN + 1];
+    snprintf(epSaved, TSDB_EP_LEN, "%s:%u", ep->dnodeFqdn, ep->dnodePort);
+    changed = strcmp(epstr, epSaved) != 0;
+    tstrncpy(epstr, epSaved, TSDB_EP_LEN);
+  }
+
+  pthread_mutex_unlock(&tsEps.mutex);
+
+  return changed;
 }
 
 static int32_t dnodeReadEps() {
   int32_t len = 0;
   int32_t maxLen = 30000;
-  char *  content = calloc(1, maxLen + 1);
-  cJSON * root = NULL;
-  FILE *  fp = NULL;
+  char   *content = calloc(1, maxLen + 1);
+  cJSON  *root = NULL;
+  FILE   *fp = NULL;
 
-  fp = fopen(tsDeps.file, "r");
+  fp = fopen(tsEps.file, "r");
   if (!fp) {
-    dDebug("file %s not exist", tsDeps.file);
+    dDebug("file %s not exist", tsEps.file);
     goto PRASE_EPS_OVER;
   }
 
   len = (int32_t)fread(content, 1, maxLen, fp);
   if (len <= 0) {
-    dError("failed to read %s since content is null", tsDeps.file);
+    dError("failed to read %s since content is null", tsEps.file);
     goto PRASE_EPS_OVER;
   }
 
   content[len] = 0;
   root = cJSON_Parse(content);
   if (root == NULL) {
-    dError("failed to read %s since invalid json format", tsDeps.file);
+    dError("failed to read %s since invalid json format", tsEps.file);
+    goto PRASE_EPS_OVER;
+  }
+
+  cJSON *dnodeId = cJSON_GetObjectItem(root, "dnodeId");
+  if (!dnodeId || dnodeId->type != cJSON_String) {
+    dError("failed to read %s since dnodeId not found", tsEps.file);
     goto PRASE_EPS_OVER;
   }
+  tsEps.dnodeId = atoi(dnodeId->valuestring);
 
-  cJSON *dnodeNum = cJSON_GetObjectItem(root, "dnodeNum");
-  if (!dnodeNum || dnodeNum->type != cJSON_Number) {
-    dError("failed to read %s since dnodeNum not found", tsDeps.file);
+  cJSON *dropped = cJSON_GetObjectItem(root, "dropped");
+  if (!dropped || dropped->type != cJSON_String) {
+    dError("failed to read %s since dropped not found", tsEps.file);
     goto PRASE_EPS_OVER;
   }
+  tsEps.dropped = atoi(dropped->valuestring);
+
+  cJSON *clusterId = cJSON_GetObjectItem(root, "clusterId");
+  if (!clusterId || clusterId->type != cJSON_String) {
+    dError("failed to read %s since clusterId not found", tsEps.file);
+    goto PRASE_EPS_OVER;
+  }
+  tsEps.clusterId = atoll(clusterId->valuestring);
 
   cJSON *dnodeInfos = cJSON_GetObjectItem(root, "dnodeInfos");
   if (!dnodeInfos || dnodeInfos->type != cJSON_Array) {
-    dError("failed to read %s since dnodeInfos not found", tsDeps.file);
+    dError("failed to read %s since dnodeInfos not found", tsEps.file);
     goto PRASE_EPS_OVER;
   }
 
   int32_t dnodeInfosSize = cJSON_GetArraySize(dnodeInfos);
-  if (dnodeInfosSize != dnodeNum->valueint) {
-    dError("failed to read %s since dnodeInfos size:%d not matched dnodeNum:%d", tsDeps.file, dnodeInfosSize,
-           (int32_t)dnodeNum->valueint);
+  if (dnodeInfosSize <= 0) {
+    dError("failed to read %s since dnodeInfos size:%d invalid", tsEps.file, dnodeInfosSize);
     goto PRASE_EPS_OVER;
   }
 
-  tsDeps.dnodeNum = dnodeInfosSize;
-  tsDeps.dnodeList = calloc(dnodeInfosSize, sizeof(SDnodeEp));
-  if (tsDeps.dnodeList == NULL) {
+  tsEps.dnodeEps = calloc(1, dnodeInfosSize * sizeof(SDnodeEp) + sizeof(SDnodeEps));
+  if (tsEps.dnodeEps == NULL) {
     dError("failed to calloc dnodeEpList since %s", strerror(errno));
     goto PRASE_EPS_OVER;
   }
+  tsEps.dnodeEps->dnodeNum = dnodeInfosSize;
 
   for (int32_t i = 0; i < dnodeInfosSize; ++i) {
     cJSON *dnodeInfo = cJSON_GetArrayItem(dnodeInfos, i);
     if (dnodeInfo == NULL) break;
 
-    SDnodeEp *ep = &tsDeps.dnodeList[i];
+    SDnodeEp *ep = &tsEps.dnodeEps->dnodeEps[i];
 
     cJSON *dnodeId = cJSON_GetObjectItem(dnodeInfo, "dnodeId");
-    if (!dnodeId || dnodeId->type != cJSON_Number) {
-      dError("failed to read %s, dnodeId not found", tsDeps.file);
+    if (!dnodeId || dnodeId->type != cJSON_String) {
+      dError("failed to read %s, dnodeId not found", tsEps.file);
+      goto PRASE_EPS_OVER;
+    }
+    ep->dnodeId = atoi(dnodeId->valuestring);
+
+    cJSON *isMnode = cJSON_GetObjectItem(dnodeInfo, "isMnode");
+    if (!isMnode || isMnode->type != cJSON_String) {
+      dError("failed to read %s, isMnode not found", tsEps.file);
       goto PRASE_EPS_OVER;
     }
-    ep->dnodeId = (int32_t)dnodeId->valueint;
+    ep->isMnode = atoi(isMnode->valuestring);
 
     cJSON *dnodeFqdn = cJSON_GetObjectItem(dnodeInfo, "dnodeFqdn");
     if (!dnodeFqdn || dnodeFqdn->type != cJSON_String || dnodeFqdn->valuestring == NULL) {
-      dError("failed to read %s, dnodeFqdn not found", tsDeps.file);
+      dError("failed to read %s, dnodeFqdn not found", tsEps.file);
       goto PRASE_EPS_OVER;
     }
     tstrncpy(ep->dnodeFqdn, dnodeFqdn->valuestring, TSDB_FQDN_LEN);
 
     cJSON *dnodePort = cJSON_GetObjectItem(dnodeInfo, "dnodePort");
-    if (!dnodePort || dnodePort->type != cJSON_Number) {
-      dError("failed to read %s, dnodePort not found", tsDeps.file);
+    if (!dnodePort || dnodePort->type != cJSON_String) {
+      dError("failed to read %s, dnodePort not found", tsEps.file);
       goto PRASE_EPS_OVER;
     }
-    ep->dnodePort = (uint16_t)dnodePort->valueint;
+    ep->dnodePort = atoi(dnodePort->valuestring);
   }
 
-  dInfo("succcessed to read file %s", tsDeps.file);
+  dInfo("succcessed to read file %s", tsEps.file);
   dnodePrintEps();
 
 PRASE_EPS_OVER:
@@ -146,35 +265,40 @@ PRASE_EPS_OVER:
   if (root != NULL) cJSON_Delete(root);
   if (fp != NULL) fclose(fp);
 
-  if (dnodeIsDnodeEpChanged(tsDeps.dnodeId, tsLocalEp)) {
-    dError("dnode:%d, localEp different from %s dnodeEps.json and need reconfigured", tsDeps.dnodeId, tsLocalEp);
+  if (dnodeIsDnodeEpChanged(tsEps.dnodeId, tsLocalEp)) {
+    dError("dnode:%d, localEp %s different with dnodeEps.json and need reconfigured", tsEps.dnodeId, tsLocalEp);
     return -1;
   }
 
+  dnodeResetEps(tsEps.dnodeEps);
+
   terrno = 0;
   return 0;
 }
 
 static int32_t dnodeWriteEps() {
-  FILE *fp = fopen(tsDeps.file, "w");
+  FILE *fp = fopen(tsEps.file, "w");
   if (!fp) {
-    dError("failed to write %s since %s", tsDeps.file, strerror(errno));
+    dError("failed to write %s since %s", tsEps.file, strerror(errno));
     return -1;
   }
 
   int32_t len = 0;
   int32_t maxLen = 30000;
-  char *  content = calloc(1, maxLen + 1);
+  char   *content = calloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
-  len += snprintf(content + len, maxLen - len, "  \"dnodeNum\": %d,\n", tsDeps.dnodeNum);
+  len += snprintf(content + len, maxLen - len, "  \"dnodeId\": \"%d\",\n", tsEps.dnodeId);
+  len += snprintf(content + len, maxLen - len, "  \"dropped\": \"%d\",\n", tsEps.dropped);
+  len += snprintf(content + len, maxLen - len, "  \"clusterId\": \"%" PRId64 "\",\n", tsEps.clusterId);
   len += snprintf(content + len, maxLen - len, "  \"dnodeInfos\": [{\n");
-  for (int32_t i = 0; i < tsDeps.dnodeNum; ++i) {
-    SDnodeEp *ep = &tsDeps.dnodeList[i];
-    len += snprintf(content + len, maxLen - len, "    \"dnodeId\": %d,\n", ep->dnodeId);
+  for (int32_t i = 0; i < tsEps.dnodeEps->dnodeNum; ++i) {
+    SDnodeEp *ep = &tsEps.dnodeEps->dnodeEps[i];
+    len += snprintf(content + len, maxLen - len, "    \"dnodeId\": \"%d\",\n", ep->dnodeId);
+    len += snprintf(content + len, maxLen - len, "    \"isMnode\": \"%d\",\n", ep->isMnode);
     len += snprintf(content + len, maxLen - len, "    \"dnodeFqdn\": \"%s\",\n", ep->dnodeFqdn);
-    len += snprintf(content + len, maxLen - len, "    \"dnodePort\": %u\n", ep->dnodePort);
-    if (i < tsDeps.dnodeNum - 1) {
+    len += snprintf(content + len, maxLen - len, "    \"dnodePort\": \"%u\"\n", ep->dnodePort);
+    if (i < tsEps.dnodeEps->dnodeNum - 1) {
       len += snprintf(content + len, maxLen - len, "  },{\n");
     } else {
       len += snprintf(content + len, maxLen - len, "  }]\n");
@@ -188,18 +312,20 @@ static int32_t dnodeWriteEps() {
   free(content);
   terrno = 0;
 
-  dInfo("successed to write %s", tsDeps.file);
+  dInfo("successed to write %s", tsEps.file);
   return 0;
 }
 
 int32_t dnodeInitEps() {
-  tsDeps.dnodeHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK);
-  if (tsDeps.dnodeHash == NULL) return -1;
+  tsEps.dnodeId = 0;
+  tsEps.dropped = 0;
+  tsEps.clusterId = 0;
+  tsEps.dnodeEps = NULL;
+  snprintf(tsEps.file, sizeof(tsEps.file), "%s/dnodeEps.json", tsDnodeDir);
+  pthread_mutex_init(&tsEps.mutex, NULL);
 
-  tsDeps.dnodeId = dnodeGetDnodeId();
-  tsDeps.dnodeNum = 0;
-  snprintf(tsDeps.file, sizeof(tsDeps.file), "%s/dnodeEps.json", tsDnodeDir);
-  pthread_mutex_init(&tsDeps.mutex, NULL);
+  tsEps.dnodeHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK);
+  if (tsEps.dnodeHash == NULL) return -1;
 
   int32_t ret = dnodeReadEps();
   if (ret == 0) {
@@ -210,75 +336,80 @@ int32_t dnodeInitEps() {
 }
 
 void dnodeCleanupEps() {
-  pthread_mutex_lock(&tsDeps.mutex);
+  pthread_mutex_lock(&tsEps.mutex);
 
-  if (tsDeps.dnodeList != NULL) {
-    free(tsDeps.dnodeList);
-    tsDeps.dnodeList = NULL;
+  if (tsEps.dnodeEps != NULL) {
+    free(tsEps.dnodeEps);
+    tsEps.dnodeEps = NULL;
   }
 
-  if (tsDeps.dnodeHash) {
-    taosHashCleanup(tsDeps.dnodeHash);
-    tsDeps.dnodeHash = NULL;
+  if (tsEps.dnodeHash) {
+    taosHashCleanup(tsEps.dnodeHash);
+    tsEps.dnodeHash = NULL;
   }
 
-  tsDeps.dnodeNum = 0;
-  pthread_mutex_unlock(&tsDeps.mutex);
-  pthread_mutex_destroy(&tsDeps.mutex);
+  pthread_mutex_unlock(&tsEps.mutex);
+  pthread_mutex_destroy(&tsEps.mutex);
 }
 
-void dnodeUpdateEps(SDnodeEps *data) {
+void dnodeUpdateDnodeEps(SDnodeEps *data) {
   if (data == NULL || data->dnodeNum <= 0) return;
 
-  data->dnodeNum = htonl(data->dnodeNum);
-  for (int32_t i = 0; i < data->dnodeNum; ++i) {
-    data->dnodeEps[i].dnodeId = htonl(data->dnodeEps[i].dnodeId);
-    data->dnodeEps[i].dnodePort = htons(data->dnodeEps[i].dnodePort);
-  }
+  pthread_mutex_lock(&tsEps.mutex);
 
-  pthread_mutex_lock(&tsDeps.mutex);
-
-  if (data->dnodeNum != tsDeps.dnodeNum) {
+  if (data->dnodeNum != tsEps.dnodeEps->dnodeNum) {
     dnodeResetEps(data);
     dnodeWriteEps();
   } else {
-    int32_t size = data->dnodeNum * sizeof(SDnodeEp);
-    if (memcmp(tsDeps.dnodeList, data->dnodeEps, size) != 0) {
+    int32_t size = data->dnodeNum * sizeof(SDnodeEp) + sizeof(SDnodeEps);
+    if (memcmp(tsEps.dnodeEps, data, size) != 0) {
       dnodeResetEps(data);
       dnodeWriteEps();
     }
   }
 
-  pthread_mutex_unlock(&tsDeps.mutex);
+  pthread_mutex_unlock(&tsEps.mutex);
 }
 
-bool dnodeIsDnodeEpChanged(int32_t dnodeId, char *epstr) {
-  bool changed = false;
-
-  pthread_mutex_lock(&tsDeps.mutex);
+void dnodeGetEp(int32_t dnodeId, char *epstr, char *fqdn, uint16_t *port) {
+  pthread_mutex_lock(&tsEps.mutex);
 
-  SDnodeEp *ep = taosHashGet(tsDeps.dnodeHash, &dnodeId, sizeof(int32_t));
+  SDnodeEp *ep = taosHashGet(tsEps.dnodeHash, &dnodeId, sizeof(int32_t));
   if (ep != NULL) {
-    char epSaved[TSDB_EP_LEN + 1];
-    snprintf(epSaved, TSDB_EP_LEN, "%s:%u", ep->dnodeFqdn, ep->dnodePort);
-    changed = strcmp(epstr, epSaved) != 0;
-    tstrncpy(epstr, epSaved, TSDB_EP_LEN);
+    if (port) *port = ep->dnodePort;
+    if (fqdn) tstrncpy(fqdn, ep->dnodeFqdn, TSDB_FQDN_LEN);
+    if (epstr) snprintf(epstr, TSDB_EP_LEN, "%s:%u", ep->dnodeFqdn, ep->dnodePort);
   }
 
-  pthread_mutex_unlock(&tsDeps.mutex);
-
-  return changed;
+  pthread_mutex_unlock(&tsEps.mutex);
 }
 
-void dnodeGetDnodeEp(int32_t dnodeId, char *epstr, char *fqdn, uint16_t *port) {
-  pthread_mutex_lock(&tsDeps.mutex);
+void dnodeUpdateCfg(SDnodeCfg *data) {
+  if (tsEps.dnodeId != 0 && !data->dropped) return;
 
-  SDnodeEp *ep = taosHashGet(tsDeps.dnodeHash, &dnodeId, sizeof(int32_t));
-  if (ep != NULL) {
-    if (port) *port = ep->dnodePort;
-    if (fqdn) tstrncpy(fqdn, ep->dnodeFqdn, TSDB_FQDN_LEN);
-    if (epstr) snprintf(epstr, TSDB_EP_LEN, "%s:%u", ep->dnodeFqdn, ep->dnodePort);
-  }
+  pthread_mutex_lock(&tsEps.mutex);
+
+  tsEps.dnodeId = data->dnodeId;
+  tsEps.clusterId = data->clusterId;
+  tsEps.dropped = data->dropped;
+  dInfo("dnodeId is set to %d, clusterId is set to %" PRId64, data->dnodeId, data->clusterId);
+
+  dnodeWriteEps();
+  pthread_mutex_unlock(&tsEps.mutex);
+}
+
+int32_t dnodeGetDnodeId() {
+  int32_t dnodeId = 0;
+  pthread_mutex_lock(&tsEps.mutex);
+  dnodeId = tsEps.dnodeId;
+  pthread_mutex_unlock(&tsEps.mutex);
+  return dnodeId;
+}
 
-  pthread_mutex_unlock(&tsDeps.mutex);
+int64_t dnodeGetClusterId() {
+  int64_t clusterId = 0;
+  pthread_mutex_lock(&tsEps.mutex);
+  clusterId = tsEps.clusterId;
+  pthread_mutex_unlock(&tsEps.mutex);
+  return clusterId;
 }

source/server/dnode/src/dnodeInt.c

@@ -14,71 +14,178 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "os.h"
-#if 0
-#include "qScript.h"
-#include "tfile.h"
-#include "tsync.h"
-#include "twal.h"
-#endif
-#include "tstep.h"
-#include "dnodeCfg.h"
 #include "dnodeCheck.h"
 #include "dnodeEps.h"
-#include "dnodeMain.h"
-#include "dnodeMnodeEps.h"
-#include "dnodeStatus.h"
-#include "dnodeTelem.h"
+#include "dnodeMsg.h"
 #include "dnodeTrans.h"
 #include "mnode.h"
+#include "sync.h"
+#include "tcache.h"
+#include "tconfig.h"
+#include "tnote.h"
+#include "tstep.h"
 #include "vnode.h"
+#include "wal.h"
+
+static struct {
+  EDnStat      runStatus;
+  SStartupStep startup;
+  SSteps      *steps;
+} tsDnode;
+
+EDnStat dnodeGetRunStat() { return tsDnode.runStatus; }
+
+void dnodeSetRunStat(EDnStat stat) { tsDnode.runStatus = stat; }
+
+static void dnodeReportStartup(char *name, char *desc) {
+  SStartupStep *startup = &tsDnode.startup;
+  tstrncpy(startup->name, name, strlen(startup->name));
+  tstrncpy(startup->desc, desc, strlen(startup->desc));
+  startup->finished = 0;
+}
+
+static void dnodeReportStartupFinished(char *name, char *desc) {
+  SStartupStep *startup = &tsDnode.startup;
+  tstrncpy(startup->name, name, strlen(startup->name));
+  tstrncpy(startup->desc, desc, strlen(startup->desc));
+  startup->finished = 1;
+}
 
-static struct SSteps *tsSteps;
+void dnodeGetStartup(SStartupStep *pStep) { memcpy(pStep, &tsDnode.startup, sizeof(SStartupStep)); }
 
-static int32_t dnodeInitVnodeModule(void **unused) {
+static int32_t dnodeInitVnode() {
   SVnodePara para;
-  para.fp.GetDnodeEp = dnodeGetDnodeEp;
+  para.fp.GetDnodeEp = dnodeGetEp;
   para.fp.SendMsgToDnode = dnodeSendMsgToDnode;
   para.fp.SendMsgToMnode = dnodeSendMsgToMnode;
 
   return vnodeInit(para);
 }
 
-static int32_t dnodeInitMnodeModule(void **unused) {
+static int32_t dnodeInitMnode() {
   SMnodePara para;
-  para.fp.GetDnodeEp = dnodeGetDnodeEp;
+  para.fp.GetDnodeEp = dnodeGetEp;
   para.fp.SendMsgToDnode = dnodeSendMsgToDnode;
   para.fp.SendMsgToMnode = dnodeSendMsgToMnode;
   para.fp.SendRedirectMsg = dnodeSendRedirectMsg;
-  dnodeGetCfg(&para.dnodeId, para.clusterId);
+  para.dnodeId = dnodeGetDnodeId();
+  para.clusterId = dnodeGetClusterId();
 
   return mnodeInit(para);
 }
 
+static int32_t dnodeInitTfs() {}
+
+static int32_t dnodeInitMain() {
+  tsDnode.runStatus = DN_RUN_STAT_STOPPED;
+  tscEmbedded = 1;
+  taosIgnSIGPIPE();
+  taosBlockSIGPIPE();
+  taosResolveCRC();
+  taosInitGlobalCfg();
+  taosReadGlobalLogCfg();
+  taosSetCoreDump(tsEnableCoreFile);
+
+  if (!taosMkDir(tsLogDir)) {
+    printf("failed to create dir: %s, reason: %s\n", tsLogDir, strerror(errno));
+    return -1;
+  }
+
+  char temp[TSDB_FILENAME_LEN];
+  sprintf(temp, "%s/taosdlog", tsLogDir);
+  if (taosInitLog(temp, tsNumOfLogLines, 1) < 0) {
+    printf("failed to init log file\n");
+  }
+
+  if (!taosReadGlobalCfg()) {
+    taosPrintGlobalCfg();
+    dError("TDengine read global config failed");
+    return -1;
+  }
+
+  dInfo("start to initialize TDengine");
+
+  taosInitNotes();
+
+  return taosCheckGlobalCfg();
+}
+
+static void dnodeCleanupMain() {
+  taos_cleanup();
+  taosCloseLog();
+  taosStopCacheRefreshWorker();
+}
+
+static int32_t dnodeCheckRunning(char *dir) {
+  char filepath[256] = {0};
+  snprintf(filepath, sizeof(filepath), "%s/.running", dir);
+
+  FileFd fd = taosOpenFileCreateWriteTrunc(filepath);
+  if (fd < 0) {
+    dError("failed to open lock file:%s since %s, quit", filepath, strerror(errno));
+    return -1;
+  }
+
+  int32_t ret = taosLockFile(fd);
+  if (ret != 0) {
+    dError("failed to lock file:%s since %s, quit", filepath, strerror(errno));
+    taosCloseFile(fd);
+    return -1;
+  }
+
+  return 0;
+}
+
+static int32_t dnodeInitDir() {
+  sprintf(tsMnodeDir, "%s/mnode", tsDataDir);
+  sprintf(tsVnodeDir, "%s/vnode", tsDataDir);
+  sprintf(tsDnodeDir, "%s/dnode", tsDataDir);
+
+  if (!taosMkDir(tsDnodeDir)) {
+    dError("failed to create dir:%s since %s", tsDnodeDir, strerror(errno));
+    return -1;
+  }
+
+  if (!taosMkDir(tsMnodeDir)) {
+    dError("failed to create dir:%s since %s", tsMnodeDir, strerror(errno));
+    return -1;
+  }
+
+  if (!taosMkDir(tsVnodeDir)) {
+    dError("failed to create dir:%s since %s", tsVnodeDir, strerror(errno));
+    return -1;
+  }
+
+  if (dnodeCheckRunning(tsDnodeDir) != 0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+static void dnodeCleanupDir() {}
+
 int32_t dnodeInit() {
-  tsSteps = taosStepInit(24, dnodeReportStartup);
-  if (tsSteps == NULL) return -1;
-
-  taosStepAdd(tsSteps, "dnode-main", dnodeInitMain, dnodeCleanupMain);
-  taosStepAdd(tsSteps, "dnode-storage", dnodeInitStorage, dnodeCleanupStorage);
-  //taosStepAdd(tsSteps, "dnode-tfs", tfInit, tfCleanup);
-  taosStepAdd(tsSteps, "dnode-rpc", rpcInit, rpcCleanup);
-  taosStepAdd(tsSteps, "dnode-check", dnodeInitCheck, dnodeCleanupCheck);
-  taosStepAdd(tsSteps, "dnode-cfg", dnodeInitCfg, dnodeCleanupCfg);
-  taosStepAdd(tsSteps, "dnode-deps", dnodeInitEps, dnodeCleanupEps);
-  taosStepAdd(tsSteps, "dnode-meps", dnodeInitMnodeEps, dnodeCleanupMnodeEps);
-  //taosStepAdd(tsSteps, "dnode-wal", walInit, walCleanUp);
-  //taosStepAdd(tsSteps, "dnode-sync", syncInit, syncCleanUp);
-  taosStepAdd(tsSteps, "dnode-vnode", dnodeInitVnodeModule, vnodeCleanup);
-  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);
+  SSteps *steps = taosStepInit(24, dnodeReportStartup);
+  if (steps == NULL) return -1;
+
+  taosStepAdd(steps, "dnode-main", dnodeInitMain, dnodeCleanupMain);
+  taosStepAdd(steps, "dnode-dir", dnodeInitDir, dnodeCleanupDir);
+  taosStepAdd(steps, "dnode-check", dnodeInitCheck, dnodeCleanupCheck);
+  taosStepAdd(steps, "dnode-rpc", rpcInit, rpcCleanup);
+  taosStepAdd(steps, "dnode-tfs", dnodeInitTfs, NULL);
+  taosStepAdd(steps, "dnode-wal", walInit, walCleanUp);
+  taosStepAdd(steps, "dnode-sync", syncInit, syncCleanUp);
+  taosStepAdd(steps, "dnode-eps", dnodeInitEps, dnodeCleanupEps);
+  taosStepAdd(steps, "dnode-vnode", dnodeInitVnode, vnodeCleanup);
+  taosStepAdd(steps, "dnode-mnode", dnodeInitMnode, mnodeCleanup);
+  taosStepAdd(steps, "dnode-trans", dnodeInitTrans, dnodeCleanupTrans);
+  taosStepAdd(steps, "dnode-msg", dnodeInitMsg, dnodeCleanupMsg);
+
+  tsDnode.steps = steps;
+  taosStepExec(tsDnode.steps);
+
+  dnodeSetRunStat(DN_RUN_STAT_RUNNING);
   dnodeReportStartupFinished("TDengine", "initialized successfully");
   dInfo("TDengine is initialized successfully");
 
@@ -86,9 +193,9 @@ int32_t dnodeInit() {
 }
 
 void dnodeCleanup() {
-  if (dnodeGetRunStat() != TD_RUN_STAT_STOPPED) {
-    dnodeSetRunStat(TD_RUN_STAT_STOPPED);
-    taosStepCleanup(tsSteps);
-    tsSteps = NULL;
+  if (dnodeGetRunStat() != DN_RUN_STAT_STOPPED) {
+    dnodeSetRunStat(DN_RUN_STAT_STOPPED);
+    taosStepCleanup(tsDnode.steps);
+    tsDnode.steps = NULL;
   }
 }

source/server/dnode/src/dnodeMain.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 "tcache.h"
-#include "tconfig.h"
-#include "tglobal.h"
-#if 0
-#include "tfs.h"
-#endif
-#include "tnote.h"
-#include "tcompression.h"
-#include "ttimer.h"
-#include "dnodeCfg.h"
-#include "dnodeMain.h"
-#include "mnode.h"
-
-static struct {
-  RunStat      runStatus;
-  void *       dnodeTimer;
-  SStartupStep startup;
-} tsDmain;
-
-static void dnodeCheckDataDirOpenned(char *dir) {
-#if 0
-  char filepath[256] = {0};
-  snprintf(filepath, sizeof(filepath), "%s/.running", dir);
-
-  int32_t fd = open(filepath, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
-  if (fd < 0) {
-    dError("failed to open lock file:%s, reason: %s, quit", filepath, strerror(errno));
-    exit(0);
-  }
-
-  int32_t ret = flock(fd, LOCK_EX | LOCK_NB);
-  if (ret != 0) {
-    dError("failed to lock file:%s ret:%d since %s, database may be running, quit", filepath, ret, strerror(errno));
-    close(fd);
-    exit(0);
-  }
-#endif
-}
-
-int32_t dnodeInitMain() {
-  tsDmain.runStatus = TD_RUN_STAT_STOPPED;
-  tsDmain.dnodeTimer = taosTmrInit(100, 200, 60000, "DND-TMR");
-  if (tsDmain.dnodeTimer == NULL) {
-    dError("failed to init dnode timer");
-    return -1;
-  }
-
-  tscEmbedded = 1;
-  taosIgnSIGPIPE();
-  taosBlockSIGPIPE();
-  taosResolveCRC();
-  taosInitGlobalCfg();
-  taosReadGlobalLogCfg();
-  taosSetCoreDump(tsEnableCoreFile);
-
-  if (!taosMkDir(tsLogDir)) {
-   printf("failed to create dir: %s, reason: %s\n", tsLogDir, strerror(errno));
-   return -1;
-  }
-
-  char temp[TSDB_FILENAME_LEN];
-  sprintf(temp, "%s/taosdlog", tsLogDir);
-  if (taosInitLog(temp, tsNumOfLogLines, 1) < 0) {
-    printf("failed to init log file\n");
-  }
-
-  if (!taosReadGlobalCfg()) {
-    taosPrintGlobalCfg();
-    dError("TDengine read global config failed");
-    return -1;
-  }
-
-  dInfo("start to initialize TDengine");
-
-  taosInitNotes();
-
-  return taosCheckGlobalCfg();
-}
-
-void dnodeCleanupMain() {
-  if (tsDmain.dnodeTimer != NULL) {
-    taosTmrCleanUp(tsDmain.dnodeTimer);
-    tsDmain.dnodeTimer = NULL;
-  }
-
-#if 0
-  taos_cleanup();
-#endif
-  taosCloseLog();
-  taosStopCacheRefreshWorker();
-}
-
-int32_t dnodeInitStorage() {
-#ifdef TD_TSZ
-  // compress module init
-  tsCompressInit();
-#endif
-
-  // storage module init
-  if (tsDiskCfgNum == 1 && !taosMkDir(tsDataDir)) {
-    dError("failed to create dir:%s since %s", tsDataDir, strerror(errno));
-    return -1;
-  }
-
-#if 0
-  if (tfsInit(tsDiskCfg, tsDiskCfgNum) < 0) {
-    dError("failed to init TFS since %s", tstrerror(terrno));
-    return -1;
-  }
-
-  strncpy(tsDataDir, TFS_PRIMARY_PATH(), TSDB_FILENAME_LEN);
-#endif
-  sprintf(tsMnodeDir, "%s/mnode", tsDataDir);
-  sprintf(tsVnodeDir, "%s/vnode", tsDataDir);
-  sprintf(tsDnodeDir, "%s/dnode", tsDataDir);
-
-  if (!taosMkDir(tsMnodeDir)) {
-    dError("failed to create dir:%s since %s", tsMnodeDir, strerror(errno));
-    return -1;
-  }
-
-  if (!taosMkDir(tsDnodeDir)) {
-    dError("failed to create dir:%s since %s", tsDnodeDir, strerror(errno));
-    return -1;
-  }
-
-#if 0
-  if (tfsMkdir("vnode") < 0) {
-    dError("failed to create vnode dir since %s", tstrerror(terrno));
-    return -1;
-  }
-
-  if (tfsMkdir("vnode_bak") < 0) {
-    dError("failed to create vnode_bak dir since %s", tstrerror(terrno));
-    return -1;
-  }
-
-  TDIR *tdir = tfsOpendir("vnode_bak/.staging");
-  bool  stagingNotEmpty = tfsReaddir(tdir) != NULL;
-  tfsClosedir(tdir);
-
-  if (stagingNotEmpty) {
-    dError("vnode_bak/.staging dir not empty, fix it first.");
-    return -1;
-  }
-
-  if (tfsMkdir("vnode_bak/.staging") < 0) {
-    dError("failed to create vnode_bak/.staging dir since %s", tstrerror(terrno));
-    return -1;
-  }
-
-  dnodeCheckDataDirOpenned(tsDnodeDir);
-
-  taosGetDisk();
-  dnodePrintDiskInfo();
-#endif  
-
-  dInfo("dnode storage is initialized at %s", tsDnodeDir);
-  return 0;
-}
-
-void dnodeCleanupStorage() {
-#if 0
-  // storage destroy
-  tfsDestroy();
-
- #ifdef TD_TSZ
-  // compress destroy
-  tsCompressExit();
- #endif
-#endif
-}
-
-void dnodeReportStartup(char *name, char *desc) {
-  SStartupStep *startup = &tsDmain.startup;
-  tstrncpy(startup->name, name, strlen(startup->name));
-  tstrncpy(startup->desc, desc, strlen(startup->desc));
-  startup->finished = 0;
-}
-
-void dnodeReportStartupFinished(char *name, char *desc) {
-  SStartupStep *startup = &tsDmain.startup;
-  tstrncpy(startup->name, name, strlen(startup->name));
-  tstrncpy(startup->desc, desc, strlen(startup->desc));
-  startup->finished = 1;
-}
-
-void dnodeProcessStartupReq(SRpcMsg *pMsg) {
-  dInfo("startup msg is received, cont:%s", (char *)pMsg->pCont);
-
-  SStartupStep *pStep = rpcMallocCont(sizeof(SStartupStep));
-  memcpy(pStep, &tsDmain.startup, sizeof(SStartupStep));
-
-  dDebug("startup msg is sent, step:%s desc:%s finished:%d", pStep->name, pStep->desc, pStep->finished);
-
-  SRpcMsg rpcRsp = {.handle = pMsg->handle, .pCont = pStep, .contLen = sizeof(SStartupStep)};
-  rpcSendResponse(&rpcRsp);
-  rpcFreeCont(pMsg->pCont);
-}
-
-static int32_t dnodeStartMnode(SRpcMsg *pMsg) {
-  SCreateMnodeMsg *pCfg = pMsg->pCont;
-  pCfg->dnodeId = htonl(pCfg->dnodeId);
-  if (pCfg->dnodeId != dnodeGetDnodeId()) {
-    dDebug("dnode:%d, in create meps msg is not equal with saved dnodeId:%d", pCfg->dnodeId,
-           dnodeGetDnodeId());
-    return TSDB_CODE_MND_DNODE_ID_NOT_CONFIGURED;
-  }
-
-  if (strcmp(pCfg->dnodeEp, tsLocalEp) != 0) {
-    dDebug("dnodeEp:%s, in create meps msg is not equal with saved dnodeEp:%s", pCfg->dnodeEp, tsLocalEp);
-    return TSDB_CODE_MND_DNODE_EP_NOT_CONFIGURED;
-  }
-
-  dDebug("dnode:%d, create meps msg is received from mnodes, numOfMnodes:%d", pCfg->dnodeId, pCfg->mnodes.mnodeNum);
-  for (int32_t i = 0; i < pCfg->mnodes.mnodeNum; ++i) {
-    pCfg->mnodes.mnodeInfos[i].mnodeId = htonl(pCfg->mnodes.mnodeInfos[i].mnodeId);
-    dDebug("meps index:%d, meps:%d:%s", i, pCfg->mnodes.mnodeInfos[i].mnodeId, pCfg->mnodes.mnodeInfos[i].mnodeEp);
-  }
-
-  if (mnodeIsServing()) return 0;
-
-  return mnodeDeploy(&pCfg->mnodes);
-}
-
-void dnodeProcessCreateMnodeReq(SRpcMsg *pMsg) {
-  int32_t code = dnodeStartMnode(pMsg);
-
-  SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0, .code = code};
-
-  rpcSendResponse(&rspMsg);
-  rpcFreeCont(pMsg->pCont);
-}
-
-void dnodeProcessConfigDnodeReq(SRpcMsg *pMsg) {
-  SCfgDnodeMsg *pCfg = pMsg->pCont;
-
-  int32_t code = taosCfgDynamicOptions(pCfg->config);
-
-  SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0, .code = code};
-
-  rpcSendResponse(&rspMsg);
-  rpcFreeCont(pMsg->pCont);
-}
-
-RunStat dnodeGetRunStat() { return tsDmain.runStatus; }
-
-void dnodeSetRunStat(RunStat stat) { tsDmain.runStatus = stat; }
-
-void* dnodeGetTimer() { return tsDmain.dnodeTimer; }
\ No newline at end of file

source/server/dnode/src/dnodeMnodeEps.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 "cJSON.h"
-#include "tglobal.h"
-#include "dnodeCfg.h"
-#include "dnodeEps.h"
-#include "dnodeMnodeEps.h"
-#include "mnode.h"
-
-static struct {
-  SRpcEpSet       mnodeEpSet;
-  SMInfos         mnodeInfos;
-  char            file[PATH_MAX + 20];
-  pthread_mutex_t mutex;
-} tsDmeps;
-
-
-static void dnodePrintMnodeEps() {
-  SRpcEpSet *epset = &tsDmeps.mnodeEpSet;
-  dInfo("print mnode eps, num:%d inuse:%d", epset->numOfEps, epset->inUse);
-  for (int32_t i = 0; i < epset->numOfEps; i++) {
-    dInfo("ep index:%d, %s:%u", i, epset->fqdn[i], epset->port[i]);
-  }
-}
-
-static void dnodeResetMnodeEps(SMInfos *mInfos) {
-  if (mInfos == NULL || mInfos->mnodeNum == 0) {
-    tsDmeps.mnodeEpSet.numOfEps = 1;
-    taosGetFqdnPortFromEp(tsFirst, tsDmeps.mnodeEpSet.fqdn[0], &tsDmeps.mnodeEpSet.port[0]);
-
-    if (strcmp(tsSecond, tsFirst) != 0) {
-      tsDmeps.mnodeEpSet.numOfEps = 2;
-      taosGetFqdnPortFromEp(tsSecond, tsDmeps.mnodeEpSet.fqdn[1], &tsDmeps.mnodeEpSet.port[1]);
-    }
-    dnodePrintMnodeEps();
-    return;
-  }
-
-  int32_t size = sizeof(SMInfos);
-  memcpy(&tsDmeps.mnodeInfos, mInfos, size);
-
-  tsDmeps.mnodeEpSet.inUse = tsDmeps.mnodeInfos.inUse;
-  tsDmeps.mnodeEpSet.numOfEps = tsDmeps.mnodeInfos.mnodeNum;
-  for (int32_t i = 0; i < tsDmeps.mnodeInfos.mnodeNum; i++) {
-    taosGetFqdnPortFromEp(tsDmeps.mnodeInfos.mnodeInfos[i].mnodeEp, tsDmeps.mnodeEpSet.fqdn[i], &tsDmeps.mnodeEpSet.port[i]);
-  }
-
-  dnodePrintMnodeEps();
-}
-
-static int32_t dnodeWriteMnodeEps() {
-  FILE *fp = fopen(tsDmeps.file, "w");
-  if (!fp) {
-    dError("failed to write %s since %s", tsDmeps.file, strerror(errno));
-    return -1;
-  }
-
-  int32_t len = 0;
-  int32_t maxLen = 2000;
-  char *  content = calloc(1, maxLen + 1);
-
-  len += snprintf(content + len, maxLen - len, "{\n");
-  len += snprintf(content + len, maxLen - len, "  \"inUse\": %d,\n", tsDmeps.mnodeInfos.inUse);
-  len += snprintf(content + len, maxLen - len, "  \"nodeNum\": %d,\n", tsDmeps.mnodeInfos.mnodeNum);
-  len += snprintf(content + len, maxLen - len, "  \"nodeInfos\": [{\n");
-  for (int32_t i = 0; i < tsDmeps.mnodeInfos.mnodeNum; i++) {
-    len += snprintf(content + len, maxLen - len, "    \"nodeId\": %d,\n", tsDmeps.mnodeInfos.mnodeInfos[i].mnodeId);
-    len += snprintf(content + len, maxLen - len, "    \"nodeEp\": \"%s\"\n", tsDmeps.mnodeInfos.mnodeInfos[i].mnodeEp);
-    if (i < tsDmeps.mnodeInfos.mnodeNum - 1) {
-      len += snprintf(content + len, maxLen - len, "  },{\n");
-    } else {
-      len += snprintf(content + len, maxLen - len, "  }]\n");
-    }
-  }
-  len += snprintf(content + len, maxLen - len, "}\n");
-
-  fwrite(content, 1, len, fp);
-  taosFsyncFile(fileno(fp));
-  fclose(fp);
-  free(content);
-  terrno = 0;
-
-  dInfo("successed to write %s", tsDmeps.file);
-  return 0;
-}
-
-static int32_t dnodeReadMnodeEps() {
-  int32_t len = 0;
-  int32_t maxLen = 2000;
-  char *  content = calloc(1, maxLen + 1);
-  cJSON * root = NULL;
-  FILE *  fp = NULL;
-  SMInfos mInfos = {0};
-  bool    nodeChanged = false;
-
-  fp = fopen(tsDmeps.file, "r");
-  if (!fp) {
-    dDebug("file %s not exist", tsDmeps.file);
-    goto PARSE_MINFOS_OVER;
-  }
-
-  len = (int32_t)fread(content, 1, maxLen, fp);
-  if (len <= 0) {
-    dError("failed to read %s since content is null", tsDmeps.file);
-    goto PARSE_MINFOS_OVER;
-  }
-
-  content[len] = 0;
-  root = cJSON_Parse(content);
-  if (root == NULL) {
-    dError("failed to read %s since invalid json format", tsDmeps.file);
-    goto PARSE_MINFOS_OVER;
-  }
-
-  cJSON *inUse = cJSON_GetObjectItem(root, "inUse");
-  if (!inUse || inUse->type != cJSON_Number) {
-    dError("failed to read mnodeEpSet.json since inUse not found");
-    goto PARSE_MINFOS_OVER;
-  }
-  tsDmeps.mnodeInfos.inUse = (int8_t)inUse->valueint;
-
-  cJSON *nodeNum = cJSON_GetObjectItem(root, "nodeNum");
-  if (!nodeNum || nodeNum->type != cJSON_Number) {
-    dError("failed to read mnodeEpSet.json since nodeNum not found");
-    goto PARSE_MINFOS_OVER;
-  }
-  mInfos.mnodeNum = (int8_t)nodeNum->valueint;
-
-  cJSON *nodeInfos = cJSON_GetObjectItem(root, "nodeInfos");
-  if (!nodeInfos || nodeInfos->type != cJSON_Array) {
-    dError("failed to read mnodeEpSet.json since nodeInfos not found");
-    goto PARSE_MINFOS_OVER;
-  }
-
-  int32_t size = cJSON_GetArraySize(nodeInfos);
-  if (size != mInfos.mnodeNum) {
-    dError("failed to read mnodeEpSet.json since nodeInfos size not matched");
-    goto PARSE_MINFOS_OVER;
-  }
-
-  for (int32_t i = 0; i < size; ++i) {
-    cJSON *nodeInfo = cJSON_GetArrayItem(nodeInfos, i);
-    if (nodeInfo == NULL) continue;
-
-    cJSON *nodeId = cJSON_GetObjectItem(nodeInfo, "nodeId");
-    if (!nodeId || nodeId->type != cJSON_Number) {
-      dError("failed to read mnodeEpSet.json since nodeId not found");
-      goto PARSE_MINFOS_OVER;
-    }
-
-    cJSON *nodeEp = cJSON_GetObjectItem(nodeInfo, "nodeEp");
-    if (!nodeEp || nodeEp->type != cJSON_String || nodeEp->valuestring == NULL) {
-      dError("failed to read mnodeEpSet.json since nodeName not found");
-      goto PARSE_MINFOS_OVER;
-    }
-
-    SMInfo *mInfo = &mInfos.mnodeInfos[i];
-    mInfo->mnodeId = (int32_t)nodeId->valueint;
-    tstrncpy(mInfo->mnodeEp, nodeEp->valuestring, TSDB_EP_LEN);
-
-    bool changed = dnodeIsDnodeEpChanged(mInfo->mnodeId, mInfo->mnodeEp);
-    if (changed) nodeChanged = changed;
-  }
-
-  dInfo("successed to read file %s", tsDmeps.file);
-
-PARSE_MINFOS_OVER:
-  if (content != NULL) free(content);
-  if (root != NULL) cJSON_Delete(root);
-  if (fp != NULL) fclose(fp);
-  terrno = 0;
-
-  for (int32_t i = 0; i < mInfos.mnodeNum; ++i) {
-    SMInfo *mInfo = &mInfos.mnodeInfos[i];
-    dnodeGetDnodeEp(mInfo->mnodeId, mInfo->mnodeEp, NULL, NULL);
-  }
-
-  dnodeResetMnodeEps(&mInfos);
-
-  if (nodeChanged) {
-    dnodeWriteMnodeEps();
-  }
-
-  return 0;
-}
-
-void dnodeSendRedirectMsg(SRpcMsg *rpcMsg, bool forShell) {
-  SRpcConnInfo connInfo = {0};
-  rpcGetConnInfo(rpcMsg->handle, &connInfo);
-
-  SRpcEpSet epSet = {0};
-  if (forShell) {
-    dnodeGetEpSetForShell(&epSet);
-  } else {
-    dnodeGetEpSetForPeer(&epSet);
-  }
-
-  dDebug("msg:%s will be redirected, dnodeIp:%s user:%s, numOfEps:%d inUse:%d", taosMsg[rpcMsg->msgType],
-         taosIpStr(connInfo.clientIp), connInfo.user, epSet.numOfEps, epSet.inUse);
-
-  for (int32_t i = 0; i < epSet.numOfEps; ++i) {
-    dDebug("mnode index:%d %s:%d", i, epSet.fqdn[i], epSet.port[i]);
-    if (strcmp(epSet.fqdn[i], tsLocalFqdn) == 0) {
-      if ((epSet.port[i] == tsServerPort + TSDB_PORT_DNODEDNODE && !forShell) ||
-          (epSet.port[i] == tsServerPort && forShell)) {
-        epSet.inUse = (i + 1) % epSet.numOfEps;
-        dDebug("mnode index:%d %s:%d set inUse to %d", i, epSet.fqdn[i], epSet.port[i], epSet.inUse);
-      }
-    }
-
-    epSet.port[i] = htons(epSet.port[i]);
-  }
-
-  rpcSendRedirectRsp(rpcMsg->handle, &epSet);
-}
-
-int32_t dnodeInitMnodeEps() {
-  snprintf(tsDmeps.file, sizeof(tsDmeps.file), "%s/mnodeEpSet.json", tsDnodeDir);
-  pthread_mutex_init(&tsDmeps.mutex, NULL);
-
-  dnodeResetMnodeEps(NULL);
-  int32_t ret = dnodeReadMnodeEps();
-  if (ret == 0) {
-    dInfo("dnode mInfos is initialized");
-  }
-
-  return ret;
-}
-
-void dnodeCleanupMnodeEps() {
-  pthread_mutex_destroy(&tsDmeps.mutex);
-}
-
-void dnodeUpdateMnodeFromStatus(SMInfos *mInfos) {
-  if (mInfos->mnodeNum <= 0 || mInfos->mnodeNum > TSDB_MAX_REPLICA) {
-    dError("invalid mInfos since num:%d invalid", mInfos->mnodeNum);
-    return;
-  }
-
-  for (int32_t i = 0; i < mInfos->mnodeNum; ++i) {
-    SMInfo *minfo = &mInfos->mnodeInfos[i];
-    minfo->mnodeId = htonl(minfo->mnodeId);
-    if (minfo->mnodeId <= 0 || strlen(minfo->mnodeEp) <= 5) {
-      dError("invalid mInfo:%d since id:%d and ep:%s invalid", i, minfo->mnodeId, minfo->mnodeEp);
-      return;
-    }
-  }
-
-  pthread_mutex_lock(&tsDmeps.mutex);
-  if (mInfos->mnodeNum != tsDmeps.mnodeInfos.mnodeNum) {
-    dnodeResetMnodeEps(mInfos);
-    dnodeWriteMnodeEps();
-  } else {
-    int32_t size = sizeof(SMInfos);
-    if (memcmp(mInfos, &tsDmeps.mnodeInfos, size) != 0) {
-      dnodeResetMnodeEps(mInfos);
-      dnodeWriteMnodeEps();
-    }
-  }
-  pthread_mutex_unlock(&tsDmeps.mutex);
-}
-
-void dnodeUpdateMnodeFromPeer(SRpcEpSet *ep) {
-  if (ep->numOfEps <= 0) {
-    dError("mInfos is changed, but content is invalid, discard it");
-    return;
-  }
-
-  pthread_mutex_lock(&tsDmeps.mutex);
-
-  dInfo("mInfos is changed, numOfEps:%d inUse:%d", ep->numOfEps, ep->inUse);
-  for (int32_t i = 0; i < ep->numOfEps; ++i) {
-    ep->port[i] -= TSDB_PORT_DNODEDNODE;
-    dInfo("minfo:%d %s:%u", i, ep->fqdn[i], ep->port[i]);
-  }
-  tsDmeps.mnodeEpSet = *ep;
-
-  pthread_mutex_unlock(&tsDmeps.mutex);
-}
-
-void dnodeGetEpSetForPeer(SRpcEpSet *epSet) {
-  pthread_mutex_lock(&tsDmeps.mutex);
-
-  *epSet = tsDmeps.mnodeEpSet;
-  for (int32_t i = 0; i < epSet->numOfEps; ++i) {
-    epSet->port[i] += TSDB_PORT_DNODEDNODE;
-  }
-
-  pthread_mutex_unlock(&tsDmeps.mutex);
-}
-
-void dnodeGetEpSetForShell(SRpcEpSet *epSet) {
-  pthread_mutex_lock(&tsDmeps.mutex);
-  *epSet = tsDmeps.mnodeEpSet;
-  pthread_mutex_unlock(&tsDmeps.mutex);
-}

source/server/dnode/src/dnodeStatus.c → source/server/dnode/src/dnodeMsg.c

@@ -14,67 +14,44 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "os.h"
-#include "ttime.h"
-#include "ttimer.h"
-#include "tglobal.h"
-#include "dnodeCfg.h"
+#include "dnodeMsg.h"
 #include "dnodeEps.h"
-#include "dnodeMnodeEps.h"
-#include "dnodeStatus.h"
-#include "dnodeMain.h"
+#include "mnode.h"
+#include "tthread.h"
+#include "ttime.h"
 #include "vnode.h"
 
 static struct {
-  void *   dnodeTimer;
-  void *   statusTimer;
-  uint32_t rebootTime;
-} tsStatus;
-
-static void dnodeSendStatusMsg(void *handle, void *tmrId) {
-  if (tsStatus.statusTimer == NULL) {
-    taosTmrReset(dnodeSendStatusMsg, tsStatusInterval * 1000, NULL, tsStatus.dnodeTimer, &tsStatus.statusTimer);
-    dError("failed to start status timer");
-    return;
-  }
+  pthread_t *threadId;
+  bool       stop;
+  uint32_t   rebootTime;
+} tsMsg;
 
+static void dnodeSendStatusMsg() {
   int32_t     contLen = sizeof(SStatusMsg) + TSDB_MAX_VNODES * sizeof(SVnodeLoad);
   SStatusMsg *pStatus = rpcMallocCont(contLen);
   if (pStatus == NULL) {
-    taosTmrReset(dnodeSendStatusMsg, tsStatusInterval * 1000, NULL, tsStatus.dnodeTimer, &tsStatus.statusTimer);
     dError("failed to malloc status message");
     return;
   }
 
-  dnodeGetCfg(&pStatus->dnodeId, pStatus->clusterId);
-  pStatus->dnodeId = htonl(dnodeGetDnodeId());
   pStatus->version = htonl(tsVersion);
-  pStatus->lastReboot = htonl(tsStatus.rebootTime);
-  pStatus->numOfCores = htons((uint16_t)tsNumOfCores);
-  pStatus->diskAvailable = tsAvailDataDirGB;
-  pStatus->alternativeRole = tsAlternativeRole;
+  pStatus->dnodeId = htonl(dnodeGetDnodeId());
   tstrncpy(pStatus->dnodeEp, tsLocalEp, TSDB_EP_LEN);
+  pStatus->clusterId = htobe64(dnodeGetClusterId());
+  pStatus->lastReboot = htonl(tsMsg.rebootTime);
+  pStatus->numOfCores = htonl(tsNumOfCores);
+  pStatus->diskAvailable = tsAvailDataDirGB;
 
   // fill cluster cfg parameters
-  pStatus->clusterCfg.numOfMnodes = htonl(tsNumOfMnodes);
-  pStatus->clusterCfg.mnodeEqualVnodeNum = htonl(tsMnodeEqualVnodeNum);
-  pStatus->clusterCfg.offlineThreshold = htonl(tsOfflineThreshold);
   pStatus->clusterCfg.statusInterval = htonl(tsStatusInterval);
-  pStatus->clusterCfg.maxtablesPerVnode = htonl(tsMaxTablePerVnode);
-  pStatus->clusterCfg.maxVgroupsPerDb = htonl(tsMaxVgroupsPerDb);
-  tstrncpy(pStatus->clusterCfg.arbitrator, tsArbitrator, TSDB_EP_LEN);
-  tstrncpy(pStatus->clusterCfg.timezone, tsTimezone, 64);
   pStatus->clusterCfg.checkTime = 0;
+  tstrncpy(pStatus->clusterCfg.timezone, tsTimezone, 64);
   char timestr[32] = "1970-01-01 00:00:00.00";
   (void)taosParseTime(timestr, &pStatus->clusterCfg.checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
   tstrncpy(pStatus->clusterCfg.locale, tsLocale, TSDB_LOCALE_LEN);
   tstrncpy(pStatus->clusterCfg.charset, tsCharset, TSDB_LOCALE_LEN);
 
-  pStatus->clusterCfg.enableBalance = tsEnableBalance;
-  pStatus->clusterCfg.flowCtrl = tsEnableFlowCtrl;
-  pStatus->clusterCfg.slaveQuery = tsEnableSlaveQuery;
-  pStatus->clusterCfg.adjustMaster = tsEnableAdjustMaster;
-
   vnodeGetStatus(pStatus);
   contLen = sizeof(SStatusMsg) + pStatus->openVnodes * sizeof(SVnodeLoad);
   pStatus->openVnodes = htons(pStatus->openVnodes);
@@ -85,52 +62,113 @@ static void dnodeSendStatusMsg(void *handle, void *tmrId) {
 }
 
 void dnodeProcessStatusRsp(SRpcMsg *pMsg) {
-  if (pMsg->code != TSDB_CODE_SUCCESS) {
-    dError("status rsp is received, error:%s", tstrerror(pMsg->code));
-    if (pMsg->code == TSDB_CODE_MND_DNODE_NOT_EXIST) {
-      char clusterId[TSDB_CLUSTER_ID_LEN];
-      dnodeGetClusterId(clusterId);
-      if (clusterId[0] != '\0') {
-        dnodeSetDropped();
-        dError("exit zombie dropped dnode");
-        exit(EXIT_FAILURE);
-      }
-    }
-
-    taosTmrReset(dnodeSendStatusMsg, tsStatusInterval * 1000, NULL, tsStatus.dnodeTimer, &tsStatus.statusTimer);
-    return;
-  }
+  dTrace("status rsp is received, code:%s", tstrerror(pMsg->code));
+  if (pMsg->code != TSDB_CODE_SUCCESS) return;
 
   SStatusRsp *pStatusRsp = pMsg->pCont;
-  SMInfos *   minfos = &pStatusRsp->mnodes;
-  dnodeUpdateMnodeFromStatus(minfos);
 
   SDnodeCfg *pCfg = &pStatusRsp->dnodeCfg;
-  pCfg->numOfVnodes = htonl(pCfg->numOfVnodes);
-  pCfg->moduleStatus = htonl(pCfg->moduleStatus);
   pCfg->dnodeId = htonl(pCfg->dnodeId);
+  pCfg->clusterId = htobe64(pCfg->clusterId);
+  pCfg->numOfVnodes = htonl(pCfg->numOfVnodes);
+  pCfg->numOfDnodes = htonl(pCfg->numOfDnodes);
   dnodeUpdateCfg(pCfg);
 
+  if (pCfg->dropped) {
+    dError("status rsp is received, and set dnode to drop status");
+    return;
+  }
+
   vnodeSetAccess(pStatusRsp->vgAccess, pCfg->numOfVnodes);
 
-  SDnodeEps *pEps = (SDnodeEps *)((char *)pStatusRsp->vgAccess + pCfg->numOfVnodes * sizeof(SVgroupAccess));
-  dnodeUpdateEps(pEps);
+  SDnodeEps *eps = (SDnodeEps *)((char *)pStatusRsp->vgAccess + pCfg->numOfVnodes * sizeof(SVgroupAccess));
+  eps->dnodeNum = htonl(eps->dnodeNum);
+  for (int32_t i = 0; i < eps->dnodeNum; ++i) {
+    eps->dnodeEps[i].dnodeId = htonl(eps->dnodeEps[i].dnodeId);
+    eps->dnodeEps[i].dnodePort = htons(eps->dnodeEps[i].dnodePort);
+  }
+
+  dnodeUpdateDnodeEps(eps);
+}
 
-  taosTmrReset(dnodeSendStatusMsg, tsStatusInterval * 1000, NULL, tsStatus.dnodeTimer, &tsStatus.statusTimer);
+static void *dnodeThreadRoutine(void *param) {
+  int32_t ms = tsStatusInterval * 1000;
+  while (!tsMsg.stop) {
+    taosMsleep(ms);
+    dnodeSendStatusMsg();
+  }
 }
 
-int32_t dnodeInitStatus() {
-  tsStatus.statusTimer = NULL;
-  tsStatus.dnodeTimer = dnodeGetTimer();
-  tsStatus.rebootTime = taosGetTimestampSec();
-  taosTmrReset(dnodeSendStatusMsg, 500, NULL, tsStatus.dnodeTimer, &tsStatus.statusTimer);
-  dInfo("dnode status timer is initialized");
-  return TSDB_CODE_SUCCESS;
+int32_t dnodeInitMsg() {
+  tsMsg.stop = false;
+  tsMsg.rebootTime = taosGetTimestampSec();
+  tsMsg.threadId = taosCreateThread(dnodeThreadRoutine, NULL);
+  if (tsMsg.threadId == NULL) {
+    return -1;
+  }
+
+  dInfo("dnode msg is initialized");
+  return 0;
 }
 
-void dnodeCleanupStatus() {
-  if (tsStatus.statusTimer != NULL) {
-    taosTmrStopA(&tsStatus.statusTimer);
-    tsStatus.statusTimer = NULL;
+void dnodeCleanupMsg() {
+  if (tsMsg.threadId != NULL) {
+    tsMsg.stop = true;
+    taosDestoryThread(tsMsg.threadId);
+    tsMsg.threadId = NULL;
   }
+
+  dInfo("dnode msg is cleanuped");
+}
+
+static int32_t dnodeStartMnode(SRpcMsg *pMsg) {
+  SCreateMnodeMsg *pCfg = pMsg->pCont;
+  pCfg->dnodeId = htonl(pCfg->dnodeId);
+  pCfg->mnodeNum = htonl(pCfg->mnodeNum);
+  for (int32_t i = 0; i < pCfg->mnodeNum; ++i) {
+    pCfg->mnodeEps[i].dnodeId = htonl(pCfg->mnodeEps[i].dnodeId);
+    pCfg->mnodeEps[i].dnodePort = htons(pCfg->mnodeEps[i].dnodePort);
+  }
+
+  if (pCfg->dnodeId != dnodeGetDnodeId()) {
+    dDebug("dnode:%d, in create meps msg is not equal with saved dnodeId:%d", pCfg->dnodeId, dnodeGetDnodeId());
+    return TSDB_CODE_MND_DNODE_ID_NOT_CONFIGURED;
+  }
+
+  if (mnodeGetStatus() == MN_STATUS_READY) return 0;
+
+  return mnodeDeploy();
+}
+
+void dnodeProcessCreateMnodeReq(SRpcMsg *pMsg) {
+  int32_t code = dnodeStartMnode(pMsg);
+
+  SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0, .code = code};
+
+  rpcSendResponse(&rspMsg);
+  rpcFreeCont(pMsg->pCont);
+}
+
+void dnodeProcessConfigDnodeReq(SRpcMsg *pMsg) {
+  SCfgDnodeMsg *pCfg = pMsg->pCont;
+
+  int32_t code = taosCfgDynamicOptions(pCfg->config);
+
+  SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0, .code = code};
+
+  rpcSendResponse(&rspMsg);
+  rpcFreeCont(pMsg->pCont);
+}
+
+void dnodeProcessStartupReq(SRpcMsg *pMsg) {
+  dInfo("startup msg is received, cont:%s", (char *)pMsg->pCont);
+
+  SStartupStep *pStep = rpcMallocCont(sizeof(SStartupStep));
+  dnodeGetStartup(pStep);
+
+  dDebug("startup msg is sent, step:%s desc:%s finished:%d", pStep->name, pStep->desc, pStep->finished);
+
+  SRpcMsg rpcRsp = {.handle = pMsg->handle, .pCont = pStep, .contLen = sizeof(SStartupStep)};
+  rpcSendResponse(&rpcRsp);
+  rpcFreeCont(pMsg->pCont);
 }

source/server/mnode/CMakeLists.txt

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

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

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

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

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

source/server/mnode/inc/mnodeBalance.h

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

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

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

source/server/mnode/inc/mnodeDb.h

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

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

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

source/server/mnode/inc/mnodeDnode.h

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

source/server/mnode/inc/mnodeFunc.h

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

source/server/mnode/inc/mnodeInt.h

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

source/server/mnode/inc/mnodeMnode.h

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

source/server/mnode/inc/mnodeOper.h

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

source/server/mnode/inc/mnodeProfile.h

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

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

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

source/server/mnode/inc/mnodeShow.h

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

source/server/mnode/inc/mnodeStable.h

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

source/server/mnode/inc/mnodeSync.h

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

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

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

source/server/mnode/inc/mnodeUser.h

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

source/server/mnode/inc/mnodeVgroup.h

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

source/server/mnode/inc/mnodeWorker.h

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

source/server/mnode/src/mnodeAcct.c

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

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

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

source/server/mnode/src/mnodeBalance.c

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

source/server/mnode/src/mnodeCluster.c

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

source/server/mnode/src/mnodeDb.c

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

source/server/mnode/src/mnodeDnode.c

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

source/server/mnode/src/mnodeFunc.c

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

source/server/mnode/src/mnodeMnode.c

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

source/server/mnode/src/mnodeOper.c

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

source/server/mnode/src/mnodeProfile.c

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

source/server/mnode/src/mnodeSdb.c

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

source/server/mnode/src/mnodeShow.c

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

source/server/mnode/src/mnodeStable.c

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

source/server/mnode/src/mnodeSync.c

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

source/server/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/vnode/CMakeLists.txt

@@ -16,6 +16,7 @@ target_link_libraries(
     PUBLIC tq
     PUBLIC tsdb
     PUBLIC wal
+    PUBLIC sync
     PUBLIC cjson
 )