diff --git a/include/common/taosmsg.h b/include/common/taosmsg.h
index 66a02f350e7dabe1864c819eaa3183781780c9e3..037199d3bd5f2bf97d965ef242e366b03bdfd7e9 100644
--- a/include/common/taosmsg.h
+++ b/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 {
diff --git a/include/common/tglobal.h b/include/common/tglobal.h
index ad2924b1e4979ef6e7c2d1dfb7b80f90c6612551..092f31cbde07977a5fe238b00abdd03a83a44f50 100644
--- a/include/common/tglobal.h
+++ b/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;
diff --git a/include/os/osDef.h b/include/os/osDef.h
index 2b3678ac6785f2f41eded008a80dda62a9f93362..bb5395f548fc418256fe71702c66c9f8683a8484 100644
--- a/include/os/osDef.h
+++ b/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
diff --git a/include/server/mnode/mnode.h b/include/server/mnode/mnode.h
index bbc0613c2b339fa730aab9cde411c3711f718695..f15fc1792a6b55a3822f10422f91679eef94eb92 100644
--- a/include/server/mnode/mnode.h
+++ b/include/server/mnode/mnode.h
@@ -20,6 +20,8 @@
extern "C" {
#endif
+typedef enum { MN_STATUS_UNINIT = 0, MN_STATUS_INIT = 1, MN_STATUS_READY = 2, MN_STATUS_CLOSING = 3 } EMnStatus;
+
typedef struct {
/**
* Send messages to other dnodes, such as create vnode message.
@@ -54,13 +56,12 @@ typedef struct {
* @param port, the port of dnode.
*/
void (*GetDnodeEp)(int32_t dnodeId, char *ep, char *fqdn, uint16_t *port);
-
} SMnodeFp;
typedef struct {
- SMnodeFp fp;
- char clusterId[TSDB_CLUSTER_ID_LEN];
- int32_t dnodeId;
+ SMnodeFp fp;
+ char clusterId[TSDB_CLUSTER_ID_LEN];
+ int32_t dnodeId;
} SMnodePara;
/**
@@ -79,10 +80,9 @@ void mnodeCleanup();
/**
* Deploy mnode instances in dnode.
*
- * @param minfos, server information used to deploy the mnode instance.
* @return Error Code.
*/
-int32_t mnodeDeploy(struct SMInfos *minfos);
+int32_t mnodeDeploy();
/**
* Delete the mnode instance deployed in dnode.
@@ -94,7 +94,7 @@ void mnodeUnDeploy();
*
* @return Server status.
*/
-bool mnodeIsServing();
+EMnStatus mnodeGetStatus();
typedef struct {
int64_t numOfDnode;
diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index c3f3e3b98b5414ae0f7b08e0b977b70764d8216f..cf8cd510c5e848ae3310f0e70873c9598b0266c9 100644
--- a/include/util/taoserror.h
+++ b/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")
diff --git a/include/util/tdef.h b/include/util/tdef.h
index 008c9215ba7f9a0e02bfb9949ff59fb66eaddf28..2cac7fc7f4ab69bf29cd5b7e7b2d7f72c13e1d58 100644
--- a/include/util/tdef.h
+++ b/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"
diff --git a/include/util/tstep.h b/include/util/tstep.h
index ffc3f6ccf71ee37f00fdc23e394b4a2083aa6603..e4ce7f584b368b87c5e0636abed30d9e201b7f83 100644
--- a/include/util/tstep.h
+++ b/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
}
diff --git a/include/util/tworker.h b/include/util/tworker.h
index 367c1a24b98ff86f18af971805f832484973fa28..47ad0bd9e71b8cc6b3286a953d9c546c5b0d3b8e 100644
--- a/include/util/tworker.h
+++ b/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
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index 745e3ad1eeabc313f42d52800667226bcc1285c5..e74eb89aefbfb587adecbdf043589806a02dfdfa 100644
--- a/source/common/src/tglobal.c
+++ b/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;
diff --git a/source/server/dnode/inc/dnodeInt.h b/source/server/dnode/inc/dnodeInt.h
index 82cdfb52bf778e5f591d9a7b5c101b5de75169b1..38eac2794e5afcc51728a2e537921163098f51b0 100644
--- a/source/server/dnode/inc/dnodeInt.h
+++ b/source/server/dnode/inc/dnodeInt.h
@@ -19,7 +19,9 @@
#ifdef __cplusplus
extern "C" {
#endif
+#include "os.h"
#include "taosmsg.h"
+#include "tglobal.h"
#include "tlog.h"
#include "trpc.h"
#include "dnode.h"
diff --git a/source/server/dnode/inc/dnodeMain.h b/source/server/dnode/inc/dnodeMain.h
index 245ede000175119169c46735fa7717128cacdc6f..325136caa6cfe158bc90ce918dc15270ca51fae9 100644
--- a/source/server/dnode/inc/dnodeMain.h
+++ b/source/server/dnode/inc/dnodeMain.h
@@ -22,10 +22,10 @@ extern "C" {
#include "dnodeInt.h"
typedef enum {
- TD_RUN_STAT_INIT,
- TD_RUN_STAT_RUNNING,
- TD_RUN_STAT_STOPPED
-} RunStat;
+ DN_RUN_STAT_INIT,
+ DN_RUN_STAT_RUNNING,
+ DN_RUN_STAT_STOPPED
+} EDnRunStat;
int32_t dnodeInitMain();
void dnodeCleanupMain();
@@ -36,7 +36,7 @@ void dnodeReportStartupFinished(char *name, char *desc);
void dnodeProcessStartupReq(SRpcMsg *pMsg);
void dnodeProcessCreateMnodeReq(SRpcMsg *pMsg);
void dnodeProcessConfigDnodeReq(SRpcMsg *pMsg);
-RunStat dnodeGetRunStat();
+EDnRunStat dnodeGetRunStat();
void dnodeSetRunStat();
void* dnodeGetTimer();
diff --git a/source/server/dnode/inc/dnodeTrans.h b/source/server/dnode/inc/dnodeTrans.h
index 631c69d11c66246abff080d03456b857aa2d94ac..f2dc647de37a809379ec2c1e7ebb19b85d8c82ee 100644
--- a/source/server/dnode/inc/dnodeTrans.h
+++ b/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
}
diff --git a/source/server/dnode/src/dnodeCheck.c b/source/server/dnode/src/dnodeCheck.c
index b59e4bd4e027fae69f514c8d43c5f6d958932bfb..b7bd930bb36d84fb0c693cc74a3313c15f5b3318 100644
--- a/source/server/dnode/src/dnodeCheck.c
+++ b/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
diff --git a/source/server/dnode/src/dnodeInt.c b/source/server/dnode/src/dnodeInt.c
index 84a7e2565b3a636c9ae5f2d89c5b292137129940..4dbf02a868197541bb3a8fe7b2e843cca12755cb 100644
--- a/source/server/dnode/src/dnodeInt.c
+++ b/source/server/dnode/src/dnodeInt.c
@@ -28,7 +28,6 @@
#include "dnodeMain.h"
#include "dnodeMnodeEps.h"
#include "dnodeStatus.h"
-#include "dnodeTelem.h"
#include "dnodeTrans.h"
#include "mnode.h"
#include "vnode.h"
@@ -73,12 +72,11 @@ int32_t dnodeInit() {
taosStepAdd(tsSteps, "dnode-mnode", dnodeInitMnodeModule, mnodeCleanup);
taosStepAdd(tsSteps, "dnode-trans", dnodeInitTrans, dnodeCleanupTrans);
taosStepAdd(tsSteps, "dnode-status", dnodeInitStatus, dnodeCleanupStatus);
- taosStepAdd(tsSteps, "dnode-telem", dnodeInitTelem, dnodeCleanupTelem);
//taosStepAdd(tsSteps, "dnode-script",scriptEnvPoolInit, scriptEnvPoolCleanup);
taosStepExec(tsSteps);
- dnodeSetRunStat(TD_RUN_STAT_RUNNING);
+ dnodeSetRunStat(DN_RUN_STAT_RUNNING);
dnodeReportStartupFinished("TDengine", "initialized successfully");
dInfo("TDengine is initialized successfully");
@@ -86,8 +84,8 @@ int32_t dnodeInit() {
}
void dnodeCleanup() {
- if (dnodeGetRunStat() != TD_RUN_STAT_STOPPED) {
- dnodeSetRunStat(TD_RUN_STAT_STOPPED);
+ if (dnodeGetRunStat() != DN_RUN_STAT_STOPPED) {
+ dnodeSetRunStat(DN_RUN_STAT_STOPPED);
taosStepCleanup(tsSteps);
tsSteps = NULL;
}
diff --git a/source/server/dnode/src/dnodeMain.c b/source/server/dnode/src/dnodeMain.c
index 24de3b7924b4b01f8dcc2049fb60dfebae659896..50702823f1d32b6f602bfaf6959374f89e7e54c2 100644
--- a/source/server/dnode/src/dnodeMain.c
+++ b/source/server/dnode/src/dnodeMain.c
@@ -29,7 +29,7 @@
#include "mnode.h"
static struct {
- RunStat runStatus;
+ EDnRunStat runStatus;
void * dnodeTimer;
SStartupStep startup;
} tsDmain;
@@ -55,7 +55,7 @@ static void dnodeCheckDataDirOpenned(char *dir) {
}
int32_t dnodeInitMain() {
- tsDmain.runStatus = TD_RUN_STAT_STOPPED;
+ tsDmain.runStatus = DN_RUN_STAT_STOPPED;
tsDmain.dnodeTimer = taosTmrInit(100, 200, 60000, "DND-TMR");
if (tsDmain.dnodeTimer == NULL) {
dError("failed to init dnode timer");
@@ -235,9 +235,9 @@ static int32_t dnodeStartMnode(SRpcMsg *pMsg) {
dDebug("meps index:%d, meps:%d:%s", i, pCfg->mnodes.mnodeInfos[i].mnodeId, pCfg->mnodes.mnodeInfos[i].mnodeEp);
}
- if (mnodeIsServing()) return 0;
+ if (mnodeGetStatus() == MN_STATUS_READY) return 0;
- return mnodeDeploy(&pCfg->mnodes);
+ return mnodeDeploy();
}
void dnodeProcessCreateMnodeReq(SRpcMsg *pMsg) {
@@ -260,8 +260,8 @@ void dnodeProcessConfigDnodeReq(SRpcMsg *pMsg) {
rpcFreeCont(pMsg->pCont);
}
-RunStat dnodeGetRunStat() { return tsDmain.runStatus; }
+EDnRunStat dnodeGetRunStat() { return tsDmain.runStatus; }
-void dnodeSetRunStat(RunStat stat) { tsDmain.runStatus = stat; }
+void dnodeSetRunStat(EDnRunStat stat) { tsDmain.runStatus = stat; }
void* dnodeGetTimer() { return tsDmain.dnodeTimer; }
\ No newline at end of file
diff --git a/source/server/dnode/src/dnodeTrans.c b/source/server/dnode/src/dnodeTrans.c
index 1739283f34b2f632c607e5e59030a3b619128119..7b48bea622e8cafd4b838a1323b704c488d37547 100644
--- a/source/server/dnode/src/dnodeTrans.c
+++ b/source/server/dnode/src/dnodeTrans.c
@@ -20,21 +20,19 @@
*/
#define _DEFAULT_SOURCE
-#include "os.h"
-#include "tglobal.h"
+#include "dnodeTrans.h"
#include "dnodeMain.h"
#include "dnodeMnodeEps.h"
#include "dnodeStatus.h"
-#include "dnodeTrans.h"
-#include "vnode.h"
#include "mnode.h"
+#include "vnode.h"
-typedef void (*RpcMsgFp)( SRpcMsg *pMsg);
+typedef void (*RpcMsgFp)(SRpcMsg *pMsg);
static struct {
- void * serverRpc;
- void * clientRpc;
- void * shellRpc;
+ void *serverRpc;
+ void *clientRpc;
+ void *shellRpc;
int32_t queryReqNum;
int32_t submitReqNum;
RpcMsgFp peerMsgFp[TSDB_MSG_TYPE_MAX];
@@ -43,18 +41,18 @@ static struct {
static void dnodeProcessPeerReq(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0};
+ int32_t msgType = pMsg->msgType;
- if (pMsg->pCont == NULL) return;
- if (pMsg->msgType == TSDB_MSG_TYPE_NETWORK_TEST) {
+ if (msgType == TSDB_MSG_TYPE_NETWORK_TEST) {
dnodeProcessStartupReq(pMsg);
return;
}
- if (dnodeGetRunStat() != TD_RUN_STAT_RUNNING) {
+ if (dnodeGetRunStat() != DN_RUN_STAT_RUNNING) {
rspMsg.code = TSDB_CODE_APP_NOT_READY;
rpcSendResponse(&rspMsg);
rpcFreeCont(pMsg->pCont);
- dTrace("RPC %p, msg:%s is ignored since dnode not running", pMsg->handle, taosMsg[pMsg->msgType]);
+ dTrace("RPC %p, peer req:%s is ignored since dnode not running", pMsg->handle, taosMsg[msgType]);
return;
}
@@ -64,38 +62,40 @@ static void dnodeProcessPeerReq(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
return;
}
- RpcMsgFp fp = tsTrans.peerMsgFp[pMsg->msgType];
+ RpcMsgFp fp = tsTrans.peerMsgFp[msgType];
if (fp != NULL) {
+ dTrace("RPC %p, peer req:%s will be processed", pMsg->handle, taosMsg[msgType]);
(*fp)(pMsg);
} else {
- dDebug("RPC %p, peer req:%s not processed", pMsg->handle, taosMsg[pMsg->msgType]);
+ dError("RPC %p, peer req:%s not processed", pMsg->handle, taosMsg[msgType]);
rspMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED;
rpcSendResponse(&rspMsg);
rpcFreeCont(pMsg->pCont);
}
}
-int32_t dnodeInitServer() {
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE] = vnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_TABLE] = vnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE] = vnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_STABLE] = vnodeProcessMsg;
+static int32_t dnodeInitServer() {
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE] = vnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_TABLE] = vnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE] = vnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_STABLE] = vnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE] = vnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE] = vnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_SYNC_VNODE] = vnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE] = vnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE] = vnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_SYNC_VNODE] = vnodeProcessMsg;
tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_COMPACT_VNODE] = vnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_VNODE] = vnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM] = vnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_VNODE] = vnodeProcessMsg;
+
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM] = vnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE] = dnodeProcessConfigDnodeReq;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_MNODE] = dnodeProcessCreateMnodeReq;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE] = dnodeProcessConfigDnodeReq;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_MNODE] = dnodeProcessCreateMnodeReq;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_AUTH] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_GRANT] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_STATUS] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_AUTH] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_GRANT] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_STATUS] = mnodeProcessMsg;
tsTrans.peerMsgFp[TSDB_MSG_TYPE_MQ_CONNECT] = vnodeProcessMsg;
/*tsTrans.peerMsgFp[TSDB_MSG_TYPE_MQ_CONSUME] = vnodeProcessRead;*/
@@ -120,7 +120,7 @@ int32_t dnodeInitServer() {
return 0;
}
-void dnodeCleanupServer() {
+static void dnodeCleanupServer() {
if (tsTrans.serverRpc) {
rpcClose(tsTrans.serverRpc);
tsTrans.serverRpc = NULL;
@@ -128,66 +128,66 @@ void dnodeCleanupServer() {
}
}
-static void dnodeProcessRspFromPeer(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
- if (dnodeGetRunStat() == TD_RUN_STAT_STOPPED) {
+static void dnodeProcessPeerRsp(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
+ int32_t msgType = pMsg->msgType;
+
+ if (dnodeGetRunStat() == DN_RUN_STAT_STOPPED) {
if (pMsg == NULL || pMsg->pCont == NULL) return;
- dTrace("msg:%p is ignored since dnode is stopping", pMsg);
+ dTrace("RPC %p, peer rsp:%s is ignored since dnode is stopping", pMsg->handle, taosMsg[msgType]);
rpcFreeCont(pMsg->pCont);
return;
}
- if (pMsg->msgType == TSDB_MSG_TYPE_DM_STATUS_RSP && pEpSet) {
+ if (msgType == TSDB_MSG_TYPE_DM_STATUS_RSP && pEpSet) {
dnodeUpdateMnodeFromPeer(pEpSet);
}
- RpcMsgFp fp = tsTrans.peerMsgFp[pMsg->msgType];
+ RpcMsgFp fp = tsTrans.peerMsgFp[msgType];
if (fp != NULL) {
+ dTrace("RPC %p, peer rsp:%s will be processed", pMsg->handle, taosMsg[msgType]);
(*fp)(pMsg);
} else {
- dDebug("RPC %p, peer rsp:%s not processed", pMsg->handle, taosMsg[pMsg->msgType]);
- SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0};
- rspMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED;
- rpcSendResponse(&rspMsg);
- rpcFreeCont(pMsg->pCont);
+ dDebug("RPC %p, peer rsp:%s not processed", pMsg->handle, taosMsg[msgType]);
}
rpcFreeCont(pMsg->pCont);
}
-int32_t dnodeInitClient() {
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_TABLE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_STABLE_RSP] = mnodeProcessMsg;
+static int32_t dnodeInitClient() {
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_TABLE_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_STABLE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_SYNC_VNODE_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_SYNC_VNODE_RSP] = mnodeProcessMsg;
tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_COMPACT_VNODE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_VNODE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_DROP_VNODE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_MNODE_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_AUTH_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_GRANT_RSP] = mnodeProcessMsg;
- tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_STATUS_RSP] = dnodeProcessStatusRsp;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_MD_CREATE_MNODE_RSP] = mnodeProcessMsg;
- char secret[TSDB_KEY_LEN] = "secret";
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_AUTH_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_GRANT_RSP] = mnodeProcessMsg;
+ tsTrans.peerMsgFp[TSDB_MSG_TYPE_DM_STATUS_RSP] = dnodeProcessStatusRsp;
+
+ char secret[TSDB_KEY_LEN] = "secret";
SRpcInit rpcInit;
memset(&rpcInit, 0, sizeof(rpcInit));
- rpcInit.label = "DND-C";
+ rpcInit.label = "DND-C";
rpcInit.numOfThreads = 1;
- rpcInit.cfp = dnodeProcessRspFromPeer;
- rpcInit.sessions = TSDB_MAX_VNODES << 4;
- rpcInit.connType = TAOS_CONN_CLIENT;
- rpcInit.idleTime = tsShellActivityTimer * 1000;
- rpcInit.user = "t";
- rpcInit.ckey = "key";
- rpcInit.secret = secret;
+ rpcInit.cfp = dnodeProcessPeerRsp;
+ rpcInit.sessions = TSDB_MAX_VNODES << 4;
+ rpcInit.connType = TAOS_CONN_CLIENT;
+ rpcInit.idleTime = tsShellActivityTimer * 1000;
+ rpcInit.user = "t";
+ rpcInit.ckey = "key";
+ rpcInit.secret = secret;
tsTrans.clientRpc = rpcOpen(&rpcInit);
if (tsTrans.clientRpc == NULL) {
@@ -199,7 +199,7 @@ int32_t dnodeInitClient() {
return 0;
}
-void dnodeCleanupClient() {
+static void dnodeCleanupClient() {
if (tsTrans.clientRpc) {
rpcClose(tsTrans.clientRpc);
tsTrans.clientRpc = NULL;
@@ -207,59 +207,50 @@ void dnodeCleanupClient() {
}
}
-static void dnodeProcessMsgFromShell(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
- SRpcMsg rpcMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0};
+static void dnodeProcessShellReq(SRpcMsg *pMsg, SRpcEpSet *pEpSet) {
+ SRpcMsg rspMsg = {.handle = pMsg->handle, .pCont = NULL, .contLen = 0};
+ int32_t msgType = pMsg->msgType;
- if (pMsg->pCont == NULL) return;
- if (dnodeGetRunStat() == TD_RUN_STAT_STOPPED) {
- dError("RPC %p, shell msg:%s is ignored since dnode exiting", pMsg->handle, taosMsg[pMsg->msgType]);
- rpcMsg.code = TSDB_CODE_DND_EXITING;
- rpcSendResponse(&rpcMsg);
+ if (dnodeGetRunStat() == DN_RUN_STAT_STOPPED) {
+ dError("RPC %p, shell req:%s is ignored since dnode exiting", pMsg->handle, taosMsg[msgType]);
+ rspMsg.code = TSDB_CODE_DND_EXITING;
+ rpcSendResponse(&rspMsg);
rpcFreeCont(pMsg->pCont);
return;
- } else if (dnodeGetRunStat() != TD_RUN_STAT_RUNNING) {
- dError("RPC %p, shell msg:%s is ignored since dnode not running", pMsg->handle, taosMsg[pMsg->msgType]);
- rpcMsg.code = TSDB_CODE_APP_NOT_READY;
- rpcSendResponse(&rpcMsg);
+ } else if (dnodeGetRunStat() != DN_RUN_STAT_RUNNING) {
+ dError("RPC %p, shell req:%s is ignored since dnode not running", pMsg->handle, taosMsg[msgType]);
+ rspMsg.code = TSDB_CODE_APP_NOT_READY;
+ rpcSendResponse(&rspMsg);
rpcFreeCont(pMsg->pCont);
return;
}
- if (pMsg->msgType == TSDB_MSG_TYPE_QUERY) {
+ if (pMsg->pCont == NULL) {
+ rspMsg.code = TSDB_CODE_DND_INVALID_MSG_LEN;
+ rpcSendResponse(&rspMsg);
+ return;
+ }
+
+ if (msgType == TSDB_MSG_TYPE_QUERY) {
atomic_fetch_add_32(&tsTrans.queryReqNum, 1);
- } else if (pMsg->msgType == TSDB_MSG_TYPE_SUBMIT) {
+ } else if (msgType == TSDB_MSG_TYPE_SUBMIT) {
atomic_fetch_add_32(&tsTrans.submitReqNum, 1);
- } else {}
+ } else {
+ }
- RpcMsgFp fp = tsTrans.shellMsgFp[pMsg->msgType];
+ RpcMsgFp fp = tsTrans.shellMsgFp[msgType];
if (fp != NULL) {
+ dTrace("RPC %p, shell req:%s will be processed", pMsg->handle, taosMsg[msgType]);
(*fp)(pMsg);
} else {
- dError("RPC %p, shell req:%s is not processed", pMsg->handle, taosMsg[pMsg->msgType]);
- rpcMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED;
- rpcSendResponse(&rpcMsg);
+ dError("RPC %p, shell req:%s is not processed", pMsg->handle, taosMsg[msgType]);
+ rspMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED;
+ rpcSendResponse(&rspMsg);
rpcFreeCont(pMsg->pCont);
}
}
-static int32_t dnodeAuthNetTest(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
- if (strcmp(user, "nettestinternal") == 0) {
- char pass[32] = {0};
- taosEncryptPass((uint8_t *)user, strlen(user), pass);
- *spi = 0;
- *encrypt = 0;
- *ckey = 0;
- memcpy(secret, pass, TSDB_KEY_LEN);
- dTrace("nettest user is authorized");
- return 0;
- }
-
- return -1;
-}
-
-void dnodeSendMsgToDnode(SRpcEpSet *epSet, SRpcMsg *rpcMsg) {
- rpcSendRequest(tsTrans.clientRpc, epSet, rpcMsg, NULL);
-}
+void dnodeSendMsgToDnode(SRpcEpSet *epSet, SRpcMsg *rpcMsg) { rpcSendRequest(tsTrans.clientRpc, epSet, rpcMsg, NULL); }
void dnodeSendMsgToMnode(SRpcMsg *rpcMsg) {
SRpcEpSet epSet = {0};
@@ -267,19 +258,13 @@ void dnodeSendMsgToMnode(SRpcMsg *rpcMsg) {
dnodeSendMsgToDnode(&epSet, rpcMsg);
}
-void dnodeSendMsgToMnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp) {
+static void dnodeSendMsgToMnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp) {
SRpcEpSet epSet = {0};
dnodeGetEpSetForPeer(&epSet);
rpcSendRecv(tsTrans.clientRpc, &epSet, rpcMsg, rpcRsp);
}
-void dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp, SRpcEpSet *epSet) {
- rpcSendRecv(tsTrans.clientRpc, epSet, rpcMsg, rpcRsp);
-}
-
static int32_t dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
- if (dnodeAuthNetTest(user, spi, encrypt, secret, ckey) == 0) return 0;
-
int32_t code = mnodeRetriveAuth(user, spi, encrypt, secret, ckey);
if (code != TSDB_CODE_APP_NOT_READY) return code;
@@ -310,54 +295,54 @@ static int32_t dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, c
return rpcRsp.code;
}
-int32_t dnodeInitShell() {
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_SUBMIT] = vnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_QUERY] = vnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_FETCH] = vnodeProcessMsg;
+static int32_t dnodeInitShell() {
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_SUBMIT] = vnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_QUERY] = vnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_FETCH] = vnodeProcessMsg;
tsTrans.shellMsgFp[TSDB_MSG_TYPE_UPDATE_TAG_VAL] = vnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_QUERY] = vnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_CONSUME] = vnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_QUERY] = vnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_MQ_CONSUME] = vnodeProcessMsg;
// the following message shall be treated as mnode write
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_ACCT] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_USER] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_USER] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TP] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_ACCT] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_USER] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_USER] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TP] = mnodeProcessMsg;
tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_FUNCTION] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_SYNC_DB] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_TP] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_FUNCTION] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TP] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_COMPACT_VNODE] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_SYNC_DB] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_TP] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_FUNCTION] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TP] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_COMPACT_VNODE] = mnodeProcessMsg;
// the following message shall be treated as mnode query
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CONNECT] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_USE_DB] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_TABLE_META] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_CONNECT] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_USE_DB] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_TABLE_META] = mnodeProcessMsg;
tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_STABLE_VGROUP] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_SHOW] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_SHOW] = mnodeProcessMsg;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = mnodeProcessMsg;
tsTrans.shellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE_FUNC] = mnodeProcessMsg;
- tsTrans.shellMsgFp[TSDB_MSG_TYPE_NETWORK_TEST] = dnodeProcessStartupReq;
+ tsTrans.shellMsgFp[TSDB_MSG_TYPE_NETWORK_TEST] = dnodeProcessStartupReq;
int32_t numOfThreads = (int32_t)((tsNumOfCores * tsNumOfThreadsPerCore) / 2.0);
if (numOfThreads < 1) {
@@ -366,14 +351,14 @@ int32_t dnodeInitShell() {
SRpcInit rpcInit;
memset(&rpcInit, 0, sizeof(rpcInit));
- rpcInit.localPort = tsDnodeShellPort;
- rpcInit.label = "SHELL";
+ rpcInit.localPort = tsDnodeShellPort;
+ rpcInit.label = "SHELL";
rpcInit.numOfThreads = numOfThreads;
- rpcInit.cfp = dnodeProcessMsgFromShell;
- rpcInit.sessions = tsMaxShellConns;
- rpcInit.connType = TAOS_CONN_SERVER;
- rpcInit.idleTime = tsShellActivityTimer * 1000;
- rpcInit.afp = dnodeRetrieveUserAuthInfo;
+ rpcInit.cfp = dnodeProcessShellReq;
+ rpcInit.sessions = tsMaxShellConns;
+ rpcInit.connType = TAOS_CONN_SERVER;
+ rpcInit.idleTime = tsShellActivityTimer * 1000;
+ rpcInit.afp = dnodeRetrieveUserAuthInfo;
tsTrans.shellRpc = rpcOpen(&rpcInit);
if (tsTrans.shellRpc == NULL) {
@@ -385,7 +370,7 @@ int32_t dnodeInitShell() {
return 0;
}
-void dnodeCleanupShell() {
+static void dnodeCleanupShell() {
if (tsTrans.shellRpc) {
rpcClose(tsTrans.shellRpc);
tsTrans.shellRpc = NULL;
diff --git a/source/server/mnode/CMakeLists.txt b/source/server/mnode/CMakeLists.txt
index 331a717bf581616c8e2a4a6c9b610d69c7c6f12d..bf35b381afabd96901c064d4be2e67f5dd743a37 100644
--- a/source/server/mnode/CMakeLists.txt
+++ b/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
diff --git a/src/mnode/inc/mnodeRead.h b/source/server/mnode/inc/mnodeAcct.h
similarity index 76%
rename from src/mnode/inc/mnodeRead.h
rename to source/server/mnode/inc/mnodeAcct.h
index 5e7131f585a9ef62c64bac7462d12cde7c093173..9491410ddfd238a0b51e2006dfbe7e603df34661 100644
--- a/src/mnode/inc/mnodeRead.h
+++ b/source/server/mnode/inc/mnodeAcct.h
@@ -13,19 +13,20 @@
* along with this program. If not, see .
*/
-#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_*/
diff --git a/src/mnode/inc/mnodeWrite.h b/source/server/mnode/inc/mnodeAuth.h
similarity index 76%
rename from src/mnode/inc/mnodeWrite.h
rename to source/server/mnode/inc/mnodeAuth.h
index ced8eeb7c053bacbf786ad4bcf765f8c6b7e21b3..fc828aca27bdf548849639e0af26aaa375fb0c61 100644
--- a/src/mnode/inc/mnodeWrite.h
+++ b/source/server/mnode/inc/mnodeAuth.h
@@ -13,19 +13,20 @@
* along with this program. If not, see .
*/
-#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_*/
diff --git a/source/server/mnode/inc/mnodeBalance.h b/source/server/mnode/inc/mnodeBalance.h
new file mode 100644
index 0000000000000000000000000000000000000000..c851d58c30b0910e9ae588de1a759ad74f152c50
--- /dev/null
+++ b/source/server/mnode/inc/mnodeBalance.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/src/mnode/inc/mnodeCluster.h b/source/server/mnode/inc/mnodeCluster.h
similarity index 81%
rename from src/mnode/inc/mnodeCluster.h
rename to source/server/mnode/inc/mnodeCluster.h
index db258ae6d6b0b7b89c0c8ed09b6175f940922742..06001a775760cd50943ba586d625d496ba96637e 100644
--- a/src/mnode/inc/mnodeCluster.h
+++ b/source/server/mnode/inc/mnodeCluster.h
@@ -13,8 +13,10 @@
* along with this program. If not, see .
*/
-#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_*/
diff --git a/source/server/mnode/inc/mnodeDb.h b/source/server/mnode/inc/mnodeDb.h
new file mode 100644
index 0000000000000000000000000000000000000000..ba16235348e912b34ecc08863f87ef8fc957f7ac
--- /dev/null
+++ b/source/server/mnode/inc/mnodeDb.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/source/server/mnode/inc/mnodeDef.h b/source/server/mnode/inc/mnodeDef.h
new file mode 100644
index 0000000000000000000000000000000000000000..2670432594a0e3872e0c302efcb0275ff021d6ee
--- /dev/null
+++ b/source/server/mnode/inc/mnodeDef.h
@@ -0,0 +1,320 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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
+
+extern int32_t mDebugFlag;
+
+// mnode log function
+#define mFatal(...) { if (mDebugFlag & DEBUG_FATAL) { taosPrintLog("MND FATAL ", 255, __VA_ARGS__); }}
+#define mError(...) { if (mDebugFlag & DEBUG_ERROR) { taosPrintLog("MND ERROR ", 255, __VA_ARGS__); }}
+#define mWarn(...) { if (mDebugFlag & DEBUG_WARN) { taosPrintLog("MND WARN ", 255, __VA_ARGS__); }}
+#define mInfo(...) { if (mDebugFlag & DEBUG_INFO) { taosPrintLog("MND ", 255, __VA_ARGS__); }}
+#define mDebug(...) { if (mDebugFlag & DEBUG_DEBUG) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
+#define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
+
+// #define 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;
+ int64_t updateTime;
+} SClusterObj;
+
+typedef struct SDnodeObj {
+ 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 {
+ SdbHead head;
+ int32_t id;
+ int8_t status;
+ int8_t role;
+ int32_t roleTerm;
+ int64_t roleTime;
+ int64_t createdTime;
+ int64_t updateTime;
+ SDnodeObj *pDnode;
+} SMnodeObj;
+
+typedef struct {
+ 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 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 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;
+ int32_t totalBlocks;
+ int32_t maxTables;
+ int32_t daysPerFile;
+ int32_t daysToKeep0;
+ int32_t daysToKeep1;
+ int32_t daysToKeep2;
+ int32_t minRowsPerFileBlock;
+ int32_t maxRowsPerFileBlock;
+ int32_t commitTime;
+ int32_t fsyncPeriod;
+ int8_t precision;
+ int8_t compression;
+ int8_t walLevel;
+ int8_t replications;
+ int8_t quorum;
+ int8_t update;
+ int8_t cacheLastRow;
+ int8_t dbType;
+ int16_t partitions;
+} SDbCfg;
+
+typedef struct SDbObj {
+ 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 {
+ int32_t dnodeId;
+ int8_t role;
+ SDnodeObj *pDnode;
+} SVnodeGid;
+
+typedef struct SVgObj {
+ uint32_t vgId;
+ int32_t numOfVnodes;
+ int64_t createdTime;
+ 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;
+ 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 {
+ int8_t type;
+ int8_t maxReplica;
+ int16_t numOfColumns;
+ int32_t index;
+ int32_t rowSize;
+ int32_t numOfRows;
+ int32_t numOfReads;
+ 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 /*_TD_MNODE_DEF_H_*/
diff --git a/source/server/mnode/inc/mnodeDnode.h b/source/server/mnode/inc/mnodeDnode.h
new file mode 100644
index 0000000000000000000000000000000000000000..ccbd359f38c82697c250815355e6842ee3985063
--- /dev/null
+++ b/source/server/mnode/inc/mnodeDnode.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/source/server/mnode/inc/mnodeFunc.h b/source/server/mnode/inc/mnodeFunc.h
new file mode 100644
index 0000000000000000000000000000000000000000..18154d1c00550154718fcceb1227e6210ea54685
--- /dev/null
+++ b/source/server/mnode/inc/mnodeFunc.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/source/server/mnode/inc/mnodeInt.h b/source/server/mnode/inc/mnodeInt.h
index 646331b076b5a9f3dc9b3d898ebc72d1f6289c47..42d3c53fa2a5242e3b663032aea5090dd05e6172 100644
--- a/source/server/mnode/inc/mnodeInt.h
+++ b/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_*/
diff --git a/src/mnode/inc/mnodePeer.h b/source/server/mnode/inc/mnodeMnode.h
similarity index 67%
rename from src/mnode/inc/mnodePeer.h
rename to source/server/mnode/inc/mnodeMnode.h
index e409d90de96c4e6f0e37ca48ce212ec38efb5706..cee96c7bf676f8b6f312a87c5c4228c3acf1b15d 100644
--- a/src/mnode/inc/mnodePeer.h
+++ b/source/server/mnode/inc/mnodeMnode.h
@@ -13,21 +13,22 @@
* along with this program. If not, see .
*/
-#ifndef TDENGINE_MNODE_PEER_H
-#define TDENGINE_MNODE_PEER_H
+#ifndef _TD_MNODE_MNODE_H_
+#define _TD_MNODE_MNODE_H_
+
+#include "mnodeInt.h"
#ifdef __cplusplus
extern "C" {
#endif
-#include "mnodeDef.h"
-void mnodeAddPeerRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg));
-void mnodeAddPeerMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg));
-int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg);
-void mnodeProcessPeerRsp(SRpcMsg *pMsg);
+int32_t mnodeInitMnode();
+void mnodeCleanupMnode();
+void mnodeGetMnodeEpSetForPeer(SRpcEpSet *epSet, bool redirect);
+void mnodeGetMnodeEpSetForShell(SRpcEpSet *epSet, bool redirect);
#ifdef __cplusplus
}
#endif
-#endif
+#endif /*_TD_MNODE_MNODE_H_*/
diff --git a/source/server/mnode/inc/mnodeOper.h b/source/server/mnode/inc/mnodeOper.h
new file mode 100644
index 0000000000000000000000000000000000000000..4392422b23cd30369fb72cf369315c5d55fc63fb
--- /dev/null
+++ b/source/server/mnode/inc/mnodeOper.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/source/server/mnode/inc/mnodeProfile.h b/source/server/mnode/inc/mnodeProfile.h
new file mode 100644
index 0000000000000000000000000000000000000000..b3735a02a3d354507284240dfd045bba8fb586c3
--- /dev/null
+++ b/source/server/mnode/inc/mnodeProfile.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/source/server/mnode/inc/mnodeSdb.h b/source/server/mnode/inc/mnodeSdb.h
new file mode 100644
index 0000000000000000000000000000000000000000..cba9538ac259c840642ade0399f3e1239c79c535
--- /dev/null
+++ b/source/server/mnode/inc/mnodeSdb.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#ifndef _TD_MNODE_SDB_H_
+#define _TD_MNODE_SDB_H_
+
+#include "mnodeInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*SdbDeployFp)();
+typedef void *(*SdbDecodeFp)(cJSON *root);
+typedef int32_t (*SdbEncodeFp)(void *pHead, char *buf, int32_t maxLen);
+
+int32_t sdbInit();
+void sdbCleanup();
+
+int32_t sdbRead();
+int32_t sdbCommit();
+
+int32_t sdbDeploy();
+void sdbUnDeploy();
+
+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 /*_TD_MNODE_INT_H_*/
diff --git a/source/server/mnode/inc/mnodeShow.h b/source/server/mnode/inc/mnodeShow.h
new file mode 100644
index 0000000000000000000000000000000000000000..50beee2897d8f42e16e44d40641455c400bb2fb2
--- /dev/null
+++ b/source/server/mnode/inc/mnodeShow.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/source/server/mnode/inc/mnodeStable.h b/source/server/mnode/inc/mnodeStable.h
new file mode 100644
index 0000000000000000000000000000000000000000..e81fa74d0fbe720298f8faf10e268f2378bd44cf
--- /dev/null
+++ b/source/server/mnode/inc/mnodeStable.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/source/server/mnode/inc/mnodeSync.h b/source/server/mnode/inc/mnodeSync.h
new file mode 100644
index 0000000000000000000000000000000000000000..714d6ed1a8f856d5fb7290b3791254735082d9eb
--- /dev/null
+++ b/source/server/mnode/inc/mnodeSync.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/source/server/dnode/inc/dnodeTelem.h b/source/server/mnode/inc/mnodeTelem.h
similarity index 80%
rename from source/server/dnode/inc/dnodeTelem.h
rename to source/server/mnode/inc/mnodeTelem.h
index 4945879e64174065882841a2d366f4570b3d7070..9122775a31987728407ab49f203e28a8981d25cc 100644
--- a/source/server/dnode/inc/dnodeTelem.h
+++ b/source/server/mnode/inc/mnodeTelem.h
@@ -13,19 +13,19 @@
* along with this program. If not, see .
*/
-#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_*/
diff --git a/source/server/mnode/inc/mnodeUser.h b/source/server/mnode/inc/mnodeUser.h
new file mode 100644
index 0000000000000000000000000000000000000000..144dd532d9afb482d9ae6e7a9ded475d86cb99f8
--- /dev/null
+++ b/source/server/mnode/inc/mnodeUser.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/source/server/mnode/inc/mnodeVgroup.h b/source/server/mnode/inc/mnodeVgroup.h
new file mode 100644
index 0000000000000000000000000000000000000000..ebd98bb798e490c6d9d0aae4b10888b9b5d51e07
--- /dev/null
+++ b/source/server/mnode/inc/mnodeVgroup.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/source/server/mnode/inc/mnodeWorker.h b/source/server/mnode/inc/mnodeWorker.h
new file mode 100644
index 0000000000000000000000000000000000000000..7663df6559603e95360f12e0a2f0a2269c3c4611
--- /dev/null
+++ b/source/server/mnode/inc/mnodeWorker.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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_*/
diff --git a/source/server/mnode/src/mnodeAcct.c b/source/server/mnode/src/mnodeAcct.c
new file mode 100644
index 0000000000000000000000000000000000000000..39db95b6d12fd019dd128e790d8fc487fd1edc3a
--- /dev/null
+++ b/source/server/mnode/src/mnodeAcct.c
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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() {}
diff --git a/source/server/mnode/src/mnodeMain.c b/source/server/mnode/src/mnodeAuth.c
similarity index 60%
rename from source/server/mnode/src/mnodeMain.c
rename to source/server/mnode/src/mnodeAuth.c
index 8e5b4692e3a4f46c8e6eb62f9fa72a28f3b7b3f2..bb3289ebebb1c2c51063a7a0f4465860d30627c4 100644
--- a/source/server/mnode/src/mnodeMain.c
+++ b/source/server/mnode/src/mnodeAuth.c
@@ -13,20 +13,24 @@
* along with this program. If not, see .
*/
-#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
diff --git a/source/server/mnode/src/mnodeBalance.c b/source/server/mnode/src/mnodeBalance.c
new file mode 100644
index 0000000000000000000000000000000000000000..a9542ab457bf7d8cba9b756fde2d0c6b9eab95b6
--- /dev/null
+++ b/source/server/mnode/src/mnodeBalance.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitBalance() { return 0; }
+void mnodeCleanupBalance() {}
\ No newline at end of file
diff --git a/source/server/mnode/src/mnodeCluster.c b/source/server/mnode/src/mnodeCluster.c
new file mode 100644
index 0000000000000000000000000000000000000000..8ce26270e2d4b42a66bbd42dddc4ec9da5aa0666
--- /dev/null
+++ b/source/server/mnode/src/mnodeCluster.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitCluster() { return 0; }
+void mnodeCleanupCluster() {}
\ No newline at end of file
diff --git a/source/server/mnode/src/mnodeDb.c b/source/server/mnode/src/mnodeDb.c
new file mode 100644
index 0000000000000000000000000000000000000000..da5e3e55423b9dca6cd1e73af1d74cb65608779c
--- /dev/null
+++ b/source/server/mnode/src/mnodeDb.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitDb() { return 0; }
+void mnodeCleanupDb() {}
\ No newline at end of file
diff --git a/source/server/mnode/src/mnodeDnode.c b/source/server/mnode/src/mnodeDnode.c
new file mode 100644
index 0000000000000000000000000000000000000000..36766f72a888d37d36c040c9f8dbcfa2b5df7f75
--- /dev/null
+++ b/source/server/mnode/src/mnodeDnode.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitDnode() { return 0; }
+void mnodeCleanupDnode() {}
\ No newline at end of file
diff --git a/source/server/mnode/src/mnodeFunc.c b/source/server/mnode/src/mnodeFunc.c
new file mode 100644
index 0000000000000000000000000000000000000000..2d8628c2beac32b52376555ebd7bd58d055f8565
--- /dev/null
+++ b/source/server/mnode/src/mnodeFunc.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitFunc() { return 0; }
+void mnodeCleanupFunc() {}
\ No newline at end of file
diff --git a/source/server/mnode/src/mnodeMnode.c b/source/server/mnode/src/mnodeMnode.c
new file mode 100644
index 0000000000000000000000000000000000000000..d2bcd25fc77a0bc355be226df2703f3d7f785817
--- /dev/null
+++ b/source/server/mnode/src/mnodeMnode.c
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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
diff --git a/source/server/mnode/src/mnodeOper.c b/source/server/mnode/src/mnodeOper.c
new file mode 100644
index 0000000000000000000000000000000000000000..35f4db026174760b15ee08c5712d5c2f752dcf45
--- /dev/null
+++ b/source/server/mnode/src/mnodeOper.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitOper() { return 0; }
+void mnodeCleanupOper() {}
\ No newline at end of file
diff --git a/source/server/mnode/src/mnodeProfile.c b/source/server/mnode/src/mnodeProfile.c
new file mode 100644
index 0000000000000000000000000000000000000000..9cf9e184cfd3c6306edc20ecdc304f5f3d5142db
--- /dev/null
+++ b/source/server/mnode/src/mnodeProfile.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitProfile() { return 0; }
+void mnodeCleanupProfile() {}
\ No newline at end of file
diff --git a/source/server/mnode/src/mnodeSdb.c b/source/server/mnode/src/mnodeSdb.c
new file mode 100644
index 0000000000000000000000000000000000000000..f676729469173a15e98967723bc640c7a9092344
--- /dev/null
+++ b/source/server/mnode/src/mnodeSdb.c
@@ -0,0 +1,395 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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
diff --git a/source/server/mnode/src/mnodeShow.c b/source/server/mnode/src/mnodeShow.c
new file mode 100644
index 0000000000000000000000000000000000000000..9918ad28e056263981ee2829bfacf66af574b2b2
--- /dev/null
+++ b/source/server/mnode/src/mnodeShow.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitShow() { return 0; }
+void mnodeCleanUpShow() {}
\ No newline at end of file
diff --git a/source/server/mnode/src/mnodeStable.c b/source/server/mnode/src/mnodeStable.c
new file mode 100644
index 0000000000000000000000000000000000000000..87e887a11bf7170c90c205e4670848b07651883b
--- /dev/null
+++ b/source/server/mnode/src/mnodeStable.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitStable() { return 0; }
+void mnodeCleanupStable() {}
\ No newline at end of file
diff --git a/source/server/mnode/src/mnodeSync.c b/source/server/mnode/src/mnodeSync.c
new file mode 100644
index 0000000000000000000000000000000000000000..c161bb971ac7c4a0a74e39acd915bd4a6eb209db
--- /dev/null
+++ b/source/server/mnode/src/mnodeSync.c
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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
diff --git a/source/server/dnode/src/dnodeTelem.c b/source/server/mnode/src/mnodeTelem.c
similarity index 68%
rename from source/server/dnode/src/dnodeTelem.c
rename to source/server/mnode/src/mnodeTelem.c
index 7c87ea5f50fedfdf8d8102746dd2bfb28e4a4261..cb292342c7e86d751ce3fa73f38ce0eb396f76ec 100644
--- a/source/server/dnode/src/dnodeTelem.c
+++ b/source/server/mnode/src/mnodeTelem.c
@@ -14,12 +14,9 @@
*/
#define _DEFAULT_SOURCE
-#include "os.h"
+#include "mnodeTelem.h"
#include "tbuffer.h"
#include "tglobal.h"
-#include "dnodeCfg.h"
-#include "dnodeTelem.h"
-#include "mnode.h"
#define TELEMETRY_SERVER "telemetry.taosdata.com"
#define TELEMETRY_PORT 80
@@ -38,9 +35,9 @@ static struct {
char email[TSDB_FQDN_LEN];
} tsTelem;
-static void dnodeBeginObject(SBufferWriter* bw) { tbufWriteChar(bw, '{'); }
+static void mnodeBeginObject(SBufferWriter* bw) { tbufWriteChar(bw, '{'); }
-static void dnodeCloseObject(SBufferWriter* bw) {
+static void mnodeCloseObject(SBufferWriter* bw) {
size_t len = tbufTell(bw);
if (tbufGetData(bw, false)[len - 1] == ',') {
tbufWriteCharAt(bw, len - 1, '}');
@@ -66,14 +63,14 @@ static void closeArray(SBufferWriter* bw) {
}
#endif
-static void dnodeWriteString(SBufferWriter* bw, const char* str) {
+static void mnodeWriteString(SBufferWriter* bw, const char* str) {
tbufWriteChar(bw, '"');
tbufWrite(bw, str, strlen(str));
tbufWriteChar(bw, '"');
}
-static void dnodeAddIntField(SBufferWriter* bw, const char* k, int64_t v) {
- dnodeWriteString(bw, k);
+static void mnodeAddIntField(SBufferWriter* bw, const char* k, int64_t v) {
+ mnodeWriteString(bw, k);
tbufWriteChar(bw, ':');
char buf[32];
sprintf(buf, "%" PRId64, v);
@@ -81,14 +78,14 @@ static void dnodeAddIntField(SBufferWriter* bw, const char* k, int64_t v) {
tbufWriteChar(bw, ',');
}
-static void dnodeAddStringField(SBufferWriter* bw, const char* k, const char* v) {
- dnodeWriteString(bw, k);
+static void mnodeAddStringField(SBufferWriter* bw, const char* k, const char* v) {
+ mnodeWriteString(bw, k);
tbufWriteChar(bw, ':');
- dnodeWriteString(bw, v);
+ mnodeWriteString(bw, v);
tbufWriteChar(bw, ',');
}
-static void dnodeAddCpuInfo(SBufferWriter* bw) {
+static void mnodeAddCpuInfo(SBufferWriter* bw) {
char* line = NULL;
size_t size = 0;
int32_t done = 0;
@@ -102,11 +99,11 @@ static void dnodeAddCpuInfo(SBufferWriter* bw) {
line[size - 1] = '\0';
if (((done & 1) == 0) && strncmp(line, "model name", 10) == 0) {
const char* v = strchr(line, ':') + 2;
- dnodeAddStringField(bw, "cpuModel", v);
+ mnodeAddStringField(bw, "cpuModel", v);
done |= 1;
} else if (((done & 2) == 0) && strncmp(line, "cpu cores", 9) == 0) {
const char* v = strchr(line, ':') + 2;
- dnodeWriteString(bw, "numOfCpu");
+ mnodeWriteString(bw, "numOfCpu");
tbufWriteChar(bw, ':');
tbufWrite(bw, v, strlen(v));
tbufWriteChar(bw, ',');
@@ -118,7 +115,7 @@ static void dnodeAddCpuInfo(SBufferWriter* bw) {
fclose(fp);
}
-static void dnodeAddOsInfo(SBufferWriter* bw) {
+static void mnodeAddOsInfo(SBufferWriter* bw) {
char* line = NULL;
size_t size = 0;
@@ -135,7 +132,7 @@ static void dnodeAddOsInfo(SBufferWriter* bw) {
p++;
line[size - 2] = 0;
}
- dnodeAddStringField(bw, "os", p);
+ mnodeAddStringField(bw, "os", p);
break;
}
}
@@ -144,7 +141,7 @@ static void dnodeAddOsInfo(SBufferWriter* bw) {
fclose(fp);
}
-static void dnodeAddMemoryInfo(SBufferWriter* bw) {
+static void mnodeAddMemoryInfo(SBufferWriter* bw) {
char* line = NULL;
size_t size = 0;
@@ -158,7 +155,7 @@ static void dnodeAddMemoryInfo(SBufferWriter* bw) {
if (strncmp(line, "MemTotal", 8) == 0) {
const char* p = strchr(line, ':') + 1;
while (*p == ' ') p++;
- dnodeAddStringField(bw, "memory", p);
+ mnodeAddStringField(bw, "memory", p);
break;
}
}
@@ -167,57 +164,57 @@ static void dnodeAddMemoryInfo(SBufferWriter* bw) {
fclose(fp);
}
-static void dnodeAddVersionInfo(SBufferWriter* bw) {
- dnodeAddStringField(bw, "version", version);
- dnodeAddStringField(bw, "buildInfo", buildinfo);
- dnodeAddStringField(bw, "gitInfo", gitinfo);
- dnodeAddStringField(bw, "email", tsTelem.email);
+static void mnodeAddVersionInfo(SBufferWriter* bw) {
+ mnodeAddStringField(bw, "version", version);
+ mnodeAddStringField(bw, "buildInfo", buildinfo);
+ mnodeAddStringField(bw, "gitInfo", gitinfo);
+ mnodeAddStringField(bw, "email", tsTelem.email);
}
-static void dnodeAddRuntimeInfo(SBufferWriter* bw) {
+static void mnodeAddRuntimeInfo(SBufferWriter* bw) {
SMnodeStat stat = {0};
if (mnodeGetStatistics(&stat) != 0) {
return;
}
- dnodeAddIntField(bw, "numOfDnode", stat.numOfDnode);
- dnodeAddIntField(bw, "numOfMnode", stat.numOfMnode);
- dnodeAddIntField(bw, "numOfVgroup", stat.numOfVgroup);
- dnodeAddIntField(bw, "numOfDatabase", stat.numOfDatabase);
- dnodeAddIntField(bw, "numOfSuperTable", stat.numOfSuperTable);
- dnodeAddIntField(bw, "numOfChildTable", stat.numOfChildTable);
- dnodeAddIntField(bw, "numOfColumn", stat.numOfColumn);
- dnodeAddIntField(bw, "numOfPoint", stat.totalPoints);
- dnodeAddIntField(bw, "totalStorage", stat.totalStorage);
- dnodeAddIntField(bw, "compStorage", stat.compStorage);
+ mnodeAddIntField(bw, "numOfDnode", stat.numOfDnode);
+ mnodeAddIntField(bw, "numOfMnode", stat.numOfMnode);
+ mnodeAddIntField(bw, "numOfVgroup", stat.numOfVgroup);
+ mnodeAddIntField(bw, "numOfDatabase", stat.numOfDatabase);
+ mnodeAddIntField(bw, "numOfSuperTable", stat.numOfSuperTable);
+ mnodeAddIntField(bw, "numOfChildTable", stat.numOfChildTable);
+ mnodeAddIntField(bw, "numOfColumn", stat.numOfColumn);
+ mnodeAddIntField(bw, "numOfPoint", stat.totalPoints);
+ mnodeAddIntField(bw, "totalStorage", stat.totalStorage);
+ mnodeAddIntField(bw, "compStorage", stat.compStorage);
}
-static void dnodeSendTelemetryReport() {
+static void mnodeSendTelemetryReport() {
char buf[128] = {0};
uint32_t ip = taosGetIpv4FromFqdn(TELEMETRY_SERVER);
if (ip == 0xffffffff) {
- dTrace("failed to get IP address of " TELEMETRY_SERVER ", reason:%s", strerror(errno));
+ mTrace("failed to get IP address of " TELEMETRY_SERVER ", reason:%s", strerror(errno));
return;
}
SOCKET fd = taosOpenTcpClientSocket(ip, TELEMETRY_PORT, 0);
if (fd < 0) {
- dTrace("failed to create socket for telemetry, reason:%s", strerror(errno));
+ mTrace("failed to create socket for telemetry, reason:%s", strerror(errno));
return;
}
char clusterId[TSDB_CLUSTER_ID_LEN] = {0};
- dnodeGetClusterId(clusterId);
+ mnodeGetClusterId(clusterId);
SBufferWriter bw = tbufInitWriter(NULL, false);
- dnodeBeginObject(&bw);
- dnodeAddStringField(&bw, "instanceId", clusterId);
- dnodeAddIntField(&bw, "reportVersion", 1);
- dnodeAddOsInfo(&bw);
- dnodeAddCpuInfo(&bw);
- dnodeAddMemoryInfo(&bw);
- dnodeAddVersionInfo(&bw);
- dnodeAddRuntimeInfo(&bw);
- dnodeCloseObject(&bw);
+ mnodeBeginObject(&bw);
+ mnodeAddStringField(&bw, "instanceId", clusterId);
+ mnodeAddIntField(&bw, "reportVersion", 1);
+ mnodeAddOsInfo(&bw);
+ mnodeAddCpuInfo(&bw);
+ mnodeAddMemoryInfo(&bw);
+ mnodeAddVersionInfo(&bw);
+ mnodeAddRuntimeInfo(&bw);
+ mnodeCloseObject(&bw);
const char* header =
"POST /report HTTP/1.1\n"
@@ -235,18 +232,18 @@ static void dnodeSendTelemetryReport() {
// read something to avoid nginx error 499
if (taosReadSocket(fd, buf, 10) < 0) {
- dTrace("failed to receive response since %s", strerror(errno));
+ mTrace("failed to receive response since %s", strerror(errno));
}
taosCloseSocket(fd);
}
-static void* dnodeTelemThreadFp(void* param) {
+static void* mnodeTelemThreadFp(void* param) {
struct timespec end = {0};
clock_gettime(CLOCK_REALTIME, &end);
end.tv_sec += 300; // wait 5 minutes before send first report
- setThreadName("dnode-telem");
+ setThreadName("mnode-telem");
while (!tsTelem.exit) {
int32_t r = 0;
@@ -257,8 +254,8 @@ static void* dnodeTelemThreadFp(void* param) {
if (r == 0) break;
if (r != ETIMEDOUT) continue;
- if (mnodeIsServing()) {
- dnodeSendTelemetryReport();
+ if (mnodeGetStatus() == MN_STATUS_READY) {
+ mnodeSendTelemetryReport();
}
end.tv_sec += REPORT_INTERVAL;
}
@@ -266,20 +263,20 @@ static void* dnodeTelemThreadFp(void* param) {
return NULL;
}
-static void dnodeGetEmail(char* filepath) {
+static void mnodeGetEmail(char* filepath) {
int32_t fd = taosOpenFileRead(filepath);
if (fd < 0) {
return;
}
if (taosReadFile(fd, (void*)tsTelem.email, TSDB_FQDN_LEN) < 0) {
- dError("failed to read %d bytes from file %s since %s", TSDB_FQDN_LEN, filepath, strerror(errno));
+ mError("failed to read %d bytes from file %s since %s", TSDB_FQDN_LEN, filepath, strerror(errno));
}
taosCloseFile(fd);
}
-int32_t dnodeInitTelem() {
+int32_t mnodeInitTelem() {
tsTelem.enable = tsEnableTelemetryReporting;
if (!tsTelem.enable) return 0;
@@ -288,23 +285,23 @@ int32_t dnodeInitTelem() {
pthread_cond_init(&tsTelem.cond, NULL);
tsTelem.email[0] = 0;
- dnodeGetEmail("/usr/local/taos/email");
+ mnodeGetEmail("/usr/local/taos/email");
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
- int32_t code = pthread_create(&tsTelem.thread, &attr, dnodeTelemThreadFp, NULL);
+ int32_t code = pthread_create(&tsTelem.thread, &attr, mnodeTelemThreadFp, NULL);
pthread_attr_destroy(&attr);
if (code != 0) {
- dTrace("failed to create telemetry thread since :%s", strerror(code));
+ mTrace("failed to create telemetry thread since :%s", strerror(code));
}
- dInfo("dnode telemetry is initialized");
+ mInfo("mnode telemetry is initialized");
return 0;
}
-void dnodeCleanupTelem() {
+void mnodeCleanupTelem() {
if (!tsTelem.enable) return;
if (taosCheckPthreadValid(tsTelem.thread)) {
diff --git a/source/server/mnode/src/mnodeUser.c b/source/server/mnode/src/mnodeUser.c
new file mode 100644
index 0000000000000000000000000000000000000000..381a16ae265af7f3aaf277f818b9022c444b138c
--- /dev/null
+++ b/source/server/mnode/src/mnodeUser.c
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#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
diff --git a/source/server/mnode/src/mnodeVgroup.c b/source/server/mnode/src/mnodeVgroup.c
new file mode 100644
index 0000000000000000000000000000000000000000..6f9df1f69f7e0d43817c2d68e63aad635de2b64b
--- /dev/null
+++ b/source/server/mnode/src/mnodeVgroup.c
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "mnodeInt.h"
+
+int32_t mnodeInitVgroup() { return 0; }
+void mnodeCleanupVgroup() {}
\ No newline at end of file
diff --git a/source/server/mnode/src/mnodeWorker.c b/source/server/mnode/src/mnodeWorker.c
new file mode 100644
index 0000000000000000000000000000000000000000..84beddb2da573d295a2c917ba916716c4e565c85
--- /dev/null
+++ b/source/server/mnode/src/mnodeWorker.c
@@ -0,0 +1,487 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tworker.h"
+#include "tglobal.h"
+#include "mnodeMnode.h"
+#include "mnodeSdb.h"
+#include "mnodeShow.h"
+#include "mnodeSync.h"
+#include "mnodeWorker.h"
+
+static struct {
+ SWorkerPool read;
+ SWorkerPool write;
+ SWorkerPool peerReq;
+ SWorkerPool peerRsp;
+ taos_queue readQ;
+ taos_queue writeQ;
+ taos_queue peerReqQ;
+ taos_queue peerRspQ;
+ int32_t (*writeMsgFp[TSDB_MSG_TYPE_MAX])(SMnMsg *);
+ int32_t (*readMsgFp[TSDB_MSG_TYPE_MAX])(SMnMsg *);
+ int32_t (*peerReqFp[TSDB_MSG_TYPE_MAX])(SMnMsg *);
+ void (*peerRspFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *);
+ void (*msgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *pMsg);
+} tsMworker = {0};
+
+static SMnMsg *mnodeInitMsg(SRpcMsg *pRpcMsg) {
+ int32_t size = sizeof(SMnMsg) + pRpcMsg->contLen;
+ SMnMsg *pMsg = taosAllocateQitem(size);
+
+ pMsg->rpcMsg = *pRpcMsg;
+ pMsg->rpcMsg.pCont = pMsg->pCont;
+ pMsg->createdTime = taosGetTimestampSec();
+ memcpy(pMsg->pCont, pRpcMsg->pCont, pRpcMsg->contLen);
+
+ SRpcConnInfo connInfo = {0};
+ if (rpcGetConnInfo(pMsg->rpcMsg.handle, &connInfo) == 0) {
+ pMsg->pUser = sdbGetRow(MN_SDB_USER, connInfo.user);
+ }
+
+ if (pMsg->pUser == NULL) {
+ mError("can not get user from conn:%p", pMsg->rpcMsg.handle);
+ taosFreeQitem(pMsg);
+ return NULL;
+ }
+
+ return pMsg;
+}
+
+static void mnodeCleanupMsg(SMnMsg *pMsg) {
+ if (pMsg == NULL) return;
+ if (pMsg->rpcMsg.pCont != pMsg->pCont) {
+ tfree(pMsg->rpcMsg.pCont);
+ }
+
+ taosFreeQitem(pMsg);
+}
+
+static void mnodeDispatchToWriteQueue(SRpcMsg *pRpcMsg) {
+ if (mnodeGetStatus() != MN_STATUS_READY || tsMworker.writeQ == NULL) {
+ mnodeSendRedirectMsg(pRpcMsg, true);
+ } else {
+ SMnMsg *pMsg = mnodeInitMsg(pRpcMsg);
+ if (pMsg == NULL) {
+ SRpcMsg rpcRsp = {.handle = pRpcMsg->handle, .code = TSDB_CODE_MND_INVALID_USER};
+ rpcSendResponse(&rpcRsp);
+ } else {
+ mTrace("msg:%p, app:%p type:%s is put into wqueue", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
+ taosWriteQitem(tsMworker.writeQ, TAOS_QTYPE_RPC, pMsg);
+ }
+ }
+
+ rpcFreeCont(pRpcMsg->pCont);
+}
+
+void mnodeReDispatchToWriteQueue(SMnMsg *pMsg) {
+ if (mnodeGetStatus() != MN_STATUS_READY || tsMworker.writeQ == NULL) {
+ mnodeSendRedirectMsg(&pMsg->rpcMsg, true);
+ mnodeCleanupMsg(pMsg);
+ } else {
+ taosWriteQitem(tsMworker.writeQ, TAOS_QTYPE_RPC, pMsg);
+ }
+}
+
+static void mnodeDispatchToReadQueue(SRpcMsg *pRpcMsg) {
+ if (mnodeGetStatus() != MN_STATUS_READY || tsMworker.readQ == NULL) {
+ mnodeSendRedirectMsg(pRpcMsg, true);
+ } else {
+ SMnMsg *pMsg = mnodeInitMsg(pRpcMsg);
+ if (pMsg == NULL) {
+ SRpcMsg rpcRsp = {.handle = pRpcMsg->handle, .code = TSDB_CODE_MND_INVALID_USER};
+ rpcSendResponse(&rpcRsp);
+ } else {
+ mTrace("msg:%p, app:%p type:%s is put into rqueue", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
+ taosWriteQitem(tsMworker.readQ, TAOS_QTYPE_RPC, pMsg);
+ }
+ }
+
+ rpcFreeCont(pRpcMsg->pCont);
+}
+
+static void mnodeDispatchToPeerQueue(SRpcMsg *pRpcMsg) {
+ if (mnodeGetStatus() != MN_STATUS_READY || tsMworker.peerReqQ == NULL) {
+ mnodeSendRedirectMsg(pRpcMsg, false);
+ } else {
+ SMnMsg *pMsg = mnodeInitMsg(pRpcMsg);
+ if (pMsg == NULL) {
+ SRpcMsg rpcRsp = {.handle = pRpcMsg->handle, .code = TSDB_CODE_MND_INVALID_USER};
+ rpcSendResponse(&rpcRsp);
+ } else {
+ mTrace("msg:%p, app:%p type:%s is put into peer req queue", pMsg, pMsg->rpcMsg.ahandle,
+ taosMsg[pMsg->rpcMsg.msgType]);
+ taosWriteQitem(tsMworker.peerReqQ, TAOS_QTYPE_RPC, pMsg);
+ }
+ }
+
+ rpcFreeCont(pRpcMsg->pCont);
+}
+
+void mnodeDispatchToPeerRspQueue(SRpcMsg *pRpcMsg) {
+ SMnMsg *pMsg = mnodeInitMsg(pRpcMsg);
+ if (pMsg == NULL) {
+ SRpcMsg rpcRsp = {.handle = pRpcMsg->handle, .code = TSDB_CODE_MND_INVALID_USER};
+ rpcSendResponse(&rpcRsp);
+ } else {
+ mTrace("msg:%p, app:%p type:%s is put into peer rsp queue", pMsg, pMsg->rpcMsg.ahandle,
+ taosMsg[pMsg->rpcMsg.msgType]);
+ taosWriteQitem(tsMworker.peerRspQ, TAOS_QTYPE_RPC, pMsg);
+ }
+
+ // rpcFreeCont(pRpcMsg->pCont);
+}
+
+static void mnodeSendRpcRsp(void *ahandle, SMnMsg *pMsg, int32_t qtype, int32_t code) {
+ if (pMsg == NULL) return;
+ if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) return;
+ if (code == TSDB_CODE_MND_ACTION_NEED_REPROCESSED) {
+ mnodeReDispatchToWriteQueue(pMsg);
+ return;
+ }
+
+ SRpcMsg rpcRsp = {
+ .handle = pMsg->rpcMsg.handle,
+ .pCont = pMsg->rpcRsp.rsp,
+ .contLen = pMsg->rpcRsp.len,
+ .code = code,
+ };
+
+ rpcSendResponse(&rpcRsp);
+ mnodeCleanupMsg(pMsg);
+}
+
+void mnodeSendRsp(SMnMsg *pMsg, int32_t code) { mnodeSendRpcRsp(NULL, pMsg, 0, code); }
+
+static void mnodeProcessPeerRspEnd(void *ahandle, SMnMsg *pMsg, int32_t qtype, int32_t code) {
+ mnodeCleanupMsg(pMsg);
+}
+
+static void mnodeInitMsgFp() {
+// // peer req
+// tsMworker.msgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = mnodeDispatchToPeerQueue;
+// tsMworker.peerReqFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = mnodeProcessTableCfgMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = mnodeDispatchToPeerQueue;
+// tsMworker.peerReqFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = mnodeProcessVnodeCfgMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_DM_AUTH] = mnodeDispatchToPeerQueue;
+// tsMworker.peerReqFp[TSDB_MSG_TYPE_DM_AUTH] = mnodeProcessAuthMsg;
+// // tsMworker.msgFp[TSDB_MSG_TYPE_DM_GRANT] = mnodeDispatchToPeerQueue;
+// // tsMworker.peerReqFp[TSDB_MSG_TYPE_DM_GRANT] = grantProcessMsgInMgmt;
+// tsMworker.msgFp[TSDB_MSG_TYPE_DM_STATUS] = mnodeDispatchToPeerQueue;
+// tsMworker.peerReqFp[TSDB_MSG_TYPE_DM_STATUS] = mnodeProcessDnodeStatusMsg;
+
+// // peer rsp
+// tsMworker.msgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP] = mnodeDispatchToPeerRspQueue;
+// tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP] = mnodeProcessCfgDnodeMsgRsp;
+
+// tsMworker.msgFp[TSDB_MSG_TYPE_MD_DROP_STABLE_RSP] = mnodeDispatchToPeerRspQueue;
+// tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_DROP_STABLE_RSP] = mnodeProcessDropSuperTableRsp;
+// tsMworker.msgFp[TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP] = mnodeDispatchToPeerRspQueue;
+// tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP] = mnodeProcessCreateChildTableRsp;
+// tsMworker.msgFp[TSDB_MSG_TYPE_MD_DROP_TABLE_RSP] = mnodeDispatchToPeerRspQueue;
+// tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_DROP_TABLE_RSP] = mnodeProcessDropChildTableRsp;
+// tsMworker.msgFp[TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP] = mnodeDispatchToPeerRspQueue;
+// tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP] = mnodeProcessAlterTableRsp;
+
+// tsMworker.msgFp[TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP] = mnodeDispatchToPeerRspQueue;
+// tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP] = mnodeProcessCreateVnodeRsp;
+// tsMworker.msgFp[TSDB_MSG_TYPE_MD_ALTER_VNODE_RSP] = mnodeDispatchToPeerRspQueue;
+// tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_ALTER_VNODE_RSP] = mnodeProcessAlterVnodeRsp;
+// tsMworker.msgFp[TSDB_MSG_TYPE_MD_COMPACT_VNODE_RSP] = mnodeDispatchToPeerRspQueue;
+// tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_COMPACT_VNODE_RSP] = mnodeProcessCompactVnodeRsp;
+// tsMworker.msgFp[TSDB_MSG_TYPE_MD_DROP_VNODE_RSP] = mnodeDispatchToPeerRspQueue;
+// tsMworker.peerRspFp[TSDB_MSG_TYPE_MD_DROP_VNODE_RSP] = mnodeProcessDropVnodeRsp;
+
+// // read msg
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = mnodeDispatchToReadQueue;
+// tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = mnodeProcessHeartBeatMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_CONNECT] = mnodeDispatchToReadQueue;
+// tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_CONNECT] = mnodeProcessConnectMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_USE_DB] = mnodeDispatchToReadQueue;
+// tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_USE_DB] = mnodeProcessUseMsg;
+
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_TABLE_META] = mnodeDispatchToReadQueue;
+// tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_TABLE_META] = mnodeProcessTableMetaMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_TABLES_META] = mnodeDispatchToReadQueue;
+// tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = mnodeProcessMultiTableMetaMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_STABLE_VGROUP] = mnodeDispatchToReadQueue;
+// tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_STABLE_VGROUP] = mnodeProcessSuperTableVgroupMsg;
+
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_SHOW] = mnodeDispatchToReadQueue;
+// tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_SHOW] = mnodeProcessShowMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = mnodeDispatchToReadQueue;
+// tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = mnodeProcessRetrieveMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_RETRIEVE_FUNC] = mnodeDispatchToReadQueue;
+// tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE_FUNC] = mnodeProcessRetrieveFuncReq;
+
+// // tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = mnodeDispatchToWriteQueue;
+// // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = acctProcessCreateAcctMsg;
+// // tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT] = mnodeDispatchToWriteQueue;
+// // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT] = acctProcessDropAcctMsg;
+// // tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_ACCT] = mnodeDispatchToWriteQueue;
+// // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_DROP_ACCT] = acctProcessAlterAcctMsg;
+
+// // write msg
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = mnodeProcessCreateUserMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_USER] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_ALTER_USER] = mnodeProcessAlterUserMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_USER] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_DROP_USER] = mnodeProcessDropUserMsg;
+
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE] = mnodeProcessCreateDnodeMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = mnodeProcessDropDnodeMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE] = mnodeProcessCfgDnodeMsg;
+
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = mnodeProcessCreateDbMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = mnodeProcessAlterDbMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_DB] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_DROP_DB] = mnodeProcessDropDbMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_SYNC_DB] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_SYNC_DB] = mnodeProcessSyncDbMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_COMPACT_VNODE] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_COMPACT_VNODE] = mnodeProcessCompactMsg;
+
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_FUNCTION] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CREATE_FUNCTION] = mnodeProcessCreateFuncMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_FUNCTION] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_DROP_FUNCTION] = mnodeProcessDropFuncMsg;
+
+// // tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_TP] = mnodeDispatchToWriteQueue;
+// // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_CREATE_TP] = tpProcessCreateTpMsg;
+// // tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_TP] = mnodeDispatchToWriteQueue;
+// // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_DROP_TP] = tpProcessAlterTpMsg;
+// // tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_TP] = mnodeDispatchToWriteQueue;
+// // tsMworker.readMsgFp[TSDB_MSG_TYPE_CM_ALTER_TP] = tpProcessDropTpMsg;
+
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE] = mnodeProcessCreateTableMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_DROP_TABLE] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE] = mnodeProcessDropTableMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = mnodeProcessAlterTableMsg;
+
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM] = NULL;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_KILL_QUERY] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY] = mnodeProcessKillQueryMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = mnodeProcessKillStreamMsg;
+// tsMworker.msgFp[TSDB_MSG_TYPE_CM_KILL_CONN] = mnodeDispatchToWriteQueue;
+// tsMworker.writeMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN] = mnodeProcessKillConnectionMsg;
+}
+
+static int32_t mnodeProcessWriteReq(void *unused, SMnMsg *pMsg, int32_t qtype) {
+ int32_t msgType = pMsg->rpcMsg.msgType;
+ void *ahandle = pMsg->rpcMsg.ahandle;
+
+ if (pMsg->rpcMsg.pCont == NULL) {
+ mError("msg:%p, app:%p type:%s content is null", pMsg, ahandle, taosMsg[msgType]);
+ return TSDB_CODE_MND_INVALID_MSG_LEN;
+ }
+
+ if (!mnodeIsMaster()) {
+ SMnRsp *rpcRsp = &pMsg->rpcRsp;
+ SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
+ mnodeGetMnodeEpSetForShell(epSet, true);
+ rpcRsp->rsp = epSet;
+ rpcRsp->len = sizeof(SRpcEpSet);
+
+ mDebug("msg:%p, app:%p type:%s in write queue, is redirected, numOfEps:%d inUse:%d", pMsg, ahandle,
+ taosMsg[msgType], epSet->numOfEps, epSet->inUse);
+
+ return TSDB_CODE_RPC_REDIRECT;
+ }
+
+ if (tsMworker.writeMsgFp[msgType] == NULL) {
+ mError("msg:%p, app:%p type:%s not processed", pMsg, ahandle, taosMsg[msgType]);
+ return TSDB_CODE_MND_MSG_NOT_PROCESSED;
+ }
+
+ return (*tsMworker.writeMsgFp[msgType])(pMsg);
+}
+
+static int32_t mnodeProcessReadReq(void* unused, SMnMsg *pMsg, int32_t qtype) {
+ int32_t msgType = pMsg->rpcMsg.msgType;
+ void *ahandle = pMsg->rpcMsg.ahandle;
+
+ if (pMsg->rpcMsg.pCont == NULL) {
+ mError("msg:%p, app:%p type:%s in mread queue, content is null", pMsg, ahandle, taosMsg[msgType]);
+ return TSDB_CODE_MND_INVALID_MSG_LEN;
+ }
+
+ if (!mnodeIsMaster()) {
+ SMnRsp *rpcRsp = &pMsg->rpcRsp;
+ SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
+ if (!epSet) {
+ return TSDB_CODE_MND_OUT_OF_MEMORY;
+ }
+ mnodeGetMnodeEpSetForShell(epSet, true);
+ rpcRsp->rsp = epSet;
+ rpcRsp->len = sizeof(SRpcEpSet);
+
+ mDebug("msg:%p, app:%p type:%s in mread queue is redirected, numOfEps:%d inUse:%d", pMsg, ahandle, taosMsg[msgType],
+ epSet->numOfEps, epSet->inUse);
+ return TSDB_CODE_RPC_REDIRECT;
+ }
+
+ if (tsMworker.readMsgFp[msgType] == NULL) {
+ mError("msg:%p, app:%p type:%s in mread queue, not processed", pMsg, ahandle, taosMsg[msgType]);
+ return TSDB_CODE_MND_MSG_NOT_PROCESSED;
+ }
+
+ mTrace("msg:%p, app:%p type:%s will be processed in mread queue", pMsg, ahandle, taosMsg[msgType]);
+ return (*tsMworker.readMsgFp[msgType])(pMsg);
+}
+
+static int32_t mnodeProcessPeerReq(void *unused, SMnMsg *pMsg, int32_t qtype) {
+ int32_t msgType = pMsg->rpcMsg.msgType;
+ void * ahandle = pMsg->rpcMsg.ahandle;
+
+ if (pMsg->rpcMsg.pCont == NULL) {
+ mError("msg:%p, ahandle:%p type:%s in mpeer queue, content is null", pMsg, ahandle, taosMsg[msgType]);
+ return TSDB_CODE_MND_INVALID_MSG_LEN;
+ }
+
+ if (!mnodeIsMaster()) {
+ SMnRsp *rpcRsp = &pMsg->rpcRsp;
+ SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
+ mnodeGetMnodeEpSetForPeer(epSet, true);
+ rpcRsp->rsp = epSet;
+ rpcRsp->len = sizeof(SRpcEpSet);
+
+ mDebug("msg:%p, ahandle:%p type:%s in mpeer queue is redirected, numOfEps:%d inUse:%d", pMsg, ahandle,
+ taosMsg[msgType], epSet->numOfEps, epSet->inUse);
+
+ return TSDB_CODE_RPC_REDIRECT;
+ }
+
+ if (tsMworker.peerReqFp[msgType] == NULL) {
+ mError("msg:%p, ahandle:%p type:%s in mpeer queue, not processed", pMsg, ahandle, taosMsg[msgType]);
+ return TSDB_CODE_MND_MSG_NOT_PROCESSED;
+ }
+
+ return (*tsMworker.peerReqFp[msgType])(pMsg);
+}
+
+static int32_t mnodeProcessPeerRsp(void *ahandle, SMnMsg *pMsg, int32_t qtype) {
+ int32_t msgType = pMsg->rpcMsg.msgType;
+ SRpcMsg *pRpcMsg = &pMsg->rpcMsg;
+
+ if (!mnodeIsMaster()) {
+ mError("msg:%p, ahandle:%p type:%s not processed for not master", pRpcMsg, pRpcMsg->ahandle, taosMsg[msgType]);
+ return 0;
+ }
+
+ if (tsMworker.peerRspFp[msgType]) {
+ (*tsMworker.peerRspFp[msgType])(pRpcMsg);
+ } else {
+ mError("msg:%p, ahandle:%p type:%s is not processed", pRpcMsg, pRpcMsg->ahandle, taosMsg[msgType]);
+ }
+
+ return 0;
+}
+
+int32_t mnodeInitWorker() {
+ mnodeInitMsgFp();
+
+ SWorkerPool *pPool = &tsMworker.write;
+ pPool->name = "mnode-write";
+ pPool->startFp = (ProcessStartFp)mnodeProcessWriteReq;
+ pPool->endFp = (ProcessEndFp)mnodeSendRpcRsp;
+ pPool->min = 1;
+ pPool->max = 1;
+ if (tWorkerInit(pPool) != 0) {
+ return TSDB_CODE_MND_OUT_OF_MEMORY;
+ } else {
+ tsMworker.writeQ = tWorkerAllocQueue(pPool, NULL);
+ }
+
+ pPool = &tsMworker.read;
+ pPool->name = "mnode-read";
+ pPool->startFp = (ProcessStartFp)mnodeProcessReadReq;
+ pPool->endFp = (ProcessEndFp)mnodeSendRpcRsp;
+ pPool->min = 2;
+ pPool->max = (int32_t)(tsNumOfCores * tsNumOfThreadsPerCore / 2);
+ pPool->max = MAX(2, pPool->max);
+ pPool->max = MIN(4, pPool->max);
+ if (tWorkerInit(pPool) != 0) {
+ return TSDB_CODE_MND_OUT_OF_MEMORY;
+ } else {
+ tsMworker.readQ = tWorkerAllocQueue(pPool, NULL);
+ }
+
+ pPool = &tsMworker.peerReq;
+ pPool->name = "mnode-peer-req";
+ pPool->startFp = (ProcessStartFp)mnodeProcessPeerReq;
+ pPool->endFp = (ProcessEndFp)mnodeSendRpcRsp;
+ pPool->min = 1;
+ pPool->max = 1;
+ if (tWorkerInit(pPool) != 0) {
+ return TSDB_CODE_MND_OUT_OF_MEMORY;
+ } else {
+ tsMworker.peerReqQ = tWorkerAllocQueue(pPool, NULL);
+ }
+
+ pPool = &tsMworker.peerRsp;
+ pPool->name = "mnode-peer-rsp";
+ pPool->startFp = (ProcessStartFp)mnodeProcessPeerRsp;
+ pPool->endFp = (ProcessEndFp)mnodeProcessPeerRspEnd;
+ pPool->min = 1;
+ pPool->max = 1;
+ if (tWorkerInit(pPool) != 0) {
+ return TSDB_CODE_MND_OUT_OF_MEMORY;
+ } else {
+ tsMworker.peerRspQ = tWorkerAllocQueue(pPool, NULL);
+ }
+
+ mInfo("mnode worker is initialized");
+ return 0;
+}
+
+void mnodeCleanupWorker() {
+ tWorkerFreeQueue(&tsMworker.write, tsMworker.writeQ);
+ tWorkerCleanup(&tsMworker.write);
+ tsMworker.writeQ = NULL;
+
+ tWorkerFreeQueue(&tsMworker.read, tsMworker.readQ);
+ tWorkerCleanup(&tsMworker.read);
+ tsMworker.readQ = NULL;
+
+ tWorkerFreeQueue(&tsMworker.peerReq, tsMworker.peerReqQ);
+ tWorkerCleanup(&tsMworker.peerReq);
+ tsMworker.peerReqQ = NULL;
+
+ tWorkerFreeQueue(&tsMworker.peerRsp, tsMworker.peerRspQ);
+ tWorkerCleanup(&tsMworker.peerRsp);
+ tsMworker.peerRspQ = NULL;
+
+ mInfo("mnode worker is closed");
+}
+
+void mnodeProcessMsg(SRpcMsg *pMsg) {
+ if (tsMworker.msgFp[pMsg->msgType]) {
+ (*tsMworker.msgFp[pMsg->msgType])(pMsg);
+ } else {
+ assert(0);
+ }
+}
diff --git a/source/server/mnode/src/mondeInt.c b/source/server/mnode/src/mondeInt.c
new file mode 100644
index 0000000000000000000000000000000000000000..37af26f6042830c3320b2bdd1120db08d92cb374
--- /dev/null
+++ b/source/server/mnode/src/mondeInt.c
@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * 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 .
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tglobal.h"
+#include "tstep.h"
+#include "mnodeAcct.h"
+#include "mnodeAuth.h"
+#include "mnodeBalance.h"
+#include "mnodeCluster.h"
+#include "mnodeDb.h"
+#include "mnodeDnode.h"
+#include "mnodeFunc.h"
+#include "mnodeMnode.h"
+#include "mnodeOper.h"
+#include "mnodeProfile.h"
+#include "mnodeSdb.h"
+#include "mnodeShow.h"
+#include "mnodeStable.h"
+#include "mnodeSync.h"
+#include "mnodeUser.h"
+#include "mnodeVgroup.h"
+#include "mnodeWorker.h"
+#include "mnodeTelem.h"
+
+static struct {
+ int32_t state;
+ int32_t dnodeId;
+ char clusterId[TSDB_CLUSTER_ID_LEN];
+ tmr_h timer;
+ SMnodeFp fp;
+ SSteps * steps1;
+ SSteps * steps2;
+} tsMint;
+
+tmr_h mnodeGetTimer() { return tsMint.timer; }
+
+int32_t mnodeGetDnodeId() { return tsMint.dnodeId; }
+
+char *mnodeGetClusterId() { return tsMint.clusterId; }
+
+EMnStatus mnodeGetStatus() { return tsMint.state; }
+
+void mnodeSendMsgToDnode(struct SRpcEpSet *epSet, struct SRpcMsg *rpcMsg) {
+ (*tsMint.fp.SendMsgToDnode)(epSet, rpcMsg);
+}
+
+void mnodeSendMsgToMnode(struct SRpcMsg *rpcMsg) { return (*tsMint.fp.SendMsgToMnode)(rpcMsg); }
+
+void mnodeSendRedirectMsg(struct SRpcMsg *rpcMsg, bool forShell) { (*tsMint.fp.SendRedirectMsg)(rpcMsg, forShell); }
+
+void mnodeGetDnodeEp(int32_t dnodeId, char *ep, char *fqdn, uint16_t *port) {
+ (*tsMint.fp.GetDnodeEp)(dnodeId, ep, fqdn, port);
+}
+
+int32_t mnodeGetStatistics(SMnodeStat *stat) { return 0; }
+
+static int32_t mnodeSetPara(SMnodePara para) {
+ tsMint.fp = para.fp;
+ tsMint.dnodeId = para.dnodeId;
+ strncpy(tsMint.clusterId, para.clusterId, TSDB_CLUSTER_ID_LEN);
+
+ if (tsMint.fp.SendMsgToDnode == NULL) return -1;
+ if (tsMint.fp.SendMsgToMnode == NULL) return -1;
+ if (tsMint.fp.SendRedirectMsg == NULL) return -1;
+ if (tsMint.dnodeId < 0) return -1;
+
+ return 0;
+}
+
+static int32_t mnodeInitTimer() {
+ if (tsMint.timer == NULL) {
+ tsMint.timer = taosTmrInit(tsMaxShellConns, 200, 3600000, "MND");
+ }
+
+ return 0;
+}
+
+static void mnodeCleanupTimer() {
+ if (tsMint.timer != NULL) {
+ taosTmrCleanUp(tsMint.timer);
+ tsMint.timer = NULL;
+ }
+}
+
+static int32_t mnodeInitStep1() {
+ struct SSteps *steps = taosStepInit(16, NULL);
+ if (steps == NULL) return -1;
+
+ taosStepAdd(steps, "mnode-sdb", sdbInit, sdbCleanup);
+ taosStepAdd(steps, "mnode-cluster", mnodeInitCluster, mnodeCleanupCluster);
+ taosStepAdd(steps, "mnode-dnode", mnodeInitDnode, mnodeCleanupDnode);
+ taosStepAdd(steps, "mnode-mnode", mnodeInitMnode, mnodeCleanupMnode);
+ taosStepAdd(steps, "mnode-acct", mnodeInitAcct, mnodeCleanupAcct);
+ taosStepAdd(steps, "mnode-auth", mnodeInitAuth, mnodeCleanupAuth);
+ taosStepAdd(steps, "mnode-user", mnodeInitUser, mnodeCleanupUser);
+ taosStepAdd(steps, "mnode-db", mnodeInitDb, mnodeCleanupDb);
+ taosStepAdd(steps, "mnode-vgroup", mnodeInitVgroup, mnodeCleanupVgroup);
+ taosStepAdd(steps, "mnode-stable", mnodeInitStable, mnodeCleanupStable);
+ taosStepAdd(steps, "mnode-func", mnodeInitFunc, mnodeCleanupFunc);
+ taosStepAdd(steps, "mnode-oper", mnodeInitOper, mnodeCleanupOper);
+
+ tsMint.steps1 = steps;
+ return taosStepExec(tsMint.steps1);
+}
+
+static int32_t mnodeInitStep2() {
+ struct SSteps *steps = taosStepInit(12, NULL);
+ if (steps == NULL) return -1;
+
+ taosStepAdd(steps, "mnode-timer", mnodeInitTimer, NULL);
+ taosStepAdd(steps, "mnode-worker", mnodeInitWorker, NULL);
+ taosStepAdd(steps, "mnode-balance", mnodeInitBalance, mnodeCleanupBalance);
+ taosStepAdd(steps, "mnode-profile", mnodeInitProfile, mnodeCleanupProfile);
+ taosStepAdd(steps, "mnode-show", mnodeInitShow, mnodeCleanUpShow);
+ taosStepAdd(steps, "mnode-sync", mnodeInitSync, mnodeCleanUpSync);
+ taosStepAdd(steps, "mnode-worker", NULL, mnodeCleanupWorker);
+ taosStepAdd(steps, "mnode-telem", mnodeInitTelem, mnodeCleanupTelem);
+ taosStepAdd(steps, "mnode-timer", NULL, mnodeCleanupTimer);
+
+ tsMint.steps2 = steps;
+ return taosStepExec(tsMint.steps2);
+}
+
+static void mnodeCleanupStep1() { taosStepCleanup(tsMint.steps1); }
+
+static void mnodeCleanupStep2() { taosStepCleanup(tsMint.steps2); }
+
+static bool mnodeNeedDeploy() {
+ if (tsMint.dnodeId > 0) return false;
+ if (tsMint.clusterId[0] != 0) return false;
+ if (strcmp(tsFirst, tsLocalEp) != 0) return false;
+ return true;
+}
+
+int32_t mnodeDeploy() {
+ if (tsMint.state != MN_STATUS_UNINIT) {
+ mError("failed to deploy mnode since its deployed");
+ return 0;
+ } else {
+ tsMint.state = MN_STATUS_INIT;
+ }
+
+ if (tsMint.dnodeId <= 0 || tsMint.clusterId[0] == 0) {
+ mError("failed to deploy mnode since cluster not ready");
+ return TSDB_CODE_MND_NOT_READY;
+ }
+
+ mInfo("starting to deploy mnode");
+
+ int32_t code = mnodeInitStep1();
+ if (code != 0) {
+ mError("failed to deploy mnode since init step1 error");
+ tsMint.state = MN_STATUS_UNINIT;
+ return TSDB_CODE_MND_SDB_ERROR;
+ }
+
+ code = mnodeInitStep2();
+ if (code != 0) {
+ mnodeCleanupStep1();
+ mError("failed to deploy mnode since init step2 error");
+ tsMint.state = MN_STATUS_UNINIT;
+ return TSDB_CODE_MND_SDB_ERROR;
+ }
+
+ mDebug("mnode is deployed and waiting for raft to confirm");
+ tsMint.state = MN_STATUS_READY;
+ return 0;
+}
+
+void mnodeUnDeploy() {
+ sdbUnDeploy();
+ mnodeCleanup();
+}
+
+int32_t mnodeInit(SMnodePara para) {
+ mDebugFlag = 207;
+ if (tsMint.state != MN_STATUS_UNINIT) {
+ return 0;
+ } else {
+ tsMint.state = MN_STATUS_INIT;
+ }
+
+ mInfo("starting to initialize mnode ...");
+
+ int32_t code = mnodeSetPara(para);
+ if (code != 0) {
+ tsMint.state = MN_STATUS_UNINIT;
+ return code;
+ }
+
+ code = mnodeInitStep1();
+ if (code != 0) {
+ tsMint.state = MN_STATUS_UNINIT;
+ return -1;
+ }
+
+ code = sdbRead();
+ if (code != 0) {
+ if (mnodeNeedDeploy()) {
+ code = sdbDeploy();
+ if (code != 0) {
+ mnodeCleanupStep1();
+ tsMint.state = MN_STATUS_UNINIT;
+ return -1;
+ }
+ } else {
+ mnodeCleanupStep1();
+ tsMint.state = MN_STATUS_UNINIT;
+ return -1;
+ }
+ }
+
+ code = mnodeInitStep2();
+ if (code != 0) {
+ mnodeCleanupStep1();
+ tsMint.state = MN_STATUS_UNINIT;
+ return -1;
+ }
+
+ tsMint.state = MN_STATUS_READY;
+ mInfo("mnode is initialized successfully");
+ return 0;
+}
+
+void mnodeCleanup() {
+ if (tsMint.state != MN_STATUS_UNINIT && tsMint.state != MN_STATUS_CLOSING) {
+ mInfo("starting to clean up mnode");
+ tsMint.state = MN_STATUS_CLOSING;
+
+ mnodeCleanupStep2();
+ mnodeCleanupStep1();
+
+ tsMint.state = MN_STATUS_UNINIT;
+ mInfo("mnode is cleaned up");
+ }
+}
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index e3d022a6b0a4a929b6c06b2c305fb71b6980a865..68cd067fb970e6e39a7a2c1bf370d860d5514e91 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -177,6 +177,10 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_PASS_FORMAT, "Invalid password form
TAOS_DEFINE_ERROR(TSDB_CODE_MND_NO_USER_FROM_CONN, "Can not get user from conn")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_USERS, "Too many users")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_MNODE_ALREADY_EXIST, "Mnode already exists")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_MNODE_NOT_EXIST, "Mnode not there")
+
+
TAOS_DEFINE_ERROR(TSDB_CODE_MND_TABLE_ALREADY_EXIST, "Table already exists")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_ID, "Table name too long")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_NAME, "Table does not exist")
diff --git a/source/util/src/tstep.c b/source/util/src/tstep.c
index 656ac658a01455f6538eab9f0ac39c9255919738..8162fb76ed717fb45eef6249ce38c9226f683d46 100644
--- a/source/util/src/tstep.c
+++ b/source/util/src/tstep.c
@@ -18,7 +18,7 @@
#include "ulog.h"
#include "tstep.h"
-typedef struct SStepObj {
+typedef struct {
char * name;
InitFp initFp;
CleanupFp cleanupFp;
diff --git a/source/util/src/tworker.c b/source/util/src/tworker.c
index 9e21583895bba8785cea19f417c50e60a50e359b..abed265e0b76204ca3537c776fe425e50bbe97d7 100644
--- a/source/util/src/tworker.c
+++ b/source/util/src/tworker.c
@@ -76,7 +76,7 @@ static void *tWorkerThreadFp(SWorker *worker) {
}
code = (*pool->startFp)(ahandle, msg, qtype);
- (*pool->endFp)(ahandle, msg, qtype, code);
+ if (pool->endFp) (*pool->endFp)(ahandle, msg, qtype, code);
}
return NULL;
diff --git a/src/mnode/CMakeLists.txt b/src/mnode/CMakeLists.txt
deleted file mode 100644
index 54b67f6530e2a4f1eafba467dca59f2cf0e34c71..0000000000000000000000000000000000000000
--- a/src/mnode/CMakeLists.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-aux_source_directory(source MNODE_SRC)
-add_library(mnode ${MNODE_SRC})
-target_include_directories(
- mnode
- PUBLIC "${CMAKE_SOURCE_DIR}/include/mnode"
- PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include"
-)
\ No newline at end of file
diff --git a/src/mnode/CMakeLists.txt.in b/src/mnode/CMakeLists.txt.in
deleted file mode 100644
index a7fc54d87786f430f913980f089d29d969b01fce..0000000000000000000000000000000000000000
--- a/src/mnode/CMakeLists.txt.in
+++ /dev/null
@@ -1,10 +0,0 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20)
-PROJECT(TDengine)
-
-INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
-INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/dnode/inc)
-
-INCLUDE_DIRECTORIES(inc)
-AUX_SOURCE_DIRECTORY(src SRC)
-
-ADD_LIBRARY(mnode ${SRC})
diff --git a/src/mnode/inc/mnodeAcct.h b/src/mnode/inc/mnodeAcct.h
deleted file mode 100644
index 522070e90990eed599d659d7a0356c0853fe0676..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeAcct.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_ACCT_H
-#define TDENGINE_MNODE_ACCT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "tacct.h"
-
-int32_t mnodeInitAccts();
-void mnodeCleanupAccts();
-void mnodeGetStatOfAllAcct(SAcctInfo* pAcctInfo);
-void * mnodeGetAcct(char *acctName);
-void * mnodeGetNextAcct(void *pIter, SAcctObj **pAcct);
-void mnodeCancelGetNextAcct(void *pIter);
-void mnodeIncAcctRef(SAcctObj *pAcct);
-void mnodeDecAcctRef(SAcctObj *pAcct);
-void mnodeAddDbToAcct(SAcctObj *pAcct, SDbObj *pDb);
-void mnodeDropDbFromAcct(SAcctObj *pAcct, SDbObj *pDb);
-void mnodeAddUserToAcct(SAcctObj *pAcct, SUserObj *pUser);
-void mnodeDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser);
-
-int32_t mnodeCompactAccts();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/inc/mnodeDb.h b/src/mnode/inc/mnodeDb.h
deleted file mode 100644
index 40c5afc2c84cd497095a508df42b9e89ad638d70..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeDb.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_DB_H
-#define TDENGINE_MNODE_DB_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "mnodeDef.h"
-
-enum _TSDB_DB_STATUS {
- TSDB_DB_STATUS_READY,
- TSDB_DB_STATUS_DROPPING
-};
-
-// api
-int32_t mnodeInitDbs();
-void mnodeCleanupDbs();
-int64_t mnodeGetDbNum();
-int32_t mnodeGetDbMaxReplica();
-SDbObj *mnodeGetDb(char *db);
-SDbObj *mnodeGetDbByTableName(char *db);
-void * mnodeGetNextDb(void *pIter, SDbObj **pDb);
-void mnodeCancelGetNextDb(void *pIter);
-void mnodeIncDbRef(SDbObj *pDb);
-void mnodeDecDbRef(SDbObj *pDb);
-bool mnodeCheckIsMonitorDB(char *db, char *monitordb);
-void mnodeDropAllDbs(SAcctObj *pAcct);
-int mnodeInsertAlterDbRow(SDbObj *pDb, void *pMsg);
-
-int32_t mnodeCompactDbs();
-
-// util func
-void mnodeAddSuperTableIntoDb(SDbObj *pDb);
-void mnodeRemoveSuperTableFromDb(SDbObj *pDb);
-void mnodeAddTableIntoDb(SDbObj *pDb);
-void mnodeRemoveTableFromDb(SDbObj *pDb);
-void mnodeAddVgroupIntoDb(SVgObj *pVgroup);
-void mnodeRemoveVgroupFromDb(SVgObj *pVgroup);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/inc/mnodeDef.h b/src/mnode/inc/mnodeDef.h
deleted file mode 100644
index 5acc8dd85eb7fe8cd3f4b17f47e06161e39a6dc4..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeDef.h
+++ /dev/null
@@ -1,292 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_DEF_H
-#define TDENGINE_MNODE_DEF_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "taosdef.h"
-#include "taosmsg.h"
-
-struct SVgObj;
-struct SDbObj;
-struct SAcctObj;
-struct SUserObj;
-struct SMnodeObj;
-
-/*
-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;
-*/
-
-typedef struct SClusterObj {
- char uid[TSDB_CLUSTER_ID_LEN];
- int64_t createdTime;
- int8_t reserved[12];
- int8_t updateEnd[4];
- int32_t refCount;
-} 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];
-} 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;
- int8_t role;
- 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;
-
-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;
-
-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;
-
-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 {
- int32_t cacheBlockSize;
- int32_t totalBlocks;
- int32_t maxTables;
- int32_t daysPerFile;
- int32_t daysToKeep0;
- int32_t daysToKeep1;
- int32_t daysToKeep2;
- int32_t minRowsPerFileBlock;
- int32_t maxRowsPerFileBlock;
- int32_t commitTime;
- int32_t fsyncPeriod;
- int8_t precision;
- int8_t compression;
- int8_t walLevel;
- int8_t replications;
- int8_t quorum;
- int8_t update;
- 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;
-} 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;
-
-typedef struct SAcctObj {
- char user[TSDB_USER_LEN];
- char pass[TSDB_KEY_LEN];
- SAcctCfg cfg;
- int64_t createdTime;
- int32_t acctId;
- 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;
-
-typedef struct {
- char db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
- int8_t type;
- 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;
- char payload[];
-} SShowObj;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/inc/mnodeDnode.h b/src/mnode/inc/mnodeDnode.h
deleted file mode 100644
index 10f79582d4a492622e1cc425d69aaa95966846d7..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeDnode.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_DNODE_H
-#define TDENGINE_MNODE_DNODE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
- TAOS_DN_STATUS_OFFLINE,
- TAOS_DN_STATUS_DROPPING,
- TAOS_DN_STATUS_BALANCING,
- TAOS_DN_STATUS_READY
-} EDnodeStatus;
-
-typedef enum {
- TAOS_DN_ALTERNATIVE_ROLE_ANY,
- TAOS_DN_ALTERNATIVE_ROLE_MNODE,
- TAOS_DN_ALTERNATIVE_ROLE_VNODE
-} EDnodeAlternativeRole;
-
-typedef enum EDnodeOfflineReason {
- TAOS_DN_OFF_ONLINE = 0,
- TAOS_DN_OFF_STATUS_MSG_TIMEOUT,
- TAOS_DN_OFF_STATUS_NOT_RECEIVED,
- TAOS_DN_OFF_RESET_BY_MNODE,
- TAOS_DN_OFF_VERSION_NOT_MATCH,
- TAOS_DN_OFF_DNODE_ID_NOT_MATCH,
- TAOS_DN_OFF_CLUSTER_ID_NOT_MATCH,
- TAOS_DN_OFF_NUM_OF_MNODES_NOT_MATCH,
- TAOS_DN_OFF_ENABLE_BALANCE_NOT_MATCH,
- TAOS_DN_OFF_MN_EQUAL_VN_NOT_MATCH,
- TAOS_DN_OFF_OFFLINE_THRESHOLD_NOT_MATCH,
- TAOS_DN_OFF_STATUS_INTERVAL_NOT_MATCH,
- TAOS_DN_OFF_MAX_TAB_PER_VN_NOT_MATCH,
- TAOS_DN_OFF_MAX_VG_PER_DB_NOT_MATCH,
- TAOS_DN_OFF_ARBITRATOR_NOT_MATCH,
- TAOS_DN_OFF_TIME_ZONE_NOT_MATCH,
- TAOS_DN_OFF_LOCALE_NOT_MATCH,
- TAOS_DN_OFF_CHARSET_NOT_MATCH,
- TAOS_DN_OFF_FLOW_CTRL_NOT_MATCH,
- TAOS_DN_OFF_SLAVE_QUERY_NOT_MATCH,
- TAOS_DN_OFF_ADJUST_MASTER_NOT_MATCH,
- TAOS_DN_OFF_OTHERS
-} EDnodeOfflineReason;
-
-extern char* dnodeStatus[];
-extern char* dnodeRoles[];
-
-int32_t mnodeInitDnodes();
-void mnodeCleanupDnodes();
-
-int32_t mnodeGetDnodesNum();
-int32_t mnodeGetOnlinDnodesCpuCoreNum();
-int32_t mnodeGetOnlineDnodesNum();
-void mnodeGetOnlineAndTotalDnodesNum(int32_t *onlineNum, int32_t *totalNum);
-void * mnodeGetNextDnode(void *pIter, SDnodeObj **pDnode);
-void mnodeCancelGetNextDnode(void *pIter);
-void mnodeIncDnodeRef(SDnodeObj *pDnode);
-void mnodeDecDnodeRef(SDnodeObj *pDnode);
-void * mnodeGetDnode(int32_t dnodeId);
-void * mnodeGetDnodeByEp(char *ep);
-void mnodeUpdateDnode(SDnodeObj *pDnode);
-int32_t mnodeDropDnode(SDnodeObj *pDnode, void *pMsg);
-
-int32_t mnodeCompactDnodes();
-extern int64_t tsAccessSquence;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/inc/mnodeFunc.h b/src/mnode/inc/mnodeFunc.h
deleted file mode 100644
index e33f3fb5671faeea39154a8ed98cb8923d54a501..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeFunc.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_FUNC_H
-#define TDENGINE_MNODE_FUNC_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "mnodeDef.h"
-
-int32_t mnodeInitFuncs();
-void mnodeCleanupFuncs();
-
-SFuncObj *mnodeGetFunc(char *name);
-void * mnodeGetNextFunc(void *pIter, SFuncObj **pFunc);
-void mnodeCancelGetNextFunc(void *pIter);
-
-void mnodeIncFuncRef(SFuncObj *pFunc);
-void mnodeDecFuncRef(SFuncObj *pFunc);
-
-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);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/inc/mnodeInt.h b/src/mnode/inc/mnodeInt.h
deleted file mode 100644
index 7a791d76e6796cfed22657f1bc7ffdb26890ea40..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeInt.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_LOG_H
-#define TDENGINE_MNODE_LOG_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "tlog.h"
-#include "monitor.h"
-
-extern int32_t mDebugFlag;
-extern int32_t sdbDebugFlag;
-
-// mnode log function
-#define mFatal(...) { if (mDebugFlag & DEBUG_FATAL) { taosPrintLog("MND FATAL ", 255, __VA_ARGS__); }}
-#define mError(...) { if (mDebugFlag & DEBUG_ERROR) { taosPrintLog("MND ERROR ", 255, __VA_ARGS__); }}
-#define mWarn(...) { if (mDebugFlag & DEBUG_WARN) { taosPrintLog("MND WARN ", 255, __VA_ARGS__); }}
-#define mInfo(...) { if (mDebugFlag & DEBUG_INFO) { taosPrintLog("MND ", 255, __VA_ARGS__); }}
-#define mDebug(...) { if (mDebugFlag & DEBUG_DEBUG) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
-#define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
-
-#define sdbFatal(...) { if (sdbDebugFlag & DEBUG_FATAL) { taosPrintLog("SDB FATAL ", 255, __VA_ARGS__); }}
-#define sdbError(...) { if (sdbDebugFlag & DEBUG_ERROR) { taosPrintLog("SDB ERROR ", 255, __VA_ARGS__); }}
-#define sdbWarn(...) { if (sdbDebugFlag & DEBUG_WARN) { taosPrintLog("SDB WARN ", 255, __VA_ARGS__); }}
-#define sdbInfo(...) { if (sdbDebugFlag & DEBUG_INFO) { taosPrintLog("SDB ", 255, __VA_ARGS__); }}
-#define sdbDebug(...) { if (sdbDebugFlag & DEBUG_DEBUG) { taosPrintLog("SDB ", sdbDebugFlag, __VA_ARGS__); }}
-#define sdbTrace(...) { if (sdbDebugFlag & DEBUG_TRACE) { taosPrintLog("SDB ", sdbDebugFlag, __VA_ARGS__); }}
-
-#define mLError(...) { monSaveLog(2, __VA_ARGS__); mError(__VA_ARGS__) }
-#define mLWarn(...) { monSaveLog(1, __VA_ARGS__); mWarn(__VA_ARGS__) }
-#define mLInfo(...) { monSaveLog(0, __VA_ARGS__); mInfo(__VA_ARGS__) }
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/inc/mnodeMnode.h b/src/mnode/inc/mnodeMnode.h
deleted file mode 100644
index 66e9eb1e0e5da6092d6fa8c9840e4f4d5472c07b..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeMnode.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_MNODE_H
-#define TDENGINE_MNODE_MNODE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct SMnodeObj;
-
-typedef enum {
- TAOS_MN_STATUS_OFFLINE,
- TAOS_MN_STATUS_DROPPING,
- TAOS_MN_STATUS_READY
-} EMnodeStatus;
-
-int32_t mnodeInitMnodes();
-void mnodeCleanupMnodes();
-
-void mnodeCreateMnode(int32_t dnodeId, char *dnodeEp, bool needConfirm);
-int32_t mnodeDropMnode(int32_t dnodeId);
-void mnodeDropMnodeLocal(int32_t dnodeId);
-
-void * mnodeGetMnode(int32_t mnodeId);
-int32_t mnodeGetMnodesNum();
-void * mnodeGetNextMnode(void *pIter, struct SMnodeObj **pMnode);
-void mnodeCancelGetNextMnode(void *pIter);
-void mnodeIncMnodeRef(struct SMnodeObj *pMnode);
-void mnodeDecMnodeRef(struct SMnodeObj *pMnode);
-
-char * mnodeGetMnodeRoleStr();
-void mnodeGetMnodeEpSetForPeer(SRpcEpSet *epSet, bool redirect);
-void mnodeGetMnodeEpSetForShell(SRpcEpSet *epSet, bool redirect);
-char* mnodeGetMnodeMasterEp();
-
-void mnodeGetMnodeInfos(void *mnodes);
-void mnodeUpdateMnodeEpSet(SMInfos *pMnodes);
-
-int32_t mnodeCompactMnodes();
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/inc/mnodeProfile.h b/src/mnode/inc/mnodeProfile.h
deleted file mode 100644
index ee57c5da1f66b620e8624a74ba774643c589e818..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeProfile.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_PROFILE_H
-#define TDENGINE_MNODE_PROFILE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "mnodeDef.h"
-
-typedef struct {
- char user[TSDB_USER_LEN];
- char appName[TSDB_APPNAME_LEN]; // app name that invokes taosc
- uint32_t pid; // pid of app that invokes taosc
- int8_t killed;
- uint16_t port;
- uint32_t ip;
- uint32_t connId;
- uint64_t stime;
- uint64_t lastAccess;
- uint32_t queryId;
- uint32_t streamId;
- int32_t numOfQueries;
- int32_t numOfStreams;
- SStreamDesc *pStreams;
- SQueryDesc * pQueries;
-} SConnObj;
-
-int32_t mnodeInitProfile();
-void mnodeCleanupProfile();
-
-SConnObj *mnodeCreateConn(char *user, uint32_t ip, uint16_t port, int32_t pid, const char* app);
-SConnObj *mnodeAccquireConn(int32_t connId, char *user, uint32_t ip, uint16_t port);
-void mnodeReleaseConn(SConnObj *pConn);
-int32_t mnodeSaveQueryStreamList(SConnObj *pConn, SHeartBeatMsg *pHBMsg);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
\ No newline at end of file
diff --git a/src/mnode/inc/mnodeSdb.h b/src/mnode/inc/mnodeSdb.h
deleted file mode 100644
index 25b841ef34d35c0691ead226f6be46e12e298125..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeSdb.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_SDB_H
-#define TDENGINE_MNODE_SDB_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "mnode.h"
-#include "twal.h"
-
-typedef enum {
- SDB_TABLE_CLUSTER = 0,
- SDB_TABLE_DNODE = 1,
- SDB_TABLE_MNODE = 2,
- SDB_TABLE_ACCOUNT = 3,
- SDB_TABLE_USER = 4,
- SDB_TABLE_DB = 5,
- SDB_TABLE_VGROUP = 6,
- SDB_TABLE_STABLE = 7,
- SDB_TABLE_CTABLE = 8,
- SDB_TABLE_FUNC = 9,
- SDB_TABLE_MAX = 10
-} ESdbTable;
-
-typedef enum {
- SDB_KEY_STRING = 0,
- SDB_KEY_INT = 1,
- SDB_KEY_AUTO = 2,
- SDB_KEY_VAR_STRING = 3,
-} ESdbKey;
-
-typedef enum {
- SDB_OPER_GLOBAL = 0,
- SDB_OPER_LOCAL = 1
-} ESdbOper;
-
-typedef struct SSdbRow {
- ESdbOper type;
- int32_t processedCount; // for sync fwd callback
- int32_t code; // for callback in sdb queue
- int32_t rowSize;
- void * rowData;
- void * pObj;
- void * pTable;
- SMnodeMsg *pMsg;
- int32_t (*fpReq)(SMnodeMsg *pMsg);
- int32_t (*fpRsp)(SMnodeMsg *pMsg, int32_t code);
- char reserveForSync[24];
- SWalHead pHead;
-} SSdbRow;
-
-typedef struct {
- char * name;
- int32_t hashSessions;
- int32_t maxRowSize;
- int32_t refCountPos;
- ESdbTable id;
- ESdbKey keyType;
- int32_t (*fpInsert)(SSdbRow *pRow);
- int32_t (*fpDelete)(SSdbRow *pRow);
- int32_t (*fpUpdate)(SSdbRow *pRow);
- int32_t (*fpEncode)(SSdbRow *pRow);
- int32_t (*fpDecode)(SSdbRow *pRow);
- int32_t (*fpDestroy)(SSdbRow *pRow);
- int32_t (*fpRestored)();
-} SSdbTableDesc;
-
-int32_t sdbInitRef();
-void sdbCleanUpRef();
-int32_t sdbInit();
-void sdbCleanUp();
-int64_t sdbOpenTable(SSdbTableDesc *desc);
-void sdbCloseTable(int64_t rid);
-void* sdbGetTableByRid(int64_t rid);
-bool sdbIsMaster();
-bool sdbIsServing();
-void sdbUpdateMnodeRoles();
-int32_t sdbGetReplicaNum();
-
-int32_t sdbInsertRow(SSdbRow *pRow);
-int32_t sdbInsertCompactRow(SSdbRow *pRow);
-int32_t sdbDeleteRow(SSdbRow *pRow);
-int32_t sdbUpdateRow(SSdbRow *pRow);
-int32_t sdbInsertRowToQueue(SSdbRow *pRow);
-
-void * sdbGetRow(void *pTable, void *key);
-void * sdbFetchRow(void *pTable, void *pIter, void **ppRow);
-void sdbFreeIter(void *pTable, void *pIter);
-void sdbIncRef(void *pTable, void *pRow);
-void sdbDecRef(void *pTable, void *pRow);
-int64_t sdbGetNumOfRows(void *pTable);
-int32_t sdbGetId(void *pTable);
-uint64_t sdbGetVersion();
-bool sdbCheckRowDeleted(void *pTable, void *pRow);
-
-int32_t mnodeCompactWal();
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/inc/mnodeShow.h b/src/mnode/inc/mnodeShow.h
deleted file mode 100644
index f985fe792dec7b09dd91bc6c037ffed8da771fb7..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeShow.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_SHELL_H
-#define TDENGINE_MNODE_SHELL_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "mnodeDef.h"
-
-int32_t mnodeInitShow();
-void mnodeCleanUpShow();
-
-typedef int32_t (*SShowMetaFp)(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-typedef int32_t (*SShowRetrieveFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-typedef void (*SShowFreeIterFp)(void *pIter);
-void mnodeAddShowMetaHandle(uint8_t showType, SShowMetaFp fp);
-void mnodeAddShowRetrieveHandle(uint8_t showType, SShowRetrieveFp fp);
-void mnodeAddShowFreeIterHandle(uint8_t msgType, SShowFreeIterFp fp);
-void mnodeVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_t capacity, SShowObj *pShow);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/inc/mnodeTable.h b/src/mnode/inc/mnodeTable.h
deleted file mode 100644
index c583a60c7a1f26fd798d78ce15eb6fa060a9d151..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeTable.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TBASE_MNODE_TABLE_H
-#define TBASE_MNODE_TABLE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "mnodeDef.h"
-
-int32_t mnodeInitTables();
-void mnodeCleanupTables();
-int64_t mnodeGetSuperTableNum();
-int64_t mnodeGetChildTableNum();
-void * mnodeGetTable(char *tableId);
-void mnodeIncTableRef(void *pTable);
-void mnodeDecTableRef(void *pTable);
-void * mnodeGetNextChildTable(void *pIter, SCTableObj **pTable);
-void * mnodeGetNextSuperTable(void *pIter, SSTableObj **pTable);
-void mnodeCancelGetNextChildTable(void *pIter);
-void mnodeCancelGetNextSuperTable(void *pIter);
-void mnodeDropAllChildTables(SDbObj *pDropDb);
-void mnodeDropAllSuperTables(SDbObj *pDropDb);
-void mnodeDropAllChildTablesInVgroups(SVgObj *pVgroup);
-int32_t mnodeCompactTables();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/inc/mnodeUser.h b/src/mnode/inc/mnodeUser.h
deleted file mode 100644
index b8f08051203e229e5fee17982ab5a47de20c41a9..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeUser.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_USER_H
-#define TDENGINE_MNODE_USER_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "mnodeDef.h"
-
-int32_t mnodeInitUsers();
-void mnodeCleanupUsers();
-SUserObj *mnodeGetUser(char *name);
-void * mnodeGetNextUser(void *pIter, SUserObj **pUser);
-void mnodeCancelGetNextUser(void *pIter);
-void mnodeIncUserRef(SUserObj *pUser);
-void mnodeDecUserRef(SUserObj *pUser);
-SUserObj *mnodeGetUserFromConn(void *pConn);
-char * mnodeGetUserFromMsg(void *pMnodeMsg);
-int32_t mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass, void *pMsg);
-void mnodeDropAllUsers(SAcctObj *pAcct);
-
-int32_t mnodeCompactUsers();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/inc/mnodeVgroup.h b/src/mnode/inc/mnodeVgroup.h
deleted file mode 100644
index aff0411fdd777f83ccc6a882fbe91d7bc909e16b..0000000000000000000000000000000000000000
--- a/src/mnode/inc/mnodeVgroup.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#ifndef TDENGINE_MNODE_VGROUP_H
-#define TDENGINE_MNODE_VGROUP_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct SMnodeMsg;
-
-int32_t mnodeInitVgroups();
-void mnodeCleanupVgroups();
-int64_t mnodeGetVgroupNum();
-SVgObj *mnodeGetVgroup(int32_t vgId);
-void mnodeIncVgroupRef(SVgObj *pVgroup);
-void mnodeDecVgroupRef(SVgObj *pVgroup);
-void mnodeDropAllDbVgroups(SDbObj *pDropDb);
-void mnodeSendDropAllDbVgroupsMsg(SDbObj *pDropDb);
-void mnodeDropAllDnodeVgroups(SDnodeObj *pDropDnode);
-//void mnodeUpdateAllDbVgroups(SDbObj *pAlterDb);
-int32_t mnodeCompactVgroups();
-
-void * mnodeGetNextVgroup(void *pIter, SVgObj **pVgroup);
-void mnodeCancelGetNextVgroup(void *pIter);
-void mnodeUpdateVgroup(SVgObj *pVgroup);
-void mnodeUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVload);
-void mnodeCheckUnCreatedVgroup(SDnodeObj *pDnode, SVnodeLoad *pVloads, int32_t openVnodes);
-
-int32_t mnodeCreateVgroup(struct SMnodeMsg *pMsg);
-void mnodeDropVgroup(SVgObj *pVgroup, void *ahandle);
-void mnodeAlterVgroup(SVgObj *pVgroup, void *ahandle);
-int32_t mnodeGetAvailableVgroup(struct SMnodeMsg *pMsg, SVgObj **pVgroup, int32_t *sid);
-
-int32_t mnodeAddTableIntoVgroup(SVgObj *pVgroup, SCTableObj *pTable, bool needCheck);
-void mnodeRemoveTableFromVgroup(SVgObj *pVgroup, SCTableObj *pTable);
-void mnodeSendDropVnodeMsg(int32_t vgId, SRpcEpSet *epSet, void *ahandle);
-void mnodeSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle);
-void mnodeSendAlterVgroupMsg(SVgObj *pVgroup,SMnodeMsg *pMsg);
-void mnodeSendSyncVgroupMsg(SVgObj *pVgroup);
-void mnodeSendCompactVgroupMsg(SVgObj *pVgroup);
-
-SRpcEpSet mnodeGetEpSetFromVgroup(SVgObj *pVgroup);
-SRpcEpSet mnodeGetEpSetFromIp(char *ep);
-
-int32_t mnodeGetVgidVer(int8_t *vver);
-void mnodeSetVgidVer(int8_t *cver, uint64_t iver);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/mnode/src/mnodeAcct.c b/src/mnode/src/mnodeAcct.c
deleted file mode 100644
index 64cfa28917cf6923230f0b7f70500c921c0d5a84..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeAcct.c
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "tglobal.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeDb.h"
-#include "mnodeSdb.h"
-#include "mnodeUser.h"
-#include "mnodeVgroup.h"
-
-int64_t tsAcctRid = -1;
-void * tsAcctSdb = NULL;
-static int32_t tsAcctUpdateSize;
-static int32_t mnodeCreateRootAcct();
-
-static int32_t mnodeAcctActionDestroy(SSdbRow *pRow) {
- SAcctObj *pAcct = pRow->pObj;
- pthread_mutex_destroy(&pAcct->mutex);
- tfree(pRow->pObj);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionInsert(SSdbRow *pRow) {
- SAcctObj *pAcct = pRow->pObj;
- memset(&pAcct->acctInfo, 0, sizeof(SAcctInfo));
- pAcct->acctInfo.accessState = TSDB_VN_ALL_ACCCESS;
- pthread_mutex_init(&pAcct->mutex, NULL);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionDelete(SSdbRow *pRow) {
- SAcctObj *pAcct = pRow->pObj;
- mnodeDropAllUsers(pAcct);
- mnodeDropAllDbs(pAcct);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionUpdate(SSdbRow *pRow) {
- SAcctObj *pAcct = pRow->pObj;
- SAcctObj *pSaved = mnodeGetAcct(pAcct->user);
- if (pAcct != pSaved) {
- memcpy(pSaved, pAcct, tsAcctUpdateSize);
- free(pAcct);
- }
- mnodeDecAcctRef(pSaved);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionEncode(SSdbRow *pRow) {
- SAcctObj *pAcct = pRow->pObj;
- memcpy(pRow->rowData, pAcct, tsAcctUpdateSize);
- pRow->rowSize = tsAcctUpdateSize;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionDecode(SSdbRow *pRow) {
- SAcctObj *pAcct = (SAcctObj *) calloc(1, sizeof(SAcctObj));
- if (pAcct == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
- memcpy(pAcct, pRow->rowData, tsAcctUpdateSize);
- pRow->pObj = pAcct;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAcctActionRestored() {
- int64_t numOfRows = sdbGetNumOfRows(tsAcctSdb);
- if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
- mInfo("dnode first deploy, create root acct");
- int32_t code = mnodeCreateRootAcct();
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("failed to create root account, reason:%s", tstrerror(code));
- return code;
- }
- }
-
- acctInit();
- return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitAccts() {
- SAcctObj tObj;
- tsAcctUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
- SSdbTableDesc desc = {
- .id = SDB_TABLE_ACCOUNT,
- .name = "accounts",
- .hashSessions = TSDB_DEFAULT_ACCOUNTS_HASH_SIZE,
- .maxRowSize = tsAcctUpdateSize,
- .refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
- .keyType = SDB_KEY_STRING,
- .fpInsert = mnodeAcctActionInsert,
- .fpDelete = mnodeAcctActionDelete,
- .fpUpdate = mnodeAcctActionUpdate,
- .fpEncode = mnodeAcctActionEncode,
- .fpDecode = mnodeAcctActionDecode,
- .fpDestroy = mnodeAcctActionDestroy,
- .fpRestored = mnodeAcctActionRestored
- };
-
- tsAcctRid = sdbOpenTable(&desc);
- tsAcctSdb = sdbGetTableByRid(tsAcctRid);
- if (tsAcctSdb == NULL) {
- mError("table:%s, failed to create hash", desc.name);
- return -1;
- }
-
- mDebug("table:%s, hash is created", desc.name);
- return TSDB_CODE_SUCCESS;
-}
-
-void mnodeCleanupAccts() {
- acctCleanUp();
- sdbCloseTable(tsAcctRid);
- tsAcctSdb = NULL;
-}
-
-void mnodeGetStatOfAllAcct(SAcctInfo* pAcctInfo) {
- memset(pAcctInfo, 0, sizeof(*pAcctInfo));
-
- void *pIter = NULL;
- SAcctObj *pAcct = NULL;
- while (1) {
- pIter = mnodeGetNextAcct(pIter, &pAcct);
- if (pAcct == NULL) {
- break;
- }
- pAcctInfo->numOfDbs += pAcct->acctInfo.numOfDbs;
- pAcctInfo->numOfTimeSeries += pAcct->acctInfo.numOfTimeSeries;
- mnodeDecAcctRef(pAcct);
- }
-
- SVgObj *pVgroup = NULL;
- pIter = NULL;
- while (1) {
- pIter = mnodeGetNextVgroup(pIter, &pVgroup);
- if (pVgroup == NULL) {
- break;
- }
- pAcctInfo->totalStorage += pVgroup->totalStorage;
- pAcctInfo->compStorage += pVgroup->compStorage;
- pAcctInfo->totalPoints += pVgroup->pointsWritten;
- mnodeDecVgroupRef(pVgroup);
- }
-}
-
-void *mnodeGetAcct(char *name) {
- return sdbGetRow(tsAcctSdb, name);
-}
-
-void *mnodeGetNextAcct(void *pIter, SAcctObj **pAcct) {
- return sdbFetchRow(tsAcctSdb, pIter, (void **)pAcct);
-}
-
-void mnodeCancelGetNextAcct(void *pIter) {
- sdbFreeIter(tsAcctSdb, pIter);
-}
-
-void mnodeIncAcctRef(SAcctObj *pAcct) {
- sdbIncRef(tsAcctSdb, pAcct);
-}
-
-void mnodeDecAcctRef(SAcctObj *pAcct) {
- sdbDecRef(tsAcctSdb, pAcct);
-}
-
-void mnodeAddDbToAcct(SAcctObj *pAcct, SDbObj *pDb) {
- atomic_add_fetch_32(&pAcct->acctInfo.numOfDbs, 1);
- pDb->pAcct = pAcct;
- mnodeIncAcctRef(pAcct);
-}
-
-void mnodeDropDbFromAcct(SAcctObj *pAcct, SDbObj *pDb) {
- atomic_sub_fetch_32(&pAcct->acctInfo.numOfDbs, 1);
- pDb->pAcct = NULL;
- mnodeDecAcctRef(pAcct);
-}
-
-void mnodeAddUserToAcct(SAcctObj *pAcct, SUserObj *pUser) {
- atomic_add_fetch_32(&pAcct->acctInfo.numOfUsers, 1);
- pUser->pAcct = pAcct;
- mnodeIncAcctRef(pAcct);
-}
-
-void mnodeDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser) {
- atomic_sub_fetch_32(&pAcct->acctInfo.numOfUsers, 1);
- pUser->pAcct = NULL;
- mnodeDecAcctRef(pAcct);
-}
-
-static int32_t mnodeCreateRootAcct() {
- int64_t numOfAccts = sdbGetNumOfRows(tsAcctSdb);
- if (numOfAccts != 0) return TSDB_CODE_SUCCESS;
-
- SAcctObj *pAcct = malloc(sizeof(SAcctObj));
- memset(pAcct, 0, sizeof(SAcctObj));
- strcpy(pAcct->user, TSDB_DEFAULT_USER);
- taosEncryptPass((uint8_t *)TSDB_DEFAULT_PASS, strlen(TSDB_DEFAULT_PASS), pAcct->pass);
- pAcct->cfg = (SAcctCfg){
- .maxUsers = 128,
- .maxDbs = 128,
- .maxTimeSeries = INT32_MAX,
- .maxConnections = 1024,
- .maxStreams = 1000,
- .maxPointsPerSecond = 10000000,
- .maxStorage = INT64_MAX,
- .maxQueryTime = INT64_MAX,
- .maxInbound = 0,
- .maxOutbound = 0,
- .accessState = TSDB_VN_ALL_ACCCESS
- };
- pAcct->acctId = sdbGetId(tsAcctSdb);
- pAcct->createdTime = taosGetTimestampMs();
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsAcctSdb,
- .pObj = pAcct,
- };
-
- return sdbInsertRow(&row);
-}
-
-int32_t mnodeCompactAccts() {
- void *pIter = NULL;
- SAcctObj *pAcct = NULL;
-
- mInfo("start to compact accts table...");
-
- while (1) {
- pIter = mnodeGetNextAcct(pIter, &pAcct);
- if (pAcct == NULL) break;
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsAcctSdb,
- .pObj = pAcct,
- };
-
- mInfo("compact accts %s", pAcct->user);
-
- sdbInsertCompactRow(&row);
- }
-
- mInfo("end to compact accts table...");
-
- return 0;
-}
-
-#ifndef _ACCT
-
-int32_t acctInit() { return TSDB_CODE_SUCCESS; }
-void acctCleanUp() {}
-int32_t acctCheck(void *pAcct, EAcctGrantType type) { return TSDB_CODE_SUCCESS; }
-
-#endif
diff --git a/src/mnode/src/mnodeCluster.c b/src/mnode/src/mnodeCluster.c
deleted file mode 100644
index 553e8446ab449cb3eab8bcc3c15bef8715fe978a..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeCluster.c
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeCluster.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "tglobal.h"
-
-int64_t tsClusterRid = -1;
-static void * tsClusterSdb = NULL;
-static int32_t tsClusterUpdateSize;
-static char tsClusterId[TSDB_CLUSTER_ID_LEN];
-static int32_t mnodeCreateCluster();
-
-static int32_t mnodeGetClusterMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveClusters(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void mnodeCancelGetNextCluster(void *pIter);
-
-static int32_t mnodeClusterActionDestroy(SSdbRow *pRow) {
- tfree(pRow->pObj);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionInsert(SSdbRow *pRow) {
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionDelete(SSdbRow *pRow) {
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionUpdate(SSdbRow *pRow) {
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionEncode(SSdbRow *pRow) {
- SClusterObj *pCluster = pRow->pObj;
- memcpy(pRow->rowData, pCluster, tsClusterUpdateSize);
- pRow->rowSize = tsClusterUpdateSize;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionDecode(SSdbRow *pRow) {
- SClusterObj *pCluster = (SClusterObj *) calloc(1, sizeof(SClusterObj));
- if (pCluster == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
- memcpy(pCluster, pRow->rowData, tsClusterUpdateSize);
- pRow->pObj = pCluster;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeClusterActionRestored() {
- int64_t numOfRows = sdbGetNumOfRows(tsClusterSdb);
- if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
- mInfo("dnode first deploy, create cluster");
- int32_t code = mnodeCreateCluster();
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("failed to create cluster, reason:%s", tstrerror(code));
- return code;
- }
- }
-
- mnodeUpdateClusterId();
- return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitCluster() {
- SClusterObj tObj;
- tsClusterUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
- SSdbTableDesc desc = {
- .id = SDB_TABLE_CLUSTER,
- .name = "cluster",
- .hashSessions = TSDB_DEFAULT_CLUSTER_HASH_SIZE,
- .maxRowSize = tsClusterUpdateSize,
- .refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
- .keyType = SDB_KEY_STRING,
- .fpInsert = mnodeClusterActionInsert,
- .fpDelete = mnodeClusterActionDelete,
- .fpUpdate = mnodeClusterActionUpdate,
- .fpEncode = mnodeClusterActionEncode,
- .fpDecode = mnodeClusterActionDecode,
- .fpDestroy = mnodeClusterActionDestroy,
- .fpRestored = mnodeClusterActionRestored
- };
-
- tsClusterRid = sdbOpenTable(&desc);
- tsClusterSdb = sdbGetTableByRid(tsClusterRid);
- if (tsClusterSdb == NULL) {
- mError("table:%s, rid:%" PRId64 ", failed to create hash", desc.name, tsClusterRid);
- return -1;
- }
-
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CLUSTER, mnodeGetClusterMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CLUSTER, mnodeRetrieveClusters);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_CLUSTER, mnodeCancelGetNextCluster);
-
- mDebug("table:%s, hash is created", desc.name);
- return TSDB_CODE_SUCCESS;
-}
-
-void mnodeCleanupCluster() {
- sdbCloseTable(tsClusterRid);
- tsClusterSdb = NULL;
-}
-
-void *mnodeGetNextCluster(void *pIter, SClusterObj **pCluster) {
- return sdbFetchRow(tsClusterSdb, pIter, (void **)pCluster);
-}
-
-void mnodeCancelGetNextCluster(void *pIter) {
- sdbFreeIter(tsClusterSdb, pIter);
-}
-
-void mnodeIncClusterRef(SClusterObj *pCluster) {
- sdbIncRef(tsClusterSdb, pCluster);
-}
-
-void mnodeDecClusterRef(SClusterObj *pCluster) {
- sdbDecRef(tsClusterSdb, pCluster);
-}
-
-static int32_t mnodeCreateCluster() {
- int64_t numOfClusters = sdbGetNumOfRows(tsClusterSdb);
- if (numOfClusters != 0) return TSDB_CODE_SUCCESS;
-
- SClusterObj *pCluster = malloc(sizeof(SClusterObj));
- memset(pCluster, 0, sizeof(SClusterObj));
- pCluster->createdTime = taosGetTimestampMs();
- bool getuid = taosGetSystemUid(pCluster->uid);
- if (!getuid) {
- strcpy(pCluster->uid, "tdengine2.0");
- mError("failed to get uid from system, set to default val %s", pCluster->uid);
- } else {
- mDebug("uid is %s", pCluster->uid);
- }
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsClusterSdb,
- .pObj = pCluster,
- };
-
- return sdbInsertRow(&row);
-}
-
-const char* mnodeGetClusterId() {
- return tsClusterId;
-}
-
-void mnodeUpdateClusterId() {
- SClusterObj *pCluster = NULL;
- void *pIter = mnodeGetNextCluster(NULL, &pCluster);
- if (pCluster != NULL) {
- tstrncpy(tsClusterId, pCluster->uid, TSDB_CLUSTER_ID_LEN);
- mDebug("cluster id is set to %s", tsClusterId);
- }
-
- mnodeDecClusterRef(pCluster);
- mnodeCancelGetNextCluster(pIter);
-}
-
-static int32_t mnodeGetClusterMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = TSDB_CLUSTER_ID_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "clusterId");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "create_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- strcpy(pMeta->tableFname, "show cluster");
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = 1;
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
- return 0;
-}
-
-static int32_t mnodeRetrieveClusters(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- int32_t cols = 0;
- char * pWrite;
- SClusterObj *pCluster = NULL;
-
- while (numOfRows < rows) {
- pShow->pIter = mnodeGetNextCluster(pShow->pIter, &pCluster);
- if (pCluster == NULL) break;
-
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pCluster->uid, TSDB_CLUSTER_ID_LEN);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *) pWrite = pCluster->createdTime;
- cols++;
-
- mnodeDecClusterRef(pCluster);
- numOfRows++;
- }
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- pShow->numOfReads += numOfRows;
- return numOfRows;
-}
-
-int32_t mnodeCompactCluster() {
- SClusterObj *pCluster = NULL;
- void *pIter;
-
- mInfo("start to compact cluster table...");
-
- pIter = mnodeGetNextCluster(NULL, &pCluster);
- while (pCluster) {
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsClusterSdb,
- .pObj = pCluster,
- };
-
- sdbInsertCompactRow(&row);
-
- pIter = mnodeGetNextCluster(pIter, &pCluster);
- }
-
- mInfo("end to compact cluster table...");
-
- return 0;
-}
\ No newline at end of file
diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c
deleted file mode 100644
index 9602e16483f3a367117f998cc619dbe408859d93..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeDb.c
+++ /dev/null
@@ -1,1417 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "tutil.h"
-#include "tgrant.h"
-#include "tglobal.h"
-#include "tname.h"
-#include "tbn.h"
-#include "tdataformat.h"
-#include "tp.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeDb.h"
-#include "mnodeDnode.h"
-#include "mnodeMnode.h"
-#include "mnodePeer.h"
-#include "mnodeProfile.h"
-#include "mnodeWrite.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeTable.h"
-#include "mnodeUser.h"
-#include "mnodeVgroup.h"
-
-#define VG_LIST_SIZE 8
-int64_t tsDbRid = -1;
-void * tsDbSdb = NULL;
-static int32_t tsDbUpdateSize;
-
-static int32_t mnodeCreateDb(SAcctObj *pAcct, SCreateDbMsg *pCreate, SMnodeMsg *pMsg);
-static int32_t mnodeDropDb(SMnodeMsg *newMsg);
-static int32_t mnodeSetDbDropping(SDbObj *pDb);
-static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessSyncDbMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessCompactMsg(SMnodeMsg *pMsg);
-int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg);
-
-#ifndef _TOPIC
-int32_t tpInit() { return 0; }
-void tpCleanUp() {}
-void tpUpdateTs(int32_t vgId, int64_t *seq, void *pMsg) {}
-#endif
-
-static void mnodeDestroyDb(SDbObj *pDb) {
- pthread_mutex_destroy(&pDb->mutex);
- tfree(pDb->vgList);
- tfree(pDb);
-}
-
-static int32_t mnodeDbActionDestroy(SSdbRow *pRow) {
- mnodeDestroyDb(pRow->pObj);
- return TSDB_CODE_SUCCESS;
-}
-
-int64_t mnodeGetDbNum() {
- return sdbGetNumOfRows(tsDbSdb);
-}
-
-int32_t mnodeGetDbMaxReplica() {
- int32_t maxReplica = 0;
- SDbObj *pDb = NULL;
- void *pIter = NULL;
-
- while (1) {
- pIter = mnodeGetNextDb(pIter, &pDb);
- if (pDb == NULL) break;
-
- if (pDb->cfg.replications > maxReplica)
- maxReplica = pDb->cfg.replications;
-
- mnodeDecDbRef(pDb);
- }
-
- return maxReplica;
-}
-
-static int32_t mnodeDbActionInsert(SSdbRow *pRow) {
- SDbObj *pDb = pRow->pObj;
- SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
-
- pthread_mutex_init(&pDb->mutex, NULL);
- pthread_mutex_lock(&pDb->mutex);
- pDb->vgListSize = VG_LIST_SIZE;
- pDb->vgList = calloc(pDb->vgListSize, sizeof(SVgObj *));
- pDb->numOfVgroups = 0;
- pthread_mutex_unlock(&pDb->mutex);
-
- pDb->numOfTables = 0;
- pDb->numOfSuperTables = 0;
-
- if (pAcct != NULL) {
- mnodeAddDbToAcct(pAcct, pDb);
- mnodeDecAcctRef(pAcct);
- }
- else {
- mError("db:%s, acct:%s info not exist in sdb", pDb->name, pDb->acct);
- return TSDB_CODE_MND_INVALID_ACCT;
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDbActionDelete(SSdbRow *pRow) {
- SDbObj *pDb = pRow->pObj;
- SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
-
- mnodeDropAllChildTables(pDb);
- mnodeDropAllSuperTables(pDb);
- mnodeDropAllDbVgroups(pDb);
-
- if (pAcct) {
- mnodeDropDbFromAcct(pAcct, pDb);
- mnodeDecAcctRef(pAcct);
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDbActionUpdate(SSdbRow *pRow) {
- SDbObj *pNew = pRow->pObj;
- SDbObj *pDb = mnodeGetDb(pNew->name);
- if (pDb != NULL && pNew != pDb) {
- memcpy(pDb, pNew, pRow->rowSize);
- free(pNew->vgList);
- free(pNew);
- }
- //mnodeUpdateAllDbVgroups(pDb);
- mnodeDecDbRef(pDb);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDbActionEncode(SSdbRow *pRow) {
- SDbObj *pDb = pRow->pObj;
- memcpy(pRow->rowData, pDb, tsDbUpdateSize);
- pRow->rowSize = tsDbUpdateSize;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDbActionDecode(SSdbRow *pRow) {
- SDbObj *pDb = (SDbObj *) calloc(1, sizeof(SDbObj));
- if (pDb == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
- memcpy(pDb, pRow->rowData, tsDbUpdateSize);
- pRow->pObj = pDb;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDbActionRestored() {
- return 0;
-}
-
-int32_t mnodeInitDbs() {
- SDbObj tObj;
- tsDbUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
- SSdbTableDesc desc = {
- .id = SDB_TABLE_DB,
- .name = "dbs",
- .hashSessions = TSDB_DEFAULT_DBS_HASH_SIZE,
- .maxRowSize = tsDbUpdateSize,
- .refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
- .keyType = SDB_KEY_STRING,
- .fpInsert = mnodeDbActionInsert,
- .fpDelete = mnodeDbActionDelete,
- .fpUpdate = mnodeDbActionUpdate,
- .fpEncode = mnodeDbActionEncode,
- .fpDecode = mnodeDbActionDecode,
- .fpDestroy = mnodeDbActionDestroy,
- .fpRestored = mnodeDbActionRestored
- };
-
- tsDbRid = sdbOpenTable(&desc);
- tsDbSdb = sdbGetTableByRid(tsDbRid);
- if (tsDbSdb == NULL) {
- mError("failed to init db data");
- return -1;
- }
-
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DB, mnodeProcessCreateDbMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_ALTER_DB, mnodeProcessAlterDbMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_DB, mnodeProcessDropDbMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_SYNC_DB, mnodeProcessSyncDbMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_COMPACT_VNODE, mnodeProcessCompactMsg);
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DB, mnodeGetDbMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DB, mnodeRetrieveDbs);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_DB, mnodeCancelGetNextDb);
-
-
- mDebug("table:dbs table is created");
- return tpInit();
-}
-
-void *mnodeGetNextDb(void *pIter, SDbObj **pDb) {
- return sdbFetchRow(tsDbSdb, pIter, (void **)pDb);
-}
-
-void mnodeCancelGetNextDb(void *pIter) {
- sdbFreeIter(tsDbSdb, pIter);
-}
-
-SDbObj *mnodeGetDb(char *db) {
- return (SDbObj *)sdbGetRow(tsDbSdb, db);
-}
-
-void mnodeIncDbRef(SDbObj *pDb) {
- sdbIncRef(tsDbSdb, pDb);
-}
-
-void mnodeDecDbRef(SDbObj *pDb) {
- sdbDecRef(tsDbSdb, pDb);
-}
-
-SDbObj *mnodeGetDbByTableName(char *tableName) {
- SName name = {0};
- tNameFromString(&name, tableName, T_NAME_ACCT|T_NAME_DB|T_NAME_TABLE);
-
- // validate the tableName?
- char db[TSDB_TABLE_FNAME_LEN] = {0};
- tNameGetFullDbName(&name, db);
-
- return mnodeGetDb(db);
-}
-
-static int32_t mnodeCheckDbCfg(SDbCfg *pCfg) {
- if (pCfg->cacheBlockSize < TSDB_MIN_CACHE_BLOCK_SIZE || pCfg->cacheBlockSize > TSDB_MAX_CACHE_BLOCK_SIZE) {
- mError("invalid db option cacheBlockSize:%d valid range: [%d, %d]", pCfg->cacheBlockSize, TSDB_MIN_CACHE_BLOCK_SIZE,
- TSDB_MAX_CACHE_BLOCK_SIZE);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->totalBlocks < TSDB_MIN_TOTAL_BLOCKS || pCfg->totalBlocks > TSDB_MAX_TOTAL_BLOCKS) {
- mError("invalid db option totalBlocks:%d valid range: [%d, %d]", pCfg->totalBlocks, TSDB_MIN_TOTAL_BLOCKS,
- TSDB_MAX_TOTAL_BLOCKS);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->maxTables < TSDB_MIN_TABLES || pCfg->maxTables > TSDB_MAX_TABLES) {
- mError("invalid db option maxTables:%d valid range: [%d, %d]", pCfg->maxTables, TSDB_MIN_TABLES, TSDB_MAX_TABLES);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) {
- mError("invalid db option daysPerFile:%d valid range: [%d, %d]", pCfg->daysPerFile, TSDB_MIN_DAYS_PER_FILE,
- TSDB_MAX_DAYS_PER_FILE);
- return TSDB_CODE_MND_INVALID_DB_OPTION_DAYS;
- }
-
- if (pCfg->daysToKeep0 < TSDB_MIN_KEEP || pCfg->daysToKeep0 > TSDB_MAX_KEEP) {
- mError("invalid db option daysToKeep:%d valid range: [%d, %d]", pCfg->daysToKeep0, TSDB_MIN_KEEP, TSDB_MAX_KEEP);
- return TSDB_CODE_MND_INVALID_DB_OPTION_KEEP;
- }
-
- if (pCfg->daysToKeep0 < pCfg->daysPerFile) {
- mError("invalid db option daysToKeep:%d should larger than daysPerFile:%d", pCfg->daysToKeep0, pCfg->daysPerFile);
- return TSDB_CODE_MND_INVALID_DB_OPTION_KEEP;
- }
-
- if (pCfg->daysToKeep1 < pCfg->daysToKeep0 || pCfg->daysToKeep1 > TSDB_MAX_KEEP) {
- mError("invalid db option daysToKeep1:%d valid range: [%d, %d]", pCfg->daysToKeep1, pCfg->daysToKeep0, TSDB_MAX_KEEP);
- return TSDB_CODE_MND_INVALID_DB_OPTION_KEEP;
- }
-
- if (pCfg->daysToKeep2 < pCfg->daysToKeep1 || pCfg->daysToKeep2 > TSDB_MAX_KEEP) {
- mError("invalid db option daysToKeep2:%d valid range: [%d, %d]", pCfg->daysToKeep2, pCfg->daysToKeep1, TSDB_MAX_KEEP);
- return TSDB_CODE_MND_INVALID_DB_OPTION_KEEP;
- }
-
-
- if (pCfg->maxRowsPerFileBlock < TSDB_MIN_MAX_ROW_FBLOCK || pCfg->maxRowsPerFileBlock > TSDB_MAX_MAX_ROW_FBLOCK) {
- mError("invalid db option maxRowsPerFileBlock:%d valid range: [%d, %d]", pCfg->maxRowsPerFileBlock,
- TSDB_MIN_MAX_ROW_FBLOCK, TSDB_MAX_MAX_ROW_FBLOCK);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->minRowsPerFileBlock < TSDB_MIN_MIN_ROW_FBLOCK || pCfg->minRowsPerFileBlock > TSDB_MAX_MIN_ROW_FBLOCK) {
- mError("invalid db option minRowsPerFileBlock:%d valid range: [%d, %d]", pCfg->minRowsPerFileBlock,
- TSDB_MIN_MIN_ROW_FBLOCK, TSDB_MAX_MIN_ROW_FBLOCK);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->minRowsPerFileBlock > pCfg->maxRowsPerFileBlock) {
- mError("invalid db option minRowsPerFileBlock:%d should smaller than maxRowsPerFileBlock:%d",
- pCfg->minRowsPerFileBlock, pCfg->maxRowsPerFileBlock);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->commitTime < TSDB_MIN_COMMIT_TIME || pCfg->commitTime > TSDB_MAX_COMMIT_TIME) {
- mError("invalid db option commitTime:%d valid range: [%d, %d]", pCfg->commitTime, TSDB_MIN_COMMIT_TIME,
- TSDB_MAX_COMMIT_TIME);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) {
- mError("invalid db option timePrecision:%d valid value: [%d, %d]", pCfg->precision, TSDB_MIN_PRECISION,
- TSDB_MAX_PRECISION);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) {
- mError("invalid db option compression:%d valid range: [%d, %d]", pCfg->compression, TSDB_MIN_COMP_LEVEL,
- TSDB_MAX_COMP_LEVEL);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) {
- mError("invalid db option walLevel:%d, valid range: [%d, %d]", pCfg->walLevel, TSDB_MIN_WAL_LEVEL, TSDB_MAX_WAL_LEVEL);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->fsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->fsyncPeriod > TSDB_MAX_FSYNC_PERIOD) {
- mError("invalid db option fsyncPeriod:%d, valid range: [%d, %d]", pCfg->fsyncPeriod, TSDB_MIN_FSYNC_PERIOD, TSDB_MAX_FSYNC_PERIOD);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->replications < TSDB_MIN_DB_REPLICA_OPTION || pCfg->replications > TSDB_MAX_DB_REPLICA_OPTION) {
- mError("invalid db option replications:%d valid range: [%d, %d]", pCfg->replications, TSDB_MIN_DB_REPLICA_OPTION,
- TSDB_MAX_DB_REPLICA_OPTION);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->replications > mnodeGetDnodesNum()) {
- mError("no enough dnode to config replica: %d, #dnodes: %d", pCfg->replications, mnodeGetDnodesNum());
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->quorum > pCfg->replications) {
- mError("invalid db option quorum:%d larger than replica:%d", pCfg->quorum, pCfg->replications);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->quorum < TSDB_MIN_DB_QUORUM_OPTION || pCfg->quorum > TSDB_MAX_DB_QUORUM_OPTION) {
- mError("invalid db option quorum:%d valid range: [%d, %d]", pCfg->quorum, TSDB_MIN_DB_QUORUM_OPTION,
- TSDB_MAX_DB_QUORUM_OPTION);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->update < TSDB_MIN_DB_UPDATE || pCfg->update > TSDB_MAX_DB_UPDATE) {
- mError("invalid db option update:%d valid range: [%d, %d]", pCfg->update, TSDB_MIN_DB_UPDATE, TSDB_MAX_DB_UPDATE);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->cacheLastRow < TSDB_MIN_DB_CACHE_LAST_ROW || pCfg->cacheLastRow > TSDB_MAX_DB_CACHE_LAST_ROW) {
- mError("invalid db option cacheLastRow:%d valid range: [%d, %d]", pCfg->cacheLastRow, TSDB_MIN_DB_CACHE_LAST_ROW, TSDB_MAX_DB_CACHE_LAST_ROW);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->dbType < 0 || pCfg->dbType > 1) {
- mError("invalid db option dbType:%d valid range: [%d, %d]", pCfg->dbType, 0, 1);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (pCfg->partitions < TSDB_MIN_DB_PARTITON_OPTION || pCfg->partitions > TSDB_MAX_DB_PARTITON_OPTION) {
- mError("invalid db option partitions:%d valid range: [%d, %d]", pCfg->partitions, TSDB_MIN_DB_PARTITON_OPTION,
- TSDB_MAX_DB_PARTITON_OPTION);
- return TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-static void mnodeSetDefaultDbCfg(SDbCfg *pCfg) {
- if (pCfg->cacheBlockSize < 0) pCfg->cacheBlockSize = tsCacheBlockSize;
- if (pCfg->totalBlocks < 0) pCfg->totalBlocks = tsBlocksPerVnode;
- if (pCfg->maxTables < 0) pCfg->maxTables = tsMaxTablePerVnode;
- if (pCfg->daysPerFile < 0) pCfg->daysPerFile = tsDaysPerFile;
- if (pCfg->daysToKeep2 < 0) pCfg->daysToKeep2 = tsDaysToKeep;
- if (pCfg->daysToKeep1 < 0) pCfg->daysToKeep1 = pCfg->daysToKeep2;
- if (pCfg->daysToKeep0 < 0) pCfg->daysToKeep0 = pCfg->daysToKeep1;
- if (pCfg->minRowsPerFileBlock < 0) pCfg->minRowsPerFileBlock = tsMinRowsInFileBlock;
- if (pCfg->maxRowsPerFileBlock < 0) pCfg->maxRowsPerFileBlock = tsMaxRowsInFileBlock;
- if (pCfg->fsyncPeriod <0) pCfg->fsyncPeriod = tsFsyncPeriod;
- if (pCfg->commitTime < 0) pCfg->commitTime = tsCommitTime;
- if (pCfg->precision < 0) pCfg->precision = tsTimePrecision;
- if (pCfg->compression < 0) pCfg->compression = tsCompression;
- if (pCfg->walLevel < 0) pCfg->walLevel = tsWAL;
- if (pCfg->replications < 0) pCfg->replications = tsReplications;
- if (pCfg->quorum < 0) pCfg->quorum = MIN(tsQuorum, pCfg->replications);
- if (pCfg->update < 0) pCfg->update = tsUpdate;
- if (pCfg->cacheLastRow < 0) pCfg->cacheLastRow = tsCacheLastRow;
- if (pCfg->dbType < 0) pCfg->dbType = 0;
- if (pCfg->partitions < 0) pCfg->partitions = tsPartitons;
-}
-
-static int32_t mnodeCreateDbCb(SMnodeMsg *pMsg, int32_t code) {
- SDbObj *pDb = pMsg->pDb;
- if (code == TSDB_CODE_SUCCESS) {
- mLInfo("db:%s, is created by %s", pDb->name, mnodeGetUserFromMsg(pMsg));
- } else {
- mError("db:%s, failed to create by %s, reason:%s", pDb->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
- }
-
- return code;
-}
-
-static int32_t mnodeCreateDb(SAcctObj *pAcct, SCreateDbMsg *pCreate, SMnodeMsg *pMsg) {
- int32_t code = acctCheck(pAcct, ACCT_GRANT_DB);
- if (code != 0) return code;
-
- SDbObj *pDb = mnodeGetDb(pCreate->db);
- if (pDb != NULL) {
- mnodeDecDbRef(pDb);
- if (pCreate->ignoreExist) {
- mDebug("db:%s, already exist, ignore exist is set", pCreate->db);
- return TSDB_CODE_SUCCESS;
- } else {
- mError("db:%s, already exist, ignore exist not set", pCreate->db);
- return TSDB_CODE_MND_DB_ALREADY_EXIST;
- }
- }
-
- code = grantCheck(TSDB_GRANT_DB);
- if (code != 0) return code;
-
- pDb = calloc(1, sizeof(SDbObj));
- tstrncpy(pDb->name, pCreate->db, sizeof(pDb->name));
- tstrncpy(pDb->acct, pAcct->user, sizeof(pDb->acct));
- pDb->createdTime = taosGetTimestampMs();
- pDb->cfg = (SDbCfg) {
- .cacheBlockSize = pCreate->cacheBlockSize,
- .totalBlocks = pCreate->totalBlocks,
- .maxTables = pCreate->maxTables,
- .daysPerFile = pCreate->daysPerFile,
- .daysToKeep0 = pCreate->daysToKeep0,
- .daysToKeep1 = pCreate->daysToKeep1,
- .daysToKeep2 = pCreate->daysToKeep2,
- .minRowsPerFileBlock = pCreate->minRowsPerFileBlock,
- .maxRowsPerFileBlock = pCreate->maxRowsPerFileBlock,
- .fsyncPeriod = pCreate->fsyncPeriod,
- .commitTime = pCreate->commitTime,
- .precision = pCreate->precision,
- .compression = pCreate->compression,
- .walLevel = pCreate->walLevel,
- .replications = pCreate->replications,
- .quorum = pCreate->quorum,
- .update = pCreate->update,
- .cacheLastRow = pCreate->cacheLastRow,
- .dbType = pCreate->dbType,
- .partitions = pCreate->partitions
- };
-
- mnodeSetDefaultDbCfg(&pDb->cfg);
-
- code = mnodeCheckDbCfg(&pDb->cfg);
- if (code != TSDB_CODE_SUCCESS) {
- tfree(pDb);
- return code;
- }
-
- pMsg->pDb = pDb;
- mnodeIncDbRef(pDb);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsDbSdb,
- .pObj = pDb,
- .rowSize = sizeof(SDbObj),
- .pMsg = pMsg,
- .fpRsp = mnodeCreateDbCb
- };
-
- code = sdbInsertRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("db:%s, failed to create, reason:%s", pDb->name, tstrerror(code));
- pMsg->pDb = NULL;
- mnodeDestroyDb(pDb);
- }
-
- return code;
-}
-
-bool mnodeCheckIsMonitorDB(char *db, char *monitordb) {
- char dbName[TSDB_DB_NAME_LEN] = {0};
- extractDBName(db, dbName);
-
- size_t len = strlen(dbName);
- return (strncasecmp(dbName, monitordb, len) == 0 && len == strlen(monitordb));
-}
-
-#if 0
-void mnodePrintVgroups(SDbObj *pDb, char *row) {
- mInfo("db:%s, vgroup link from head, row:%s", pDb->name, row);
- SVgObj *pVgroup = pDb->pHead;
- while (pVgroup != NULL) {
- mInfo("vgId:%d", pVgroup->vgId);
- pVgroup = pVgroup->next;
- }
-
- mInfo("db:%s, vgroup link from tail", pDb->name, pDb->numOfVgroups);
- pVgroup = pDb->pTail;
- while (pVgroup != NULL) {
- mInfo("vgId:%d", pVgroup->vgId);
- pVgroup = pVgroup->prev;
- }
-}
-#endif
-
-void mnodeAddVgroupIntoDb(SVgObj *pVgroup) {
- SDbObj *pDb = pVgroup->pDb;
-
- pthread_mutex_lock(&pDb->mutex);
- int32_t vgPos = pDb->numOfVgroups++;
- if (vgPos >= pDb->vgListSize) {
- pDb->vgList = realloc(pDb->vgList, pDb->vgListSize * 2 * sizeof(SVgObj *));
- memset(pDb->vgList + pDb->vgListSize, 0, pDb->vgListSize * sizeof(SVgObj *));
- pDb->vgListSize *= 2;
- }
-
- pDb->vgList[vgPos] = pVgroup;
- pthread_mutex_unlock(&pDb->mutex);
-}
-
-void mnodeRemoveVgroupFromDb(SVgObj *pVgroup) {
- SDbObj *pDb = pVgroup->pDb;
-
- pthread_mutex_lock(&pDb->mutex);
- for (int32_t v1 = 0; v1 < pDb->numOfVgroups; ++v1) {
- if (pDb->vgList[v1] == pVgroup) {
- for (int32_t v2 = v1; v2 < pDb->numOfVgroups - 1; ++v2) {
- pDb->vgList[v2] = pDb->vgList[v2 + 1];
- }
- pDb->numOfVgroups--;
- pDb->vgList[pDb->numOfVgroups] = NULL;
- break;
- }
- }
-
- pthread_mutex_unlock(&pDb->mutex);
-}
-
-void mnodeCleanupDbs() {
- tpCleanUp();
- sdbCloseTable(tsDbRid);
- tsDbSdb = NULL;
-}
-
-
-
-
-static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- int32_t cols = 0;
-
- SSchema *pSchema = pMeta->schema;
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) return 0;
-
- pShow->bytes[cols] = (TSDB_DB_NAME_LEN - 1) + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "name");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "created_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "ntables");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
-#ifndef __CLOUD_VERSION__
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "vgroups");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-#ifndef __CLOUD_VERSION__
- }
-#endif
-
-#ifndef __CLOUD_VERSION__
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "replica");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "quorum");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "days");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-#ifndef __CLOUD_VERSION__
- }
-#endif
-
- pShow->bytes[cols] = 24 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-
-#ifdef _STORAGE
- strcpy(pSchema[cols].name, "keep0,keep1,keep2");
-#else
- strcpy(pSchema[cols].name, "keep");
-#endif
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
-#ifndef __CLOUD_VERSION__
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "cache(MB)");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "blocks");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "minrows");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "maxrows");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 1;
- pSchema[cols].type = TSDB_DATA_TYPE_TINYINT;
- strcpy(pSchema[cols].name, "wallevel");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "fsync");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 1;
- pSchema[cols].type = TSDB_DATA_TYPE_TINYINT;
- strcpy(pSchema[cols].name, "comp");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 1;
- pSchema[cols].type = TSDB_DATA_TYPE_TINYINT;
- strcpy(pSchema[cols].name, "cachelast");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-#ifndef __CLOUD_VERSION__
- }
-#endif
-
- pShow->bytes[cols] = 3 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "precision");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 1;
- pSchema[cols].type = TSDB_DATA_TYPE_TINYINT;
- strcpy(pSchema[cols].name, "update");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 10 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "status");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
- pShow->numOfRows = pUser->pAcct->acctInfo.numOfDbs;
-
- mnodeDecUserRef(pUser);
- return 0;
-}
-
-char *mnodeGetDbStr(char *src) {
- char *pos = strstr(src, TS_PATH_DELIMITER);
- if (pos != NULL) ++pos;
-
- return pos;
-}
-
-static int32_t mnodeRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- SDbObj *pDb = NULL;
- char * pWrite;
- int32_t cols = 0;
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) return 0;
-
- while (numOfRows < rows) {
- pShow->pIter = mnodeGetNextDb(pShow->pIter, &pDb);
-
- if (pDb == NULL) break;
- if (pDb->pAcct != pUser->pAcct || pDb->status != TSDB_DB_STATUS_READY) {
- mnodeDecDbRef(pDb);
- continue;
- }
-
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- char* name = mnodeGetDbStr(pDb->name);
- if (name != NULL) {
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, name, pShow->bytes[cols]);
- } else {
- STR_TO_VARSTR(pWrite, "NULL");
- }
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = pDb->createdTime;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = pDb->numOfTables;
- cols++;
-
-#ifndef __CLOUD_VERSION__
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = pDb->numOfVgroups;
- cols++;
-#ifndef __CLOUD_VERSION__
- }
-#endif
-
-#ifndef __CLOUD_VERSION__
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = pDb->cfg.replications;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = pDb->cfg.quorum;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = pDb->cfg.daysPerFile;
- cols++;
-#ifndef __CLOUD_VERSION__
- }
-#endif
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
- char tmp[128] = {0};
-#ifdef _STORAGE
- if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {
- sprintf(tmp, "%d,%d,%d", pDb->cfg.daysToKeep1, pDb->cfg.daysToKeep2, pDb->cfg.daysToKeep0);
- } else {
- sprintf(tmp, "%d,%d,%d", pDb->cfg.daysToKeep0, pDb->cfg.daysToKeep1, pDb->cfg.daysToKeep2);
- }
-#else
- sprintf(tmp, "%d", pDb->cfg.daysToKeep2);
-#endif
- STR_WITH_SIZE_TO_VARSTR(pWrite, tmp, strlen(tmp));
- cols++;
-
-#ifndef __CLOUD_VERSION__
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
-#endif
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = pDb->cfg.cacheBlockSize;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = pDb->cfg.totalBlocks;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = pDb->cfg.minRowsPerFileBlock;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = pDb->cfg.maxRowsPerFileBlock;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int8_t *)pWrite = pDb->cfg.walLevel;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = pDb->cfg.fsyncPeriod;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int8_t *)pWrite = pDb->cfg.compression;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int8_t *)pWrite = pDb->cfg.cacheLastRow;
- cols++;
-#ifndef __CLOUD_VERSION__
- }
-#endif
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- char *prec = NULL;
- switch (pDb->cfg.precision) {
- case TSDB_TIME_PRECISION_MILLI: prec = TSDB_TIME_PRECISION_MILLI_STR; break;
- case TSDB_TIME_PRECISION_MICRO: prec = TSDB_TIME_PRECISION_MICRO_STR; break;
- case TSDB_TIME_PRECISION_NANO: prec = TSDB_TIME_PRECISION_NANO_STR; break;
- default: assert(false); break;
- }
- STR_WITH_SIZE_TO_VARSTR(pWrite, prec, 2);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int8_t *)pWrite = pDb->cfg.update;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- if (pDb->status == TSDB_DB_STATUS_READY) {
- const char *src = "ready";
- STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
- } else {
- const char *src = "dropping";
- STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
- }
- cols++;
-
- numOfRows++;
- mnodeDecDbRef(pDb);
- }
-
- pShow->numOfReads += numOfRows;
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-
- mnodeDecUserRef(pUser);
- return numOfRows;
-}
-
-void mnodeAddSuperTableIntoDb(SDbObj *pDb) {
- atomic_add_fetch_32(&pDb->numOfSuperTables, 1);
-}
-
-void mnodeRemoveSuperTableFromDb(SDbObj *pDb) {
- atomic_add_fetch_32(&pDb->numOfSuperTables, -1);
-}
-
-void mnodeAddTableIntoDb(SDbObj *pDb) {
- atomic_add_fetch_32(&pDb->numOfTables, 1);
-}
-
-void mnodeRemoveTableFromDb(SDbObj *pDb) {
- atomic_add_fetch_32(&pDb->numOfTables, -1);
-}
-
-static int32_t mnodeSetDbDropping(SDbObj *pDb) {
- if (pDb->status) return TSDB_CODE_SUCCESS;
-
- pDb->status = true;
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsDbSdb,
- .pObj = pDb
- };
-
- int32_t code = sdbUpdateRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("db:%s, failed to set dropping state, reason:%s", pDb->name, tstrerror(code));
- }
-
- return code;
-}
-
-static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg) {
- SCreateDbMsg *pCreate = pMsg->rpcMsg.pCont;
- pCreate->maxTables = htonl(pCreate->maxTables);
- pCreate->cacheBlockSize = htonl(pCreate->cacheBlockSize);
- pCreate->totalBlocks = htonl(pCreate->totalBlocks);
- pCreate->daysPerFile = htonl(pCreate->daysPerFile);
- pCreate->daysToKeep0 = htonl(pCreate->daysToKeep0);
- pCreate->daysToKeep1 = htonl(pCreate->daysToKeep1);
- pCreate->daysToKeep2 = htonl(pCreate->daysToKeep2);
- pCreate->commitTime = htonl(pCreate->commitTime);
- pCreate->fsyncPeriod = htonl(pCreate->fsyncPeriod);
- pCreate->partitions = htons(pCreate->partitions);
- pCreate->minRowsPerFileBlock = htonl(pCreate->minRowsPerFileBlock);
- pCreate->maxRowsPerFileBlock = htonl(pCreate->maxRowsPerFileBlock);
-
- int32_t code;
- if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
- code = TSDB_CODE_GRANT_EXPIRED;
- } else if (!pMsg->pUser->writeAuth) {
- code = TSDB_CODE_MND_NO_RIGHTS;
- } else {
- code = mnodeCreateDb(pMsg->pUser->pAcct, pCreate, pMsg);
- }
-
- return code;
-}
-
-static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SAlterDbMsg *pAlter) {
- SDbCfg newCfg = pDb->cfg;
- int32_t maxTables = htonl(pAlter->maxTables);
- int32_t cacheBlockSize = htonl(pAlter->cacheBlockSize);
- int32_t totalBlocks = htonl(pAlter->totalBlocks);
- int32_t daysPerFile = htonl(pAlter->daysPerFile);
- int32_t daysToKeep0 = htonl(pAlter->daysToKeep0);
- int32_t daysToKeep1 = htonl(pAlter->daysToKeep1);
- int32_t daysToKeep2 = htonl(pAlter->daysToKeep2);
- int32_t minRows = htonl(pAlter->minRowsPerFileBlock);
- int32_t maxRows = htonl(pAlter->maxRowsPerFileBlock);
- int32_t commitTime = htonl(pAlter->commitTime);
- int32_t fsyncPeriod = htonl(pAlter->fsyncPeriod);
- int8_t compression = pAlter->compression;
- int8_t walLevel = pAlter->walLevel;
- int8_t replications = pAlter->replications;
- int8_t quorum = pAlter->quorum;
- int8_t precision = pAlter->precision;
- int8_t update = pAlter->update;
- int8_t cacheLastRow = pAlter->cacheLastRow;
- int8_t dbType = pAlter->dbType;
- int16_t partitions = htons(pAlter->partitions);
-
- terrno = TSDB_CODE_SUCCESS;
-
- //UPGRATE FROM LOW VERSION, reorder it
- if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {
- int32_t t = pDb->cfg.daysToKeep0;
- newCfg.daysToKeep0 = pDb->cfg.daysToKeep1;
- newCfg.daysToKeep1 = pDb->cfg.daysToKeep2;
- newCfg.daysToKeep2 = t;
- }
-
- if (cacheBlockSize > 0 && cacheBlockSize != pDb->cfg.cacheBlockSize) {
- mError("db:%s, can't alter cache option", pDb->name);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (totalBlocks > 0 && totalBlocks != pDb->cfg.totalBlocks) {
- mInfo("db:%s, blocks:%d change to %d", pDb->name, pDb->cfg.totalBlocks, totalBlocks);
- newCfg.totalBlocks = totalBlocks;
- }
-
- if (maxTables > 0) {
- mInfo("db:%s, maxTables:%d change to %d", pDb->name, pDb->cfg.maxTables, maxTables);
- newCfg.maxTables = maxTables;
- if (newCfg.maxTables < pDb->cfg.maxTables) {
- mError("db:%s, tables:%d should larger than origin:%d", pDb->name, newCfg.maxTables, pDb->cfg.maxTables);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
- }
- }
-
- if (daysPerFile > 0 && daysPerFile != pDb->cfg.daysPerFile) {
- mError("db:%s, can't alter days option", pDb->name);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (daysToKeep0 > 0 && (daysToKeep0 != pDb->cfg.daysToKeep0 || newCfg.daysToKeep0 != pDb->cfg.daysToKeep0)) {
- mDebug("db:%s, daysToKeep:%d change to %d", pDb->name, pDb->cfg.daysToKeep0, daysToKeep0);
- newCfg.daysToKeep0 = daysToKeep0;
- }
-
- if (daysToKeep1 > 0 && (daysToKeep1 != pDb->cfg.daysToKeep1 || newCfg.daysToKeep1 != pDb->cfg.daysToKeep1)) {
- mDebug("db:%s, daysToKeep1:%d change to %d", pDb->name, pDb->cfg.daysToKeep1, daysToKeep1);
- newCfg.daysToKeep1 = daysToKeep1;
- }
-
- if (daysToKeep2 > 0 && (daysToKeep2 != pDb->cfg.daysToKeep2 || newCfg.daysToKeep2 != pDb->cfg.daysToKeep2)) {
- mDebug("db:%s, daysToKeep2:%d change to %d", pDb->name, pDb->cfg.daysToKeep2, daysToKeep2);
- newCfg.daysToKeep2 = daysToKeep2;
- }
-
- if (minRows > 0 && minRows != pDb->cfg.minRowsPerFileBlock) {
- mError("db:%s, can't alter minRows option", pDb->name);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (maxRows > 0 && maxRows != pDb->cfg.maxRowsPerFileBlock) {
- mError("db:%s, can't alter maxRows option", pDb->name);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (commitTime > 0 && commitTime != pDb->cfg.commitTime) {
- mError("db:%s, can't alter commitTime option", pDb->name);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (precision > 0 && precision != pDb->cfg.precision) {
- mError("db:%s, can't alter precision option", pDb->name);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (compression >= 0 && compression != pDb->cfg.compression) {
- mDebug("db:%s, compression:%d change to %d", pDb->name, pDb->cfg.compression, compression);
- newCfg.compression = compression;
- }
-
- if (walLevel > 0 && walLevel != pDb->cfg.walLevel) {
- mDebug("db:%s, walLevel:%d change to %d", pDb->name, pDb->cfg.walLevel, walLevel);
- newCfg.walLevel = walLevel;
- }
-
- if (fsyncPeriod >= 0 && fsyncPeriod != pDb->cfg.fsyncPeriod) {
- mDebug("db:%s, fsyncPeriod:%d change to %d", pDb->name, pDb->cfg.fsyncPeriod, fsyncPeriod);
- newCfg.fsyncPeriod = fsyncPeriod;
- }
-
- if (replications > 0 && replications != pDb->cfg.replications) {
- mDebug("db:%s, replications:%d change to %d", pDb->name, pDb->cfg.replications, replications);
- newCfg.replications = replications;
-
- if (pDb->cfg.walLevel < TSDB_MIN_WAL_LEVEL) {
- mError("db:%s, walLevel:%d must be greater than 0", pDb->name, pDb->cfg.walLevel);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
- }
-
- if (replications > mnodeGetDnodesNum()) {
- mError("db:%s, no enough dnode to change replica:%d", pDb->name, replications);
- terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
- }
-
- if (pDb->cfg.replications - replications >= 2) {
- mError("db:%s, replica number can't change from %d to %d", pDb->name, pDb->cfg.replications, replications);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
- }
- }
-
- if (quorum >= 0 && quorum != pDb->cfg.quorum) {
- mDebug("db:%s, quorum:%d change to %d", pDb->name, pDb->cfg.quorum, quorum);
- newCfg.quorum = quorum;
- }
-
- if (update >= 0 && update != pDb->cfg.update) {
-#if 0
- mDebug("db:%s, update:%d change to %d", pDb->name, pDb->cfg.update, update);
- newCfg.update = update;
-#else
- mError("db:%s, can't alter update option", pDb->name);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-#endif
- }
-
- if (cacheLastRow >= 0 && cacheLastRow != pDb->cfg.cacheLastRow) {
- mDebug("db:%s, cacheLastRow:%d change to %d", pDb->name, pDb->cfg.cacheLastRow, cacheLastRow);
- newCfg.cacheLastRow = cacheLastRow;
- }
-
- if (dbType >= 0 && dbType != pDb->cfg.dbType) {
- mDebug("db:%s, dbType:%d change to %d", pDb->name, pDb->cfg.dbType, dbType);
- newCfg.dbType = dbType;
- }
-
- if (partitions >= 0 && partitions != pDb->cfg.partitions) {
- mDebug("db:%s, partitions:%d change to %d", pDb->name, pDb->cfg.partitions, partitions);
- newCfg.partitions = partitions;
- }
-
-// community version can only change daysToKeep
-// but enterprise version can change all daysToKeep options
-#ifndef _STORAGE
- newCfg.daysToKeep1 = newCfg.daysToKeep0;
- newCfg.daysToKeep2 = newCfg.daysToKeep0;
-#endif
-
- return newCfg;
-}
-
-static int32_t mnodeAlterDbFp(SMnodeMsg *pMsg) {
- SDbObj *pDb = pMsg->pDb;
-
- void *pIter = NULL;
- SVgObj *pVgroup = NULL;
- pMsg->expected = 0;
- while (1) {
- pIter = mnodeGetNextVgroup(pIter, &pVgroup);
- if (pVgroup == NULL) break;
- if (pVgroup->pDb == pDb) {
- pMsg->expected += pVgroup->numOfVnodes;
- mnodeSendAlterVgroupMsg(pVgroup,pMsg);
- }
- mnodeDecVgroupRef(pVgroup);
- }
-
- mDebug("db:%s, all vgroups is altered", pDb->name);
- mLInfo("db:%s, is alterd by %s", pDb->name, mnodeGetUserFromMsg(pMsg));
-
- // in case there is no vnode for this db currently(no table in db,etc.)
- if (pMsg->expected == 0) {
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsDbSdb,
- .pObj = pDb,
- .pMsg = pMsg,
- };
-
- return sdbUpdateRow(&row);
- }
-
- //bnNotify();
-
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-int mnodeInsertAlterDbRow(SDbObj *pDb, void *pMsg) {
- SSdbRow desc = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsDbSdb,
- .pObj = pDb,
- .pMsg = pMsg,
- };
-
- return sdbUpdateRow(&desc);
-}
-
-static int32_t mnodeAlterDb(SDbObj *pDb, SAlterDbMsg *pAlter, void *pMsg) {
- mDebug("db:%s, type:%d do alter operation", pDb->name, pDb->cfg.dbType);
-
- SDbCfg newCfg = mnodeGetAlterDbOption(pDb, pAlter);
- if (terrno != TSDB_CODE_SUCCESS) {
- return terrno;
- }
-
- int32_t code = mnodeCheckDbCfg(&newCfg);
- if (code != TSDB_CODE_SUCCESS) {
- return code;
- }
-
- if (memcmp(&newCfg, &pDb->cfg, sizeof(SDbCfg)) != 0) {
- pDb->cfg = newCfg;
- pDb->dbCfgVersion++;
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsDbSdb,
- .pObj = pDb,
- .pMsg = pMsg,
- .fpReq = mnodeAlterDbFp
- };
-
- code = sdbUpdateRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("db:%s, failed to alter, reason:%s", pDb->name, tstrerror(code));
- }
-}
-
- return code;
-}
-
-int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg) {
- SAlterDbMsg *pAlter = pMsg->rpcMsg.pCont;
- mDebug("db:%s, alter db msg is received from thandle:%p, dbType:%d", pAlter->db, pMsg->rpcMsg.handle, pAlter->dbType);
-
- if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pAlter->db);
- if (pMsg->pDb == NULL) {
- mError("db:%s, failed to alter, invalid db", pAlter->db);
- return TSDB_CODE_MND_INVALID_DB;
- }
-
- if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pAlter->db, pMsg->pDb->status);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- return mnodeAlterDb(pMsg->pDb, pAlter, pMsg);
-}
-
-static int32_t mnodeDropDbCb(SMnodeMsg *pMsg, int32_t code) {
- SDbObj *pDb = pMsg->pDb;
- if (code != TSDB_CODE_SUCCESS) {
- mError("db:%s, failed to drop from sdb, reason:%s", pDb->name, tstrerror(code));
- } else {
- mLInfo("db:%s, is dropped by %s", pDb->name, mnodeGetUserFromMsg(pMsg));
- }
-
- return code;
-}
-
-static int32_t mnodeDropDb(SMnodeMsg *pMsg) {
- if (pMsg == NULL) return TSDB_CODE_MND_APP_ERROR;
-
- SDbObj *pDb = pMsg->pDb;
- mInfo("db:%s, drop db from sdb", pDb->name);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsDbSdb,
- .pObj = pDb,
- .pMsg = pMsg,
- .fpRsp = mnodeDropDbCb
- };
-
- int32_t code = sdbDeleteRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("db:%s, failed to drop, reason:%s", pDb->name, tstrerror(code));
- }
-
- return code;
-}
-
-static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg) {
- SDropDbMsg *pDrop = pMsg->rpcMsg.pCont;
- mDebug("db:%s, drop db msg is received from thandle:%p", pDrop->db, pMsg->rpcMsg.handle);
-
- if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pDrop->db);
- if (pMsg->pDb == NULL) {
- if (pDrop->ignoreNotExists) {
- mDebug("db:%s, db is not exist, treat as success", pDrop->db);
- return TSDB_CODE_SUCCESS;
- } else {
- mError("db:%s, failed to drop, invalid db", pDrop->db);
- return TSDB_CODE_MND_INVALID_DB;
- }
- }
-
-#if 0
- if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) {
- mError("db:%s, can't drop monitor database", pDrop->db);
- return TSDB_CODE_MND_MONITOR_DB_FORBIDDEN;
- }
-#endif
-
- int32_t code = mnodeSetDbDropping(pMsg->pDb);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("db:%s, failed to drop, reason:%s", pDrop->db, tstrerror(code));
- return code;
- }
-
- mnodeSendDropAllDbVgroupsMsg(pMsg->pDb);
-
- mDebug("db:%s, all vgroups is dropped", pMsg->pDb->name);
- return mnodeDropDb(pMsg);
-}
-
-static int32_t mnodeSyncDb(SDbObj *pDb, SMnodeMsg *pMsg) {
- void *pIter = NULL;
- SVgObj *pVgroup = NULL;
- while (1) {
- pIter = mnodeGetNextVgroup(pIter, &pVgroup);
- if (pVgroup == NULL) break;
- if (pVgroup->pDb == pDb) {
- mnodeSendSyncVgroupMsg(pVgroup);
- }
- mnodeDecVgroupRef(pVgroup);
- }
-
- mLInfo("db:%s, is synced by %s", pDb->name, mnodeGetUserFromMsg(pMsg));
-
- return TSDB_CODE_SUCCESS;
-}
-
-
-static int32_t mnodeCompact(SDbObj *pDb, SCompactMsg *pCompactMsg) {
- int32_t count = ntohs(pCompactMsg->numOfVgroup);
- int32_t *buf = malloc(sizeof(int32_t) * count);
- if (buf == NULL) {
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
- for (int32_t i = 0; i < count; i++) {
- buf[i] = ntohs(pCompactMsg->vgid[i]);
- }
-
- // copy from mnodeSyncDb, so ugly
- for (int32_t i = 0; i < count; i++) {
- SVgObj *pVgroup = NULL;
- void *pIter = NULL;
- bool valid = false;
- while (1) {
- pIter = mnodeGetNextVgroup(pIter, &pVgroup);
- if (pVgroup == NULL) break;
- if (pVgroup->pDb == pDb && pVgroup->vgId == buf[i]) {
- mnodeSendCompactVgroupMsg(pVgroup);
- mnodeDecVgroupRef(pVgroup);
- valid = true;
- break;
- }
- mnodeDecVgroupRef(pVgroup);
- }
- if (valid == false) {
- mLError("db:%s, cannot find valid vgId: %d", pDb->name, buf[i]);
- }
- }
- free(buf);
-
- mLInfo("db:%s, trigger compact", pDb->name);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeProcessSyncDbMsg(SMnodeMsg *pMsg) {
- SSyncDbMsg *pSyncDb = pMsg->rpcMsg.pCont;
- mDebug("db:%s, syncdb is received from thandle:%p, ignore:%d", pSyncDb->db, pMsg->rpcMsg.handle, pSyncDb->ignoreNotExists);
-
- if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pSyncDb->db);
- if (pMsg->pDb == NULL) {
- if (pSyncDb->ignoreNotExists) {
- mDebug("db:%s, db is not exist, treat as success", pSyncDb->db);
- return TSDB_CODE_SUCCESS;
- } else {
- mError("db:%s, failed to sync, invalid db", pSyncDb->db);
- return TSDB_CODE_MND_INVALID_DB;
- }
- }
-
- if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pSyncDb->db, pMsg->pDb->status);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- return mnodeSyncDb(pMsg->pDb, pMsg);
-}
-static int32_t mnodeProcessCompactMsg(SMnodeMsg *pMsg) {
- SCompactMsg *pCompact = pMsg->rpcMsg.pCont;
- mDebug("db:%s, compact is received from thandle:%p", pCompact->db, pMsg->rpcMsg.handle);
-
- if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pCompact->db);
- if (pMsg->pDb == NULL) return TSDB_CODE_MND_DB_NOT_SELECTED;
-
- if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping, ignore compact request", pCompact->db, pMsg->pDb->status);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- return mnodeCompact(pMsg->pDb, pCompact);
-}
-
-void mnodeDropAllDbs(SAcctObj *pAcct) {
- int32_t numOfDbs = 0;
- SDbObj *pDb = NULL;
- void * pIter = NULL;
-
- mInfo("acct:%s, all dbs will be dropped from sdb", pAcct->user);
-
- while (1) {
- pIter = mnodeGetNextDb(pIter, &pDb);
- if (pDb == NULL) break;
-
- if (pDb->pAcct == pAcct) {
- mInfo("db:%s, drop db from sdb for acct:%s is dropped", pDb->name, pAcct->user);
- SSdbRow row = {
- .type = SDB_OPER_LOCAL,
- .pTable = tsDbSdb,
- .pObj = pDb
- };
-
- sdbDeleteRow(&row);
- numOfDbs++;
- }
- mnodeDecDbRef(pDb);
- }
-
- mInfo("acct:%s, all dbs:%d is dropped from sdb", pAcct->user, numOfDbs);
-}
-
-int32_t mnodeCompactDbs() {
- void *pIter = NULL;
- SDbObj *pDb = NULL;
-
- mInfo("start to compact dbs table...");
-
- while (1) {
- pIter = mnodeGetNextDb(pIter, &pDb);
- if (pDb == NULL) break;
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsDbSdb,
- .pObj = pDb,
- .rowSize = sizeof(SDbObj),
- };
-
- mInfo("compact dbs %s", pDb->name);
-
- sdbInsertCompactRow(&row);
- }
-
- mInfo("end to compact dbs table...");
-
- return 0;
-}
diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c
deleted file mode 100644
index 7dd199cca4248e5467017e1b6247f3b534c45711..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeDnode.c
+++ /dev/null
@@ -1,1317 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "tgrant.h"
-#include "tglobal.h"
-#include "tconfig.h"
-#include "tutil.h"
-#include "tsocket.h"
-#include "tbn.h"
-#include "tsync.h"
-#include "tdataformat.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeDnode.h"
-#include "mnodeDb.h"
-#include "mnodeMnode.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeUser.h"
-#include "mnodeVgroup.h"
-#include "mnodeWrite.h"
-#include "mnodePeer.h"
-#include "mnodeCluster.h"
-
-int64_t tsAccessSquence = 0;
-int64_t tsDnodeRid = -1;
-static void * tsDnodeSdb = NULL;
-static int32_t tsDnodeUpdateSize = 0;
-extern void * tsMnodeSdb;
-extern void * tsVgroupSdb;
-
-static SDnodeEps*tsDnodeEps;
-static int32_t tsDnodeEpsSize;
-static pthread_mutex_t tsDnodeEpsMutex;
-
-static int32_t mnodeCreateDnode(char *ep, SMnodeMsg *pMsg);
-static int32_t mnodeProcessCreateDnodeMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessDropDnodeMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessCfgDnodeMsg(SMnodeMsg *pMsg);
-static void mnodeProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) ;
-static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg);
-static int32_t mnodeGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void mnodeUpdateDnodeEps();
-
-static char* offlineReason[] = {
- "",
- "status msg timeout",
- "status not received",
- "status reset by mnode",
- "version not match",
- "dnodeId not match",
- "clusterId not match",
- "numOfMnodes not match",
- "balance not match",
- "mnEqualVn not match",
- "offThreshold not match",
- "interval not match",
- "maxTabPerVn not match",
- "maxVgPerDb not match",
- "arbitrator not match",
- "timezone not match",
- "locale not match",
- "charset not match",
- "unknown",
-};
-
-static int32_t mnodeDnodeActionDestroy(SSdbRow *pRow) {
- tfree(pRow->pObj);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionInsert(SSdbRow *pRow) {
- SDnodeObj *pDnode = pRow->pObj;
- if (pDnode->status != TAOS_DN_STATUS_DROPPING) {
- pDnode->status = TAOS_DN_STATUS_OFFLINE;
- pDnode->lastAccess = tsAccessSquence;
- pDnode->offlineReason = TAOS_DN_OFF_STATUS_NOT_RECEIVED;
- }
-
- pDnode->customScore = 0;
-
- dnodeUpdateEp(pDnode->dnodeId, pDnode->dnodeEp, pDnode->dnodeFqdn, &pDnode->dnodePort);
- mnodeUpdateDnodeEps();
-
- mInfo("dnode:%d, fqdn:%s ep:%s port:%d is created", pDnode->dnodeId, pDnode->dnodeFqdn, pDnode->dnodeEp, pDnode->dnodePort);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionDelete(SSdbRow *pRow) {
- SDnodeObj *pDnode = pRow->pObj;
-
- mnodeDropMnodeLocal(pDnode->dnodeId);
- bnNotify();
- mnodeUpdateDnodeEps();
-
- mDebug("dnode:%d, all vgroups is dropped from sdb", pDnode->dnodeId);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionUpdate(SSdbRow *pRow) {
- SDnodeObj *pNew = pRow->pObj;
- SDnodeObj *pDnode = mnodeGetDnode(pNew->dnodeId);
- if (pDnode != NULL && pNew != pDnode) {
- memcpy(pDnode, pNew, pRow->rowSize);
- free(pNew);
- }
- mnodeDecDnodeRef(pDnode);
-
- mnodeUpdateDnodeEps();
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionEncode(SSdbRow *pRow) {
- SDnodeObj *pDnode = pRow->pObj;
- memcpy(pRow->rowData, pDnode, tsDnodeUpdateSize);
- pRow->rowSize = tsDnodeUpdateSize;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionDecode(SSdbRow *pRow) {
- SDnodeObj *pDnode = (SDnodeObj *) calloc(1, sizeof(SDnodeObj));
- if (pDnode == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
- memcpy(pDnode, pRow->rowData, tsDnodeUpdateSize);
- pRow->pObj = pDnode;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeDnodeActionRestored() {
- int64_t numOfRows = sdbGetNumOfRows(tsDnodeSdb);
- if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
- mInfo("dnode first deploy, create dnode:%s", tsLocalEp);
- mnodeCreateDnode(tsLocalEp, NULL);
- SDnodeObj *pDnode = mnodeGetDnodeByEp(tsLocalEp);
- if (pDnode != NULL) {
- mnodeCreateMnode(pDnode->dnodeId, pDnode->dnodeEp, false);
- mnodeDecDnodeRef(pDnode);
- }
- }
-
- mnodeUpdateDnodeEps();
- return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitDnodes() {
- SDnodeObj tObj;
- tsDnodeUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
- pthread_mutex_init(&tsDnodeEpsMutex, NULL);
-
- SSdbTableDesc desc = {
- .id = SDB_TABLE_DNODE,
- .name = "dnodes",
- .hashSessions = TSDB_DEFAULT_DNODES_HASH_SIZE,
- .maxRowSize = tsDnodeUpdateSize,
- .refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
- .keyType = SDB_KEY_AUTO,
- .fpInsert = mnodeDnodeActionInsert,
- .fpDelete = mnodeDnodeActionDelete,
- .fpUpdate = mnodeDnodeActionUpdate,
- .fpEncode = mnodeDnodeActionEncode,
- .fpDecode = mnodeDnodeActionDecode,
- .fpDestroy = mnodeDnodeActionDestroy,
- .fpRestored = mnodeDnodeActionRestored
- };
-
- tsDnodeRid = sdbOpenTable(&desc);
- tsDnodeSdb = sdbGetTableByRid(tsDnodeRid);
- if (tsDnodeSdb == NULL) {
- mError("failed to init dnodes data");
- return -1;
- }
-
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DNODE, mnodeProcessCreateDnodeMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_DNODE, mnodeProcessDropDnodeMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CONFIG_DNODE, mnodeProcessCfgDnodeMsg);
-
- mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP, mnodeProcessCfgDnodeMsgRsp);
- mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_STATUS, mnodeProcessDnodeStatusMsg);
-
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_MODULE, mnodeGetModuleMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_MODULE, mnodeRetrieveModules);
-
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VARIABLES, mnodeGetConfigMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VARIABLES, mnodeRetrieveConfigs);
-
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VNODES, mnodeGetVnodeMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VNODES, mnodeRetrieveVnodes);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_VNODES, mnodeCancelGetNextVgroup);
-
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DNODE, mnodeGetDnodeMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DNODE, mnodeRetrieveDnodes);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_DNODE, mnodeCancelGetNextDnode);
-
- mDebug("table:dnodes table is created");
- return 0;
-}
-
-void mnodeCleanupDnodes() {
- sdbCloseTable(tsDnodeRid);
- pthread_mutex_destroy(&tsDnodeEpsMutex);
- free(tsDnodeEps);
- tsDnodeEps = NULL;
- tsDnodeSdb = NULL;
-}
-
-void *mnodeGetNextDnode(void *pIter, SDnodeObj **pDnode) {
- return sdbFetchRow(tsDnodeSdb, pIter, (void **)pDnode);
-}
-
-void mnodeCancelGetNextDnode(void *pIter) {
- sdbFreeIter(tsDnodeSdb, pIter);
-}
-
-int32_t mnodeGetDnodesNum() {
- return (int32_t)sdbGetNumOfRows(tsDnodeSdb);
-}
-
-int32_t mnodeGetOnlinDnodesCpuCoreNum() {
- SDnodeObj *pDnode = NULL;
- void * pIter = NULL;
- int32_t cpuCores = 0;
-
- while (1) {
- pIter = mnodeGetNextDnode(pIter, &pDnode);
- if (pDnode == NULL) break;
- if (pDnode->status != TAOS_DN_STATUS_OFFLINE) {
- cpuCores += pDnode->numOfCores;
- }
- mnodeDecDnodeRef(pDnode);
- }
-
- if (cpuCores < 2) cpuCores = 2;
- return cpuCores;
-}
-
-int32_t mnodeGetOnlineDnodesNum() {
- SDnodeObj *pDnode = NULL;
- void * pIter = NULL;
- int32_t onlineDnodes = 0;
-
- while (1) {
- pIter = mnodeGetNextDnode(pIter, &pDnode);
- if (pDnode == NULL) break;
- if (pDnode->status != TAOS_DN_STATUS_OFFLINE) onlineDnodes++;
- mnodeDecDnodeRef(pDnode);
- }
-
- return onlineDnodes;
-}
-
-void mnodeGetOnlineAndTotalDnodesNum(int32_t *onlineNum, int32_t *totalNum) {
- SDnodeObj *pDnode = NULL;
- void * pIter = NULL;
- int32_t onlineDnodes = 0, totalDnodes = 0;
-
- while (1) {
- pIter = mnodeGetNextDnode(pIter, &pDnode);
- if (pDnode == NULL) break;
- if (pDnode->status != TAOS_DN_STATUS_OFFLINE) ++onlineDnodes;
- ++totalDnodes;
- mnodeDecDnodeRef(pDnode);
- }
-
- if (onlineNum) {
- *onlineNum = onlineDnodes;
- }
-
- if (totalNum) {
- *totalNum = totalDnodes;
- }
-}
-
-void *mnodeGetDnode(int32_t dnodeId) {
- return sdbGetRow(tsDnodeSdb, &dnodeId);
-}
-
-void *mnodeGetDnodeByEp(char *ep) {
- SDnodeObj *pDnode = NULL;
- void * pIter = NULL;
-
- while (1) {
- pIter = mnodeGetNextDnode(pIter, &pDnode);
- if (pDnode == NULL) break;
- if (strncasecmp(ep, pDnode->dnodeEp, TSDB_EP_LEN) == 0) {
- mnodeCancelGetNextDnode(pIter);
- return pDnode;
- }
- mnodeDecDnodeRef(pDnode);
- }
-
-
- return NULL;
-}
-
-void mnodeIncDnodeRef(SDnodeObj *pDnode) {
- sdbIncRef(tsDnodeSdb, pDnode);
-}
-
-void mnodeDecDnodeRef(SDnodeObj *pDnode) {
- sdbDecRef(tsDnodeSdb, pDnode);
-}
-
-void mnodeUpdateDnode(SDnodeObj *pDnode) {
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsDnodeSdb,
- .pObj = pDnode
- };
-
- int32_t code = sdbUpdateRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("dnode:%d, failed update", pDnode->dnodeId);
- }
-}
-
-static int32_t mnodeProcessCfgDnodeMsg(SMnodeMsg *pMsg) {
- if (strcmp(pMsg->pUser->user, TSDB_DEFAULT_USER) != 0) {
- mError("failed to cfg dnode, no rights");
- return TSDB_CODE_MND_NO_RIGHTS;
- }
-
- SCfgDnodeMsg *pCmCfgDnode = pMsg->rpcMsg.pCont;
- if (pCmCfgDnode->ep[0] == 0) {
- tstrncpy(pCmCfgDnode->ep, tsLocalEp, TSDB_EP_LEN);
- }
-
- SDnodeObj *pDnode = mnodeGetDnodeByEp(pCmCfgDnode->ep);
- if (pDnode == NULL) {
- int32_t dnodeId = strtol(pCmCfgDnode->ep, NULL, 10);
- if (dnodeId <= 0 || dnodeId > 65536) {
- mError("failed to cfg dnode, invalid dnodeEp:%s", pCmCfgDnode->ep);
- return TSDB_CODE_MND_DNODE_NOT_EXIST;
- }
-
- pDnode = mnodeGetDnode(dnodeId);
- if (pDnode == NULL) {
- mError("failed to cfg dnode, invalid dnodeId:%d", dnodeId);
- return TSDB_CODE_MND_DNODE_NOT_EXIST;
- }
- }
-
- SRpcEpSet epSet = mnodeGetEpSetFromIp(pDnode->dnodeEp);
-
- if (strncasecmp(pCmCfgDnode->config, "balance", 7) == 0) {
- int32_t vnodeId = 0;
- int32_t dnodeId = 0;
- bool parseOk = taosCheckBalanceCfgOptions(pCmCfgDnode->config + 8, &vnodeId, &dnodeId);
- if (!parseOk) {
- mnodeDecDnodeRef(pDnode);
- return TSDB_CODE_MND_INVALID_DNODE_CFG_OPTION;
- }
-
- int32_t code = bnAlterDnode(pDnode, vnodeId, dnodeId);
- mnodeDecDnodeRef(pDnode);
- return code;
- } else {
- SCfgDnodeMsg *pMdCfgDnode = rpcMallocCont(sizeof(SCfgDnodeMsg));
- strcpy(pMdCfgDnode->ep, pCmCfgDnode->ep);
- strcpy(pMdCfgDnode->config, pCmCfgDnode->config);
-
- SRpcMsg rpcMdCfgDnodeMsg = {
- .ahandle = 0,
- .code = 0,
- .msgType = TSDB_MSG_TYPE_MD_CONFIG_DNODE,
- .pCont = pMdCfgDnode,
- .contLen = sizeof(SCfgDnodeMsg)
- };
-
- mInfo("dnode:%s, is configured by %s", pCmCfgDnode->ep, pMsg->pUser->user);
- dnodeSendMsgToDnode(&epSet, &rpcMdCfgDnodeMsg);
- mnodeDecDnodeRef(pDnode);
- return TSDB_CODE_SUCCESS;
- }
-}
-
-static void mnodeProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) {
- mInfo("cfg dnode rsp is received");
-}
-
-static int32_t mnodeCheckClusterCfgPara(const SClusterCfg *clusterCfg) {
- if (clusterCfg->numOfMnodes != htonl(tsNumOfMnodes)) {
- mError("\"numOfMnodes\"[%d - %d] cfg parameters inconsistent", clusterCfg->numOfMnodes, htonl(tsNumOfMnodes));
- return TAOS_DN_OFF_NUM_OF_MNODES_NOT_MATCH;
- }
- if (clusterCfg->mnodeEqualVnodeNum != htonl(tsMnodeEqualVnodeNum)) {
- mError("\"mnodeEqualVnodeNum\"[%d - %d] cfg parameters inconsistent", clusterCfg->mnodeEqualVnodeNum,
- htonl(tsMnodeEqualVnodeNum));
- return TAOS_DN_OFF_MN_EQUAL_VN_NOT_MATCH;
- }
- if (clusterCfg->offlineThreshold != htonl(tsOfflineThreshold)) {
- mError("\"offlineThreshold\"[%d - %d] cfg parameters inconsistent", clusterCfg->offlineThreshold,
- htonl(tsOfflineThreshold));
- return TAOS_DN_OFF_OFFLINE_THRESHOLD_NOT_MATCH;
- }
- if (clusterCfg->statusInterval != htonl(tsStatusInterval)) {
- mError("\"statusInterval\"[%d - %d] cfg parameters inconsistent", clusterCfg->statusInterval,
- htonl(tsStatusInterval));
- return TAOS_DN_OFF_STATUS_INTERVAL_NOT_MATCH;
- }
- if (clusterCfg->maxtablesPerVnode != htonl(tsMaxTablePerVnode)) {
- mError("\"maxTablesPerVnode\"[%d - %d] cfg parameters inconsistent", clusterCfg->maxtablesPerVnode,
- htonl(tsMaxTablePerVnode));
- return TAOS_DN_OFF_MAX_TAB_PER_VN_NOT_MATCH;
- }
- if (clusterCfg->maxVgroupsPerDb != htonl(tsMaxVgroupsPerDb)) {
- mError("\"maxVgroupsPerDb\"[%d - %d] cfg parameters inconsistent", clusterCfg->maxVgroupsPerDb,
- htonl(tsMaxVgroupsPerDb));
- return TAOS_DN_OFF_MAX_VG_PER_DB_NOT_MATCH;
- }
- if (0 != strncasecmp(clusterCfg->arbitrator, tsArbitrator, strlen(tsArbitrator))) {
- mError("\"arbitrator\"[%s - %s] cfg parameters inconsistent", clusterCfg->arbitrator, tsArbitrator);
- return TAOS_DN_OFF_ARBITRATOR_NOT_MATCH;
- }
-
- int64_t checkTime = 0;
- char timestr[32] = "1970-01-01 00:00:00.00";
- (void)taosParseTime(timestr, &checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
- if ((0 != strncasecmp(clusterCfg->timezone, tsTimezone, strlen(tsTimezone))) &&
- (checkTime != clusterCfg->checkTime)) {
- mError("\"timezone\"[%s - %s] [%" PRId64 " - %" PRId64 "] cfg parameters inconsistent", clusterCfg->timezone,
- tsTimezone, clusterCfg->checkTime, checkTime);
- return TAOS_DN_OFF_TIME_ZONE_NOT_MATCH;
- }
-
- // if (0 != strncasecmp(clusterCfg->locale, tsLocale, strlen(tsLocale))) {
- // mError("\"locale\"[%s - %s] cfg parameters inconsistent", clusterCfg->locale, tsLocale);
- // return TAOS_DN_OFF_LOCALE_NOT_MATCH;
- // }
- // if (0 != strncasecmp(clusterCfg->charset, tsCharset, strlen(tsCharset))) {
- // mError("\"charset\"[%s - %s] cfg parameters inconsistent.", clusterCfg->charset, tsCharset);
- // return TAOS_DN_OFF_CHARSET_NOT_MATCH;
- // }
-
- if (clusterCfg->enableBalance != tsEnableBalance) {
- mError("\"balance\"[%d - %d] cfg parameters inconsistent", clusterCfg->enableBalance, tsEnableBalance);
- return TAOS_DN_OFF_ENABLE_BALANCE_NOT_MATCH;
- }
- if (clusterCfg->flowCtrl != tsEnableFlowCtrl) {
- mError("\"flowCtrl\"[%d - %d] cfg parameters inconsistent", clusterCfg->flowCtrl, tsEnableFlowCtrl);
- return TAOS_DN_OFF_FLOW_CTRL_NOT_MATCH;
- }
- if (clusterCfg->slaveQuery != tsEnableSlaveQuery) {
- mError("\"slaveQuery\"[%d - %d] cfg parameters inconsistent", clusterCfg->slaveQuery, tsEnableSlaveQuery);
- return TAOS_DN_OFF_SLAVE_QUERY_NOT_MATCH;
- }
- if (clusterCfg->adjustMaster != tsEnableAdjustMaster) {
- mError("\"adjustMaster\"[%d - %d] cfg parameters inconsistent", clusterCfg->adjustMaster, tsEnableAdjustMaster);
- return TAOS_DN_OFF_ADJUST_MASTER_NOT_MATCH;
- }
-
- return 0;
-}
-
-static int32_t mnodeGetDnodeEpsSize() {
- pthread_mutex_lock(&tsDnodeEpsMutex);
- int32_t size = tsDnodeEpsSize;
- pthread_mutex_unlock(&tsDnodeEpsMutex);
- return size;
-}
-
-static void mnodeGetDnodeEpsData(SDnodeEps *pEps, int32_t epsSize) {
- pthread_mutex_lock(&tsDnodeEpsMutex);
- if (epsSize == tsDnodeEpsSize) {
- memcpy(pEps, tsDnodeEps, tsDnodeEpsSize);
- }
- pthread_mutex_unlock(&tsDnodeEpsMutex);
-}
-
-static void mnodeUpdateDnodeEps() {
- pthread_mutex_lock(&tsDnodeEpsMutex);
-
- int32_t totalDnodes = mnodeGetDnodesNum();
- tsDnodeEpsSize = sizeof(SDnodeEps) + totalDnodes * sizeof(SDnodeEp);
- free(tsDnodeEps);
- tsDnodeEps = calloc(1, tsDnodeEpsSize);
- tsDnodeEps->dnodeNum = htonl(totalDnodes);
-
- SDnodeObj *pDnode = NULL;
- void * pIter = NULL;
- int32_t dnodesNum = 0;
-
- while (1) {
- pIter = mnodeGetNextDnode(pIter, &pDnode);
- if (pDnode == NULL) break;
- if (dnodesNum >= totalDnodes) {
- mnodeCancelGetNextDnode(pIter);
- break;
- }
-
- SDnodeEp *pEp = &tsDnodeEps->dnodeEps[dnodesNum];
- dnodesNum++;
- pEp->dnodeId = htonl(pDnode->dnodeId);
- pEp->dnodePort = htons(pDnode->dnodePort);
- tstrncpy(pEp->dnodeFqdn, pDnode->dnodeFqdn, TSDB_FQDN_LEN);
- mnodeDecDnodeRef(pDnode);
- }
-
- pthread_mutex_unlock(&tsDnodeEpsMutex);
-}
-
-static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg) {
- SDnodeObj *pDnode = NULL;
- SStatusMsg *pStatus = pMsg->rpcMsg.pCont;
- pStatus->dnodeId = htonl(pStatus->dnodeId);
- pStatus->moduleStatus = htonl(pStatus->moduleStatus);
- pStatus->lastReboot = htonl(pStatus->lastReboot);
- pStatus->numOfCores = htons(pStatus->numOfCores);
-
- uint32_t _version = htonl(pStatus->version);
- if (_version != tsVersion) {
- pDnode = mnodeGetDnodeByEp(pStatus->dnodeEp);
- if (pDnode != NULL && pDnode->status != TAOS_DN_STATUS_READY) {
- pDnode->offlineReason = TAOS_DN_OFF_VERSION_NOT_MATCH;
- }
- mError("dnode:%d, status msg version:%d not equal with cluster:%d", pStatus->dnodeId, _version, tsVersion);
- return TSDB_CODE_MND_INVALID_MSG_VERSION;
- }
-
- if (pStatus->dnodeId == 0) {
- pDnode = mnodeGetDnodeByEp(pStatus->dnodeEp);
- if (pDnode == NULL) {
- mDebug("dnode %s not created", pStatus->dnodeEp);
- return TSDB_CODE_MND_DNODE_NOT_EXIST;
- }
- } else {
- pDnode = mnodeGetDnode(pStatus->dnodeId);
- if (pDnode == NULL) {
- pDnode = mnodeGetDnodeByEp(pStatus->dnodeEp);
- if (pDnode != NULL && pDnode->status != TAOS_DN_STATUS_READY) {
- pDnode->offlineReason = TAOS_DN_OFF_DNODE_ID_NOT_MATCH;
- }
- mError("dnode:%d, %s not exist", pStatus->dnodeId, pStatus->dnodeEp);
- return TSDB_CODE_MND_DNODE_NOT_EXIST;
- }
- }
-
- pDnode->lastReboot = pStatus->lastReboot;
- pDnode->numOfCores = pStatus->numOfCores;
- pDnode->diskAvailable = pStatus->diskAvailable;
- pDnode->alternativeRole = pStatus->alternativeRole;
- pDnode->moduleStatus = pStatus->moduleStatus;
-
- if (pStatus->dnodeId == 0) {
- mDebug("dnode:%d %s, first access, set clusterId %s", pDnode->dnodeId, pDnode->dnodeEp, mnodeGetClusterId());
- } else {
- if (strncmp(pStatus->clusterId, mnodeGetClusterId(), TSDB_CLUSTER_ID_LEN - 1) != 0) {
- if (pDnode != NULL && pDnode->status != TAOS_DN_STATUS_READY) {
- pDnode->offlineReason = TAOS_DN_OFF_CLUSTER_ID_NOT_MATCH;
- }
- mError("dnode:%d, input clusterId %s not match with exist %s", pDnode->dnodeId, pStatus->clusterId,
- mnodeGetClusterId());
- return TSDB_CODE_MND_INVALID_CLUSTER_ID;
- } else {
- mTrace("dnode:%d, status received, access times %" PRId64 " openVnodes:%d:%d", pDnode->dnodeId, pDnode->lastAccess,
- htons(pStatus->openVnodes), pDnode->openVnodes);
- }
- }
-
- int32_t openVnodes = htons(pStatus->openVnodes);
- int32_t epsSize = mnodeGetDnodeEpsSize();
- int32_t vgAccessSize = openVnodes * sizeof(SVgroupAccess);
- int32_t contLen = sizeof(SStatusRsp) + vgAccessSize + epsSize;
-
- SStatusRsp *pRsp = rpcMallocCont(contLen);
- if (pRsp == NULL) {
- mnodeDecDnodeRef(pDnode);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- pRsp->dnodeCfg.dnodeId = htonl(pDnode->dnodeId);
- pRsp->dnodeCfg.moduleStatus = htonl((int32_t)pDnode->isMgmt);
- pRsp->dnodeCfg.numOfVnodes = htonl(openVnodes);
- tstrncpy(pRsp->dnodeCfg.clusterId, mnodeGetClusterId(), TSDB_CLUSTER_ID_LEN);
- SVgroupAccess *pAccess = (SVgroupAccess *)((char *)pRsp + sizeof(SStatusRsp));
-
- for (int32_t j = 0; j < openVnodes; ++j) {
- SVnodeLoad *pVload = &pStatus->load[j];
- pVload->vgId = htonl(pVload->vgId);
- pVload->dbCfgVersion = htonl(pVload->dbCfgVersion);
- pVload->vgCfgVersion = htonl(pVload->vgCfgVersion);
- pVload->vnodeVersion = htobe64(pVload->vnodeVersion);
-
- SVgObj *pVgroup = mnodeGetVgroup(pVload->vgId);
- if (pVgroup == NULL) {
- SRpcEpSet epSet = mnodeGetEpSetFromIp(pDnode->dnodeEp);
- mInfo("dnode:%d, vgId:%d not exist in mnode, drop it", pDnode->dnodeId, pVload->vgId);
- mnodeSendDropVnodeMsg(pVload->vgId, &epSet, NULL);
- } else {
- mnodeUpdateVgroupStatus(pVgroup, pDnode, pVload);
- pAccess->vgId = htonl(pVload->vgId);
- pAccess->accessState = pVgroup->accessState;
- pAccess++;
- mnodeDecVgroupRef(pVgroup);
- }
- }
-
- if (pDnode->status == TAOS_DN_STATUS_OFFLINE) {
- // Verify whether the cluster parameters are consistent when status change from offline to ready
- int32_t ret = mnodeCheckClusterCfgPara(&(pStatus->clusterCfg));
- if (0 != ret) {
- pDnode->offlineReason = ret;
- mnodeDecDnodeRef(pDnode);
- rpcFreeCont(pRsp);
- mError("dnode:%d, %s cluster cfg parameters inconsistent, reason:%s", pDnode->dnodeId, pStatus->dnodeEp,
- offlineReason[ret]);
- return TSDB_CODE_MND_CLUSTER_CFG_INCONSISTENT;
- }
-
- mInfo("dnode:%d, from offline to online", pDnode->dnodeId);
- pDnode->status = TAOS_DN_STATUS_READY;
- pDnode->offlineReason = TAOS_DN_OFF_ONLINE;
- bnCheckModules();
- bnNotify();
- }
-
- int32_t numOfMnodes = mnodeGetMnodesNum();
- if (numOfMnodes < tsNumOfMnodes && numOfMnodes < mnodeGetOnlineDnodesNum()
- && bnDnodeCanCreateMnode(pDnode)) {
- bnNotify();
- }
-
- if (openVnodes != pDnode->openVnodes) {
- mnodeCheckUnCreatedVgroup(pDnode, pStatus->load, openVnodes);
- }
-
- pDnode->lastAccess = tsAccessSquence;
-
- //this func should be called after sdb replica changed
- mnodeGetMnodeInfos(&pRsp->mnodes);
-
- mnodeDecDnodeRef(pDnode);
-
- SDnodeEps *pEps = (SDnodeEps *)((char *)pRsp + sizeof(SStatusRsp) + vgAccessSize);
- mnodeGetDnodeEpsData(pEps, epsSize);
-
- pMsg->rpcRsp.len = contLen;
- pMsg->rpcRsp.rsp = pRsp;
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeCreateDnode(char *ep, SMnodeMsg *pMsg) {
- int32_t grantCode = grantCheck(TSDB_GRANT_DNODE);
- if (grantCode != TSDB_CODE_SUCCESS) {
- return grantCode;
- }
-
- char dnodeEp[TSDB_EP_LEN] = {0};
- tstrncpy(dnodeEp, ep, TSDB_EP_LEN);
- strtrim(dnodeEp);
-
- char *temp = strchr(dnodeEp, ':');
- if (!temp) {
- int32_t len = (int32_t)strlen(dnodeEp);
- if (dnodeEp[len - 1] == ';') dnodeEp[len - 1] = 0;
- len = (int32_t)strlen(dnodeEp);
- snprintf(dnodeEp + len, TSDB_EP_LEN - len, ":%d", tsServerPort);
- }
- ep = dnodeEp;
-
- SDnodeObj *pDnode = mnodeGetDnodeByEp(ep);
- if (pDnode != NULL) {
- mnodeDecDnodeRef(pDnode);
- mError("dnode:%d, already exist, %s:%d", pDnode->dnodeId, pDnode->dnodeFqdn, pDnode->dnodePort);
- return TSDB_CODE_MND_DNODE_ALREADY_EXIST;
- }
-
- pDnode = (SDnodeObj *) calloc(1, sizeof(SDnodeObj));
- pDnode->createdTime = taosGetTimestampMs();
- pDnode->status = TAOS_DN_STATUS_OFFLINE;
- pDnode->offlineReason = TAOS_DN_OFF_STATUS_NOT_RECEIVED;
- tstrncpy(pDnode->dnodeEp, ep, TSDB_EP_LEN);
- taosGetFqdnPortFromEp(ep, pDnode->dnodeFqdn, &pDnode->dnodePort);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsDnodeSdb,
- .pObj = pDnode,
- .rowSize = sizeof(SDnodeObj),
- .pMsg = pMsg
- };
-
- int32_t code = sdbInsertRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- int dnodeId = pDnode->dnodeId;
- tfree(pDnode);
- mError("failed to create dnode:%d, reason:%s", dnodeId, tstrerror(code));
- } else {
- mLInfo("dnode:%d is created", pDnode->dnodeId);
- }
-
- return code;
-}
-
-int32_t mnodeDropDnode(SDnodeObj *pDnode, void *pMsg) {
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsDnodeSdb,
- .pObj = pDnode,
- .pMsg = pMsg
- };
-
- int32_t code = sdbDeleteRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("dnode:%d, failed to drop from cluster, result:%s", pDnode->dnodeId, tstrerror(code));
- } else {
- mLInfo("dnode:%d, is dropped from cluster", pDnode->dnodeId);
- }
-
- return code;
-}
-
-static int32_t mnodeDropDnodeByEp(char *ep, SMnodeMsg *pMsg) {
- SDnodeObj *pDnode = mnodeGetDnodeByEp(ep);
- if (pDnode == NULL) {
- if (strspn(ep, "0123456789 ;") != strlen(ep)) {
- return TSDB_CODE_MND_DNODE_NOT_EXIST;
- }
-
- int32_t dnodeId = (int32_t)strtol(ep, NULL, 10);
- pDnode = mnodeGetDnode(dnodeId);
- if (pDnode == NULL) {
- mError("dnode:%s, is not exist", ep);
- return TSDB_CODE_MND_DNODE_NOT_EXIST;
- }
- }
-
- if (strcmp(pDnode->dnodeEp, mnodeGetMnodeMasterEp()) == 0) {
- mError("dnode:%d, can't drop dnode:%s which is master", pDnode->dnodeId, ep);
- mnodeDecDnodeRef(pDnode);
- return TSDB_CODE_MND_NO_REMOVE_MASTER;
- }
-
- int32_t maxReplica = mnodeGetDbMaxReplica();
- int32_t dnodesNum = mnodeGetDnodesNum();
- if (dnodesNum <= maxReplica) {
- mError("dnode:%d, can't drop dnode:%s, #dnodes: %d, replia: %d", pDnode->dnodeId, ep, dnodesNum, maxReplica);
- mnodeDecDnodeRef(pDnode);
- return TSDB_CODE_MND_NO_ENOUGH_DNODES;
- }
-
- mInfo("dnode:%d, start to drop it", pDnode->dnodeId);
-
- int32_t code = bnDropDnode(pDnode);
- mnodeDecDnodeRef(pDnode);
- return code;
-}
-
-static int32_t mnodeProcessCreateDnodeMsg(SMnodeMsg *pMsg) {
- SCreateDnodeMsg *pCreate = pMsg->rpcMsg.pCont;
-
- if (strcmp(pMsg->pUser->user, TSDB_DEFAULT_USER) != 0) {
- return TSDB_CODE_MND_NO_RIGHTS;
- } else {
- return mnodeCreateDnode(pCreate->ep, pMsg);
- }
-}
-
-static int32_t mnodeProcessDropDnodeMsg(SMnodeMsg *pMsg) {
- SDropDnodeMsg *pDrop = pMsg->rpcMsg.pCont;
-
- if (strcmp(pMsg->pUser->user, TSDB_DEFAULT_USER) != 0) {
- return TSDB_CODE_MND_NO_RIGHTS;
- } else {
- return mnodeDropDnodeByEp(pDrop->ep, pMsg);
- }
-}
-
-static int32_t mnodeGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) return 0;
-
- if (strcmp(pUser->pAcct->user, TSDB_DEFAULT_USER) != 0) {
- mnodeDecUserRef(pUser);
- return TSDB_CODE_MND_NO_RIGHTS;
- }
-
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "id");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_EP_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "end_point");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "vnodes");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "cores");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 10 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "status");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 5 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "role");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "create_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 24 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "offline reason");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = mnodeGetDnodesNum();
- if (tsArbitrator[0] != 0) {
- pShow->numOfRows++;
- }
-
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
- pShow->pIter = NULL;
-
- mnodeDecUserRef(pUser);
-
- return 0;
-}
-
-static int32_t mnodeRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- int32_t cols = 0;
- SDnodeObj *pDnode = NULL;
- char *pWrite;
-
- while (numOfRows < rows) {
- pShow->pIter = mnodeGetNextDnode(pShow->pIter, &pDnode);
- if (pDnode == NULL) break;
-
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = pDnode->dnodeId;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDnode->dnodeEp, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = pDnode->openVnodes;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = pDnode->numOfCores;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- char* status = dnodeStatus[pDnode->status];
- STR_TO_VARSTR(pWrite, status);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- char* role = dnodeRoles[pDnode->alternativeRole];
- STR_TO_VARSTR(pWrite, role);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = pDnode->createdTime;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_TO_VARSTR(pWrite, offlineReason[pDnode->offlineReason]);
- cols++;
-
- numOfRows++;
- mnodeDecDnodeRef(pDnode);
- }
-
- if (tsArbitrator[0] != 0) {
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = 0;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, tsArbitrator, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = 0;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = 0;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- char *status = dnodeStatus[tsArbOnline > 0 ? TAOS_DN_STATUS_READY : TAOS_DN_STATUS_OFFLINE];
- STR_TO_VARSTR(pWrite, status);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_TO_VARSTR(pWrite, "arb");
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = tsArbOnlineTimestamp;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_TO_VARSTR(pWrite, "-");
- cols++;
-
- numOfRows++;
- }
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- pShow->numOfReads += numOfRows;
- return numOfRows;
-}
-
-static bool mnodeCheckModuleInDnode(SDnodeObj *pDnode, int32_t moduleType) {
- uint32_t status = pDnode->moduleStatus & (1u << moduleType);
- return status > 0;
-}
-
-static int32_t mnodeGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- int32_t cols = 0;
-
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) return 0;
-
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) {
- mnodeDecUserRef(pUser);
- return TSDB_CODE_MND_NO_RIGHTS;
- }
-
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "id");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 40 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "end_point");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "module");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "status");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = mnodeGetDnodesNum() * TSDB_MOD_MAX;
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
- pShow->pIter = NULL;
- mnodeDecUserRef(pUser);
-
- return 0;
-}
-
-int32_t mnodeRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
-
- char* pWrite;
- char* moduleName[5] = { "MNODE", "HTTP", "MONITOR", "MQTT", "UNKNOWN" };
- int32_t cols;
-
- while (numOfRows < rows) {
- SDnodeObj *pDnode = NULL;
- pShow->pIter = mnodeGetNextDnode(pShow->pIter, (SDnodeObj **)&pDnode);
- if (pDnode == NULL) break;
-
- for (int32_t moduleType = 0; moduleType < TSDB_MOD_MAX; ++moduleType) {
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = pDnode->dnodeId;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDnode->dnodeEp, pShow->bytes[cols] - 1);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, moduleName[moduleType], pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- bool enable = mnodeCheckModuleInDnode(pDnode, moduleType);
-
- char* v = enable? "enable":"disable";
- STR_TO_VARSTR(pWrite, v);
- cols++;
-
- numOfRows++;
- }
-
- mnodeDecDnodeRef(pDnode);
- }
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- pShow->numOfReads += numOfRows;
- return numOfRows;
-}
-
-static bool mnodeCheckConfigShow(SGlobalCfg *cfg) {
- if (!(cfg->cfgType & TSDB_CFG_CTYPE_B_SHOW))
- return false;
- return true;
-}
-
-static int32_t mnodeGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- int32_t cols = 0;
-
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) return 0;
-
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) {
- mnodeDecUserRef(pUser);
- return TSDB_CODE_MND_NO_RIGHTS;
- }
-
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = TSDB_CFG_OPTION_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- tstrncpy(pSchema[cols].name, "name", sizeof(pSchema[cols].name));
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_CFG_VALUE_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- tstrncpy(pSchema[cols].name, "value", sizeof(pSchema[cols].name));
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
-
- pShow->numOfRows = 0;
- for (int32_t i = tsGlobalConfigNum - 1; i >= 0; --i) {
- SGlobalCfg *cfg = tsGlobalConfig + i;
- if (!mnodeCheckConfigShow(cfg)) continue;
- pShow->numOfRows++;
- }
-
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
- pShow->pIter = NULL;
- mnodeDecUserRef(pUser);
-
- return 0;
-}
-
-static int32_t mnodeRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
-
- for (int32_t i = tsGlobalConfigNum - 1; i >= 0 && numOfRows < rows; --i) {
- SGlobalCfg *cfg = tsGlobalConfig + i;
- if (!mnodeCheckConfigShow(cfg)) continue;
-
- char *pWrite;
- int32_t cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, cfg->option, TSDB_CFG_OPTION_LEN);
-
- cols++;
- int32_t t = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- switch (cfg->valType) {
- case TAOS_CFG_VTYPE_INT8:
- t = snprintf(varDataVal(pWrite), TSDB_CFG_VALUE_LEN, "%d", *((int8_t *)cfg->ptr));
- varDataSetLen(pWrite, t);
- numOfRows++;
- break;
- case TAOS_CFG_VTYPE_INT16:
- t = snprintf(varDataVal(pWrite), TSDB_CFG_VALUE_LEN, "%d", *((int16_t *)cfg->ptr));
- varDataSetLen(pWrite, t);
- numOfRows++;
- break;
- case TAOS_CFG_VTYPE_INT32:
- t = snprintf(varDataVal(pWrite), TSDB_CFG_VALUE_LEN, "%d", *((int32_t *)cfg->ptr));
- varDataSetLen(pWrite, t);
- numOfRows++;
- break;
- case TAOS_CFG_VTYPE_FLOAT:
- case TAOS_CFG_VTYPE_DOUBLE:
- t = snprintf(varDataVal(pWrite), TSDB_CFG_VALUE_LEN, "%f", *((float *)cfg->ptr));
- varDataSetLen(pWrite, t);
- numOfRows++;
- break;
- case TAOS_CFG_VTYPE_STRING:
- case TAOS_CFG_VTYPE_IPSTR:
- case TAOS_CFG_VTYPE_DIRECTORY:
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, cfg->ptr, TSDB_CFG_VALUE_LEN);
- numOfRows++;
- break;
- default:
- break;
- }
- }
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- pShow->numOfReads += numOfRows;
- return numOfRows;
-}
-
-static int32_t mnodeGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- int32_t cols = 0;
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) return 0;
-
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) {
- mnodeDecUserRef(pUser);
- return TSDB_CODE_MND_NO_RIGHTS;
- }
-
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "vgId");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 12 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "status");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
-
- SDnodeObj *pDnode = NULL;
- if (pShow->payloadLen > 0 ) {
- char ep[TSDB_EP_LEN] = {0};
- // not use tstrncpy to make runtime happy
- uint16_t len = (pShow->payloadLen + 1) > TSDB_EP_LEN ? TSDB_EP_LEN :(pShow->payloadLen + 1);
- strncpy(ep, pShow->payload, len - 1);
-
- pDnode = mnodeGetDnodeByEp(ep);
- } else {
- void *pIter = mnodeGetNextDnode(NULL, (SDnodeObj **)&pDnode);
- mnodeCancelGetNextDnode(pIter);
- }
-
- if (pDnode != NULL) {
- pShow->numOfRows += pDnode->openVnodes;
- mnodeDecDnodeRef(pDnode);
- }
-
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
- pShow->pIter = pDnode;
- mnodeDecUserRef(pUser);
-
- return 0;
-}
-
-static int32_t mnodeRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- SDnodeObj *pDnode = NULL;
- char * pWrite;
- int32_t cols = 0;
-
- if (0 == rows) return 0;
-
- pDnode = (SDnodeObj *)(pShow->pIter);
- if (pDnode != NULL) {
- SVgObj *pVgroup;
- while (1) {
- pShow->pVgIter = mnodeGetNextVgroup(pShow->pVgIter, &pVgroup);
- if (pVgroup == NULL) break;
-
- for (int32_t i = 0; i < pVgroup->numOfVnodes && numOfRows < rows; ++i) {
- SVnodeGid *pVgid = &pVgroup->vnodeGid[i];
- if (pVgid->pDnode == pDnode) {
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(uint32_t *)pWrite = pVgroup->vgId;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_TO_VARSTR(pWrite, syncRole[pVgid->role]);
- cols++;
- numOfRows++;
-
- }
- }
- if (numOfRows >= rows) {
- break;
- }
-
- mnodeDecVgroupRef(pVgroup);
- }
- } else {
- numOfRows = 0;
- }
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- pShow->numOfReads += numOfRows;
- return numOfRows;
-}
-
-char* dnodeStatus[] = {
- "offline",
- "dropping",
- "balancing",
- "ready",
- "undefined"
-};
-
-char* dnodeRoles[] = {
- "any",
- "mnode",
- "vnode",
- "any"
-};
-
-int32_t mnodeCompactDnodes() {
- SDnodeObj *pDnode = NULL;
- void * pIter = NULL;
-
- mInfo("start to compact dnodes table...");
-
- while (1) {
- pIter = mnodeGetNextDnode(pIter, &pDnode);
- if (pDnode == NULL) break;
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsDnodeSdb,
- .pObj = pDnode,
- .rowSize = sizeof(SDnodeObj),
- };
-
- mInfo("compact dnode %d", pDnode->dnodeId);
-
- sdbInsertCompactRow(&row);
- }
-
- mInfo("end to compact dnodes table...");
-
- return 0;
-}
diff --git a/src/mnode/src/mnodeFunc.c b/src/mnode/src/mnodeFunc.c
deleted file mode 100644
index 253958efbe9a0d81d0542217447eaf750e10caf9..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeFunc.c
+++ /dev/null
@@ -1,485 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "trpc.h"
-#include "tutil.h"
-#include "tglobal.h"
-#include "tgrant.h"
-#include "tdataformat.h"
-#include "tkey.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeUser.h"
-#include "mnodeMnode.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeFunc.h"
-#include "mnodeWrite.h"
-#include "mnodeRead.h"
-#include "mnodePeer.h"
-
-int64_t tsFuncRid = -1;
-static void * tsFuncSdb = NULL;
-static int32_t tsFuncUpdateSize = 0;
-static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeProcessRetrieveFuncImplMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg);
-
-static int32_t mnodeFuncActionDestroy(SSdbRow *pRow) {
- tfree(pRow->pObj);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionInsert(SSdbRow *pRow) {
- SFuncObj *pFunc = pRow->pObj;
-
- mTrace("func:%s, contLen: %d, insert into sdb", pFunc->name, pFunc->contLen);
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionDelete(SSdbRow *pRow) {
- SFuncObj *pFunc = pRow->pObj;
-
- mTrace("func:%s, length: %d, delete from sdb", pFunc->name, pFunc->contLen);
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionUpdate(SSdbRow *pRow) {
- SFuncObj *pFunc = pRow->pObj;
-
- SFuncObj *pSaved = mnodeGetFunc(pFunc->name);
- if (pFunc != pSaved) {
- memcpy(pSaved, pFunc, tsFuncUpdateSize);
- free(pFunc);
- }
-
- mnodeDecFuncRef(pSaved);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionEncode(SSdbRow *pRow) {
- SFuncObj *pFunc = pRow->pObj;
-
- memcpy(pRow->rowData, pFunc, tsFuncUpdateSize);
- pRow->rowSize = tsFuncUpdateSize;
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionDecode(SSdbRow *pRow) {
- SFuncObj *pFunc = (SFuncObj *)calloc(1, sizeof(SFuncObj));
- if (pFunc == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
- memcpy(pFunc, pRow->rowData, tsFuncUpdateSize);
- pRow->pObj = pFunc;
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeFuncActionRestored() {
- int64_t numOfRows = sdbGetNumOfRows(tsFuncSdb);
-
- if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
- mInfo("dnode first deploy, func restored.");
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitFuncs() {
- SFuncObj tObj;
- tsFuncUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
- SSdbTableDesc desc = {
- .id = SDB_TABLE_FUNC,
- .name = "funcs",
- .hashSessions = TSDB_DEFAULT_USERS_HASH_SIZE,
- .maxRowSize = tsFuncUpdateSize,
- .refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
- .keyType = SDB_KEY_STRING,
- .fpInsert = mnodeFuncActionInsert,
- .fpDelete = mnodeFuncActionDelete,
- .fpUpdate = mnodeFuncActionUpdate,
- .fpEncode = mnodeFuncActionEncode,
- .fpDecode = mnodeFuncActionDecode,
- .fpDestroy = mnodeFuncActionDestroy,
- .fpRestored = mnodeFuncActionRestored
- };
-
- tsFuncRid = sdbOpenTable(&desc);
- tsFuncSdb = sdbGetTableByRid(tsFuncRid);
- if (tsFuncSdb == NULL) {
- mError("table:%s, failed to create hash", desc.name);
- return -1;
- }
-
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_FUNCTION, mnodeProcessCreateFuncMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_FUNCTION, mnodeProcessDropFuncMsg);
- mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_RETRIEVE_FUNC, mnodeProcessRetrieveFuncImplMsg);
-
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeGetFuncMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeRetrieveFuncs);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeCancelGetNextFunc);
-
- mDebug("table:%s, hash is created", desc.name);
-
- return 0;
-}
-
-void mnodeCleanupFuncs() {
- sdbCloseTable(tsFuncRid);
- tsFuncSdb = NULL;
-}
-
-SFuncObj *mnodeGetFunc(char *name) {
- return (SFuncObj *)sdbGetRow(tsFuncSdb, name);
-}
-
-void *mnodeGetNextFunc(void *pIter, SFuncObj **pFunc) {
- return sdbFetchRow(tsFuncSdb, pIter, (void **)pFunc);
-}
-
-void mnodeCancelGetNextFunc(void *pIter) {
- sdbFreeIter(tsFuncSdb, pIter);
-}
-
-void mnodeIncFuncRef(SFuncObj *pFunc) {
- sdbIncRef(tsFuncSdb, pFunc);
-}
-
-void mnodeDecFuncRef(SFuncObj *pFunc) {
- sdbDecRef(tsFuncSdb, pFunc);
-}
-/*
-static int32_t mnodeUpdateFunc(SFuncObj *pFunc, void *pMsg) {
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsFuncSdb,
- .pObj = pFunc,
- .pMsg = pMsg
- };
-
- int32_t code = sdbUpdateRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("func:%s, failed to alter by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
- } else {
- mLInfo("func:%s, is altered by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
- }
-
- return code;
-}
-*/
-int32_t mnodeCreateFunc(SAcctObj *pAcct, char *name, int32_t codeLen, char *codeScript, char *path, uint8_t outputType, int16_t outputLen, int32_t funcType, int32_t bufSize, SMnodeMsg *pMsg) {
- if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
- return TSDB_CODE_GRANT_EXPIRED;
- }
-
- if (!pMsg->pUser->writeAuth) {
- return TSDB_CODE_MND_NO_RIGHTS;
- }
-
- int32_t code = acctCheck(pAcct, ACCT_GRANT_USER);
- if (code != TSDB_CODE_SUCCESS) {
- return code;
- }
-
- code = grantCheck(TSDB_GRANT_USER);
- if (code != TSDB_CODE_SUCCESS) {
- return code;
- }
-
- if (name[0] == 0) {
- return TSDB_CODE_MND_INVALID_FUNC_NAME;
- }
-
- if (codeScript[0] == 0) {
- return TSDB_CODE_MND_INVALID_FUNC_CODE;
- }
-
- if (codeLen < 0 || codeLen > TSDB_FUNC_CODE_LEN) {
- return TSDB_CODE_MND_INVALID_FUNC_CODE;
- }
-
- if (bufSize < 0 || bufSize > TSDB_FUNC_BUF_SIZE) {
- return TSDB_CODE_MND_INVALID_FUNC_BUFSIZE;
- }
-
- SFuncObj *pFunc = mnodeGetFunc(name);
- if (pFunc != NULL) {
- mDebug("func:%s, is already there", name);
- mnodeDecFuncRef(pFunc);
- return TSDB_CODE_MND_FUNC_ALREADY_EXIST;
- }
-
- pFunc = calloc(1, sizeof(SFuncObj));
- tstrncpy(pFunc->name, name, TSDB_FUNC_NAME_LEN);
- tstrncpy(pFunc->path, path, tListLen(pFunc->path));
- memcpy(pFunc->cont, codeScript, codeLen);
- pFunc->contLen = codeLen;
- pFunc->createdTime = taosGetTimestampMs();
- pFunc->resType = outputType;
- pFunc->resBytes = outputLen;
- pFunc->funcType = funcType;
- pFunc->bufSize = bufSize;
- pFunc->sig = 0;
- pFunc->type = 1; //lua script, refactor
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsFuncSdb,
- .pObj = pFunc,
- .rowSize = sizeof(SFuncObj),
- .pMsg = pMsg
- };
-
- code = sdbInsertRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("func:%s, failed to create by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
- tfree(pFunc);
- } else {
- mLInfo("func:%s, is created by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
- }
-
- return code;
-}
-
-static int32_t mnodeDropFunc(SFuncObj *pFunc, void *pMsg) {
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsFuncSdb,
- .pObj = pFunc,
- .pMsg = pMsg
- };
-
- int32_t code = sdbDeleteRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("func:%s, failed to drop by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
- } else {
- mLInfo("func:%s, is dropped by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
- }
-
- return code;
-}
-
-static int32_t mnodeGetFuncsNum() {
- return (int32_t)sdbGetNumOfRows(tsFuncSdb);
-}
-
-static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) {
- return TSDB_CODE_MND_NO_USER_FROM_CONN;
- }
-
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = TSDB_FUNC_NAME_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "name");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = PATH_MAX + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "path");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "aggregate");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_TYPE_STR_MAX_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "outputtype");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "create_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "code_len");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "bufsize");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- strcpy(pMeta->tableFname, "show funcs");
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = mnodeGetFuncsNum();
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
- mnodeDecUserRef(pUser);
-
- return 0;
-}
-
-static void* mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int16_t len) {
- char *msg = "unknown";
- if (type >= sizeof(tDataTypes)/sizeof(tDataTypes[0])) {
- return msg;
- }
-
- if (type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_BINARY) {
- int32_t bytes = len > 0 ? (int)(len - VARSTR_HEADER_SIZE) : len;
-
- snprintf(buf, buflen - 1, "%s(%d)", tDataTypes[type].name, type == TSDB_DATA_TYPE_NCHAR ? bytes/4 : bytes);
- buf[buflen - 1] = 0;
-
- return buf;
- }
-
- return tDataTypes[type].name;
-}
-
-static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- SFuncObj *pFunc = NULL;
- int32_t cols = 0;
- char *pWrite;
- char buf[TSDB_TYPE_STR_MAX_LEN];
-
- while (numOfRows < rows) {
- pShow->pIter = mnodeGetNextFunc(pShow->pIter, &pFunc);
- if (pFunc == NULL) break;
-
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pFunc->name, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pFunc->path, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = pFunc->funcType == TSDB_UDF_TYPE_AGGREGATE ? 1 : 0;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->resType, pFunc->resBytes), pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = pFunc->createdTime;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = pFunc->contLen;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = pFunc->bufSize;
- cols++;
-
- numOfRows++;
- mnodeDecFuncRef(pFunc);
- }
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- pShow->numOfReads += numOfRows;
- return numOfRows;
-}
-
-static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg) {
- SCreateFuncMsg *pCreate = pMsg->rpcMsg.pCont;
- pCreate->codeLen = htonl(pCreate->codeLen);
- pCreate->outputLen = htons(pCreate->outputLen);
- pCreate->funcType = htonl(pCreate->funcType);
- pCreate->bufSize = htonl(pCreate->bufSize);
-
- return mnodeCreateFunc(pMsg->pUser->pAcct, pCreate->name, pCreate->codeLen, pCreate->code, pCreate->path, pCreate->outputType, pCreate->outputLen, pCreate->funcType, pCreate->bufSize, pMsg);
-}
-
-static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg) {
- SDropFuncMsg *pDrop = pMsg->rpcMsg.pCont;
-
- SFuncObj *pFunc = mnodeGetFunc(pDrop->name);
- if (pFunc == NULL) {
- return TSDB_CODE_MND_INVALID_FUNC;
- }
-
- return mnodeDropFunc(pFunc, pMsg);
-}
-
-static int32_t mnodeProcessRetrieveFuncImplMsg(SMnodeMsg *pMsg) {
- SRetrieveFuncMsg *pInfo = pMsg->rpcMsg.pCont;
- pInfo->num = htonl(pInfo->num);
-
- int32_t t = sizeof(SUdfFuncMsg) + (sizeof(SFunctionInfoMsg) + TSDB_FUNC_CODE_LEN) * pInfo->num + 16384;
-
- SUdfFuncMsg *pFuncMsg = rpcMallocCont(t);
- pFuncMsg->num = htonl(pInfo->num);
- char* pOutput = pFuncMsg->content;
- tstr* name = (tstr*) pInfo->name;
-
- for(int32_t i = 0; i < pInfo->num; ++i) {
- char buf[TSDB_FUNC_NAME_LEN] = {0};
- tstrncpy(buf, name->data, htons(name->len) + 1);
-
- SFuncObj* pFuncObj = mnodeGetFunc(buf);
- if (pFuncObj == NULL) {
- mError("function %s does not exist", buf);
- return TSDB_CODE_MND_INVALID_FUNC;
- }
-
- SFunctionInfoMsg* pFuncInfo = (SFunctionInfoMsg*) pOutput;
-
- strcpy(pFuncInfo->name, buf);
- pFuncInfo->len = htonl(pFuncObj->contLen);
- memcpy(pFuncInfo->content, pFuncObj->cont, pFuncObj->contLen);
-
- pFuncInfo->funcType = htonl(pFuncObj->funcType);
- pFuncInfo->resType = pFuncObj->resType;
- pFuncInfo->resBytes = htons(pFuncObj->resBytes);
- pFuncInfo->bufSize = htonl(pFuncObj->bufSize);
-
- pOutput += sizeof(SFunctionInfoMsg) + pFuncObj->contLen;
- name =(tstr *)((char *)name + sizeof(*name) + htons(name->len));
- }
-
- pMsg->rpcRsp.rsp = pFuncMsg;
- pMsg->rpcRsp.len = (int32_t)(pOutput - (char*)pFuncMsg);
- return TSDB_CODE_SUCCESS;
-}
diff --git a/src/mnode/src/mnodeGrant.c b/src/mnode/src/mnodeGrant.c
deleted file mode 100644
index 7329629ef92f61d29794807bd868cda354270548..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeGrant.c
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#ifndef _GRANT
-#include "os.h"
-#include "taoserror.h"
-#include "tgrant.h"
-#include "mnodeInt.h"
-
-int32_t grantInit() { return TSDB_CODE_SUCCESS; }
-void grantCleanUp() {}
-void grantParseParameter() { mError("can't parsed parameter k"); }
-int32_t grantCheck(EGrantType grant) { return TSDB_CODE_SUCCESS; }
-void grantReset(EGrantType grant, uint64_t value) {}
-void grantAdd(EGrantType grant, uint64_t value) {}
-void grantRestore(EGrantType grant, uint64_t value) {}
-
-#endif
\ No newline at end of file
diff --git a/src/mnode/src/mnodeInt.c b/src/mnode/src/mnodeInt.c
deleted file mode 100644
index 534deec09a821ce2aa6e5761d2d7242015713fd0..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeInt.c
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosmsg.h"
-#include "taoserror.h"
-#include "trpc.h"
-#include "tqueue.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeDb.h"
-#include "mnodeDnode.h"
-#include "mnodeMnode.h"
-#include "mnodeProfile.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeTable.h"
-#include "mnodeUser.h"
-#include "mnodeVgroup.h"
-
-void *mnodeCreateMsg(SRpcMsg *pRpcMsg) {
- int32_t size = sizeof(SMnodeMsg) + pRpcMsg->contLen;
- SMnodeMsg *pMsg = taosAllocateQitem(size);
-
- pMsg->rpcMsg = *pRpcMsg;
- pMsg->rpcMsg.pCont = pMsg->pCont;
- pMsg->incomingTs = taosGetTimestampSec();
- memcpy(pMsg->pCont, pRpcMsg->pCont, pRpcMsg->contLen);
-
- return pMsg;
-}
-
-int32_t mnodeInitMsg(SMnodeMsg *pMsg) {
- if (pMsg->pUser != NULL) {
- mTrace("msg:%p, app:%p user info already inited", pMsg, pMsg->rpcMsg.ahandle);
- return TSDB_CODE_SUCCESS;
- }
-
- pMsg->pUser = mnodeGetUserFromConn(pMsg->rpcMsg.handle);
- if (pMsg->pUser == NULL) {
- return TSDB_CODE_MND_INVALID_USER;
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-void mnodeCleanupMsg(SMnodeMsg *pMsg) {
- if (pMsg != NULL) {
- if (pMsg->rpcMsg.pCont != pMsg->pCont) {
- tfree(pMsg->rpcMsg.pCont);
- }
- if (pMsg->pUser) mnodeDecUserRef(pMsg->pUser);
- if (pMsg->pDb) mnodeDecDbRef(pMsg->pDb);
- if (pMsg->pVgroup) mnodeDecVgroupRef(pMsg->pVgroup);
- if (pMsg->pTable) mnodeDecTableRef(pMsg->pTable);
- if (pMsg->pSTable) mnodeDecTableRef(pMsg->pSTable);
- if (pMsg->pAcct) mnodeDecAcctRef(pMsg->pAcct);
- if (pMsg->pDnode) mnodeDecDnodeRef(pMsg->pDnode);
- }
-}
diff --git a/src/mnode/src/mnodeMain.c b/src/mnode/src/mnodeMain.c
deleted file mode 100644
index df3c49165ca00262016006e4450eb1ba574a5525..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeMain.c
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosdef.h"
-#include "tsched.h"
-#include "tbn.h"
-#include "tgrant.h"
-#include "ttimer.h"
-#include "tglobal.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeDnode.h"
-#include "mnodeMnode.h"
-#include "mnodeDb.h"
-#include "mnodeSdb.h"
-#include "mnodeVgroup.h"
-#include "mnodeUser.h"
-#include "mnodeFunc.h"
-#include "mnodeTable.h"
-#include "mnodeCluster.h"
-#include "mnodeShow.h"
-#include "mnodeProfile.h"
-
-void *tsMnodeTmr = NULL;
-static bool tsMgmtIsRunning = false;
-
-static SStep tsMnodeSteps[] = {
- {"sdbref", sdbInitRef, sdbCleanUpRef},
- {"profile", mnodeInitProfile, mnodeCleanupProfile},
- {"cluster", mnodeInitCluster, mnodeCleanupCluster},
- {"accts", mnodeInitAccts, mnodeCleanupAccts},
- {"users", mnodeInitUsers, mnodeCleanupUsers},
- {"funcs", mnodeInitFuncs, mnodeCleanupFuncs},
- {"dnodes", mnodeInitDnodes, mnodeCleanupDnodes},
- {"dbs", mnodeInitDbs, mnodeCleanupDbs},
- {"vgroups", mnodeInitVgroups, mnodeCleanupVgroups},
- {"tables", mnodeInitTables, mnodeCleanupTables},
- {"mnodes", mnodeInitMnodes, mnodeCleanupMnodes},
- {"sdb", sdbInit, sdbCleanUp},
- {"balance", bnInit, bnCleanUp},
- {"grant", grantInit, grantCleanUp},
- {"show", mnodeInitShow, mnodeCleanUpShow}
-};
-
-static SStep tsMnodeCompactSteps[] = {
- {"cluster", mnodeCompactCluster, NULL},
- {"dnodes", mnodeCompactDnodes, NULL},
- {"mnodes", mnodeCompactMnodes, NULL},
- {"accts", mnodeCompactAccts, NULL},
- {"users", mnodeCompactUsers, NULL},
- {"dbs", mnodeCompactDbs, NULL},
- {"vgroups", mnodeCompactVgroups, NULL},
- {"tables", mnodeCompactTables, NULL},
-
-};
-
-static void mnodeInitTimer();
-static void mnodeCleanupTimer();
-static bool mnodeNeedStart() ;
-
-static void mnodeCleanupComponents() {
- int32_t stepSize = sizeof(tsMnodeSteps) / sizeof(SStep);
- dnodeStepCleanup(tsMnodeSteps, stepSize);
-}
-
-static int32_t mnodeInitComponents() {
- int32_t stepSize = sizeof(tsMnodeSteps) / sizeof(SStep);
- return dnodeStepInit(tsMnodeSteps, stepSize);
-}
-
-int32_t mnodeCompactComponents() {
- int32_t stepSize = sizeof(tsMnodeCompactSteps) / sizeof(SStep);
- return dnodeStepInit(tsMnodeCompactSteps, stepSize);
-}
-
-int32_t mnodeStartSystem() {
- if (tsMgmtIsRunning) {
- mInfo("mnode module already started...");
- return TSDB_CODE_SUCCESS;
- }
-
- mInfo("starting to initialize mnode ...");
- if (mkdir(tsMnodeDir, 0755) != 0 && errno != EEXIST) {
- mError("failed to init mnode dir:%s, reason:%s", tsMnodeDir, strerror(errno));
- return TSDB_CODE_MND_FAILED_TO_CREATE_DIR;
- }
-
- dnodeAllocMWritequeue();
- dnodeAllocMReadQueue();
- dnodeAllocateMPeerQueue();
-
- if (mnodeInitComponents() != 0) {
- return TSDB_CODE_MND_FAILED_TO_INIT_STEP;
- }
-
- dnodeReportStep("mnode-grant", "start to set grant infomation", 0);
- grantReset(TSDB_GRANT_ALL, 0);
- tsMgmtIsRunning = true;
-
- mInfo("mnode is initialized successfully");
-
- sdbUpdateSync(NULL);
-
- return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitSystem() {
- mnodeInitTimer();
- if (mnodeNeedStart() || tsCompactMnodeWal) {
- return mnodeStartSystem();
- }
- return 0;
-}
-
-void mnodeCleanupSystem() {
- if (tsMgmtIsRunning) {
- mInfo("starting to clean up mnode");
- tsMgmtIsRunning = false;
-
- dnodeFreeMWritequeue();
- dnodeFreeMReadQueue();
- dnodeFreeMPeerQueue();
- mnodeCleanupTimer();
- mnodeCleanupComponents();
-
- mInfo("mnode is cleaned up");
- }
-}
-
-void mnodeStopSystem() {
- if (sdbIsMaster()) {
- mDebug("it is a master mnode, it could not be stopped");
- return;
- }
-
- mnodeCleanupSystem();
-
- if (remove(tsMnodeDir) != 0) {
- mInfo("failed to remove mnode file, reason:%s", strerror(errno));
- } else {
- mInfo("mnode file is removed");
- }
-}
-
-static void mnodeInitTimer() {
- if (tsMnodeTmr == NULL) {
- tsMnodeTmr = taosTmrInit(tsMaxShellConns, 200, 3600000, "MND");
- }
-}
-
-static void mnodeCleanupTimer() {
- if (tsMnodeTmr != NULL) {
- taosTmrCleanUp(tsMnodeTmr);
- tsMnodeTmr = NULL;
- }
-}
-
-static bool mnodeNeedStart() {
- struct stat dirstat;
- char mnodeFileName[TSDB_FILENAME_LEN * 2] = {0};
- sprintf(mnodeFileName, "%s/wal/wal0", tsMnodeDir);
-
- bool fileExist = (stat(mnodeFileName, &dirstat) == 0);
- bool asMaster = (strcmp(tsFirst, tsLocalEp) == 0);
-
- if (asMaster || fileExist) {
- mDebug("mnode module start, asMaster:%d fileExist:%d", asMaster, fileExist);
- return true;
- } else {
- mDebug("mnode module won't start, asMaster:%d fileExist:%d", asMaster, fileExist);
- return false;
- }
-}
-
-bool mnodeIsRunning() {
- return tsMgmtIsRunning;
-}
diff --git a/src/mnode/src/mnodeMnode.c b/src/mnode/src/mnodeMnode.c
deleted file mode 100644
index 13dd06bcac733694475eee7be718afdc6c17466e..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeMnode.c
+++ /dev/null
@@ -1,606 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "tglobal.h"
-#include "trpc.h"
-#include "tsync.h"
-#include "tbn.h"
-#include "tutil.h"
-#include "tsocket.h"
-#include "tdataformat.h"
-#include "dnode.h"
-#include "mnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeMnode.h"
-#include "mnodeDnode.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeUser.h"
-#include "mnodeVgroup.h"
-
-int64_t tsMnodeRid = -1;
-static void * tsMnodeSdb = NULL;
-static int32_t tsMnodeUpdateSize = 0;
-static SRpcEpSet tsMEpForShell;
-static SRpcEpSet tsMEpForPeer;
-static SMInfos tsMInfos;
-static int32_t mnodeGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-
-#if defined(LINUX)
- static pthread_rwlock_t tsMnodeLock;
- #define mnodeMnodeWrLock() pthread_rwlock_wrlock(&tsMnodeLock)
- #define mnodeMnodeRdLock() pthread_rwlock_rdlock(&tsMnodeLock)
- #define mnodeMnodeUnLock() pthread_rwlock_unlock(&tsMnodeLock)
- #define mnodeMnodeInitLock() pthread_rwlock_init(&tsMnodeLock, NULL)
- #define mnodeMnodeDestroyLock() pthread_rwlock_destroy(&tsMnodeLock)
-#else
- static pthread_mutex_t tsMnodeLock;
- #define mnodeMnodeWrLock() pthread_mutex_lock(&tsMnodeLock)
- #define mnodeMnodeRdLock() pthread_mutex_lock(&tsMnodeLock)
- #define mnodeMnodeUnLock() pthread_mutex_unlock(&tsMnodeLock)
- #define mnodeMnodeInitLock() pthread_mutex_init(&tsMnodeLock, NULL)
- #define mnodeMnodeDestroyLock() pthread_mutex_destroy(&tsMnodeLock)
-#endif
-
-static int32_t mnodeMnodeActionDestroy(SSdbRow *pRow) {
- tfree(pRow->pObj);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionInsert(SSdbRow *pRow) {
- SMnodeObj *pMnode = pRow->pObj;
- SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
- if (pDnode == NULL) return TSDB_CODE_MND_DNODE_NOT_EXIST;
-
- pDnode->isMgmt = true;
- mnodeDecDnodeRef(pDnode);
-
- mInfo("mnode:%d, fqdn:%s ep:%s port:%u is created", pMnode->mnodeId, pDnode->dnodeFqdn, pDnode->dnodeEp,
- pDnode->dnodePort);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionDelete(SSdbRow *pRow) {
- SMnodeObj *pMnode = pRow->pObj;
-
- SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
- if (pDnode == NULL) return TSDB_CODE_MND_DNODE_NOT_EXIST;
- pDnode->isMgmt = false;
- mnodeDecDnodeRef(pDnode);
-
- mDebug("mnode:%d, is dropped from sdb", pMnode->mnodeId);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionUpdate(SSdbRow *pRow) {
- SMnodeObj *pMnode = pRow->pObj;
- SMnodeObj *pSaved = mnodeGetMnode(pMnode->mnodeId);
- if (pMnode != pSaved) {
- memcpy(pSaved, pMnode, pRow->rowSize);
- free(pMnode);
- }
- mnodeDecMnodeRef(pSaved);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionEncode(SSdbRow *pRow) {
- SMnodeObj *pMnode = pRow->pObj;
- memcpy(pRow->rowData, pMnode, tsMnodeUpdateSize);
- pRow->rowSize = tsMnodeUpdateSize;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionDecode(SSdbRow *pRow) {
- SMnodeObj *pMnode = calloc(1, sizeof(SMnodeObj));
- if (pMnode == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
- memcpy(pMnode, pRow->rowData, tsMnodeUpdateSize);
- pRow->pObj = pMnode;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeMnodeActionRestored() {
- if (mnodeGetMnodesNum() == 1) {
- SMnodeObj *pMnode = NULL;
- void *pIter = mnodeGetNextMnode(NULL, &pMnode);
- if (pMnode != NULL) {
- pMnode->role = TAOS_SYNC_ROLE_MASTER;
- pMnode->roleTime = taosGetTimestampMs();
- mnodeDecMnodeRef(pMnode);
- }
- mnodeCancelGetNextMnode(pIter);
- }
-
- mnodeUpdateMnodeEpSet(NULL);
-
- return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitMnodes() {
- mnodeMnodeInitLock();
-
- SMnodeObj tObj;
- tsMnodeUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
- SSdbTableDesc desc = {
- .id = SDB_TABLE_MNODE,
- .name = "mnodes",
- .hashSessions = TSDB_DEFAULT_MNODES_HASH_SIZE,
- .maxRowSize = tsMnodeUpdateSize,
- .refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
- .keyType = SDB_KEY_INT,
- .fpInsert = mnodeMnodeActionInsert,
- .fpDelete = mnodeMnodeActionDelete,
- .fpUpdate = mnodeMnodeActionUpdate,
- .fpEncode = mnodeMnodeActionEncode,
- .fpDecode = mnodeMnodeActionDecode,
- .fpDestroy = mnodeMnodeActionDestroy,
- .fpRestored = mnodeMnodeActionRestored
- };
-
- tsMnodeRid = sdbOpenTable(&desc);
- tsMnodeSdb = sdbGetTableByRid(tsMnodeRid);
- if (tsMnodeSdb == NULL) {
- mError("failed to init mnodes data");
- return -1;
- }
-
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_MNODE, mnodeGetMnodeMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_MNODE, mnodeRetrieveMnodes);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_MNODE, mnodeCancelGetNextMnode);
-
- mDebug("table:mnodes table is created");
- return TSDB_CODE_SUCCESS;
-}
-
-void mnodeCleanupMnodes() {
- sdbCloseTable(tsMnodeRid);
- tsMnodeSdb = NULL;
- mnodeMnodeDestroyLock();
-}
-
-int32_t mnodeGetMnodesNum() {
- return (int32_t)sdbGetNumOfRows(tsMnodeSdb);
-}
-
-void *mnodeGetMnode(int32_t mnodeId) {
- return sdbGetRow(tsMnodeSdb, &mnodeId);
-}
-
-void mnodeIncMnodeRef(SMnodeObj *pMnode) {
- sdbIncRef(tsMnodeSdb, pMnode);
-}
-
-void mnodeDecMnodeRef(SMnodeObj *pMnode) {
- sdbDecRef(tsMnodeSdb, pMnode);
-}
-
-void *mnodeGetNextMnode(void *pIter, SMnodeObj **pMnode) {
- return sdbFetchRow(tsMnodeSdb, pIter, (void **)pMnode);
-}
-
-void mnodeCancelGetNextMnode(void *pIter) {
- sdbFreeIter(tsMnodeSdb, pIter);
-}
-
-void mnodeUpdateMnodeEpSet(SMInfos *pMinfos) {
- bool set = false;
- SMInfos mInfos = {0};
-
- if (pMinfos != NULL) {
- mInfo("vgId:1, update mnodes epSet, numOfMinfos:%d", pMinfos->mnodeNum);
- set = true;
- mInfos = *pMinfos;
- } else {
- mInfo("vgId:1, update mnodes epSet, numOfMnodes:%d", mnodeGetMnodesNum());
- int32_t index = 0;
- void * pIter = NULL;
- while (1) {
- SMnodeObj *pMnode = NULL;
- pIter = mnodeGetNextMnode(pIter, &pMnode);
- if (pMnode == NULL) break;
-
- SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
- if (pDnode != NULL) {
- set = true;
- mInfos.mnodeInfos[index].mnodeId = pMnode->mnodeId;
- strcpy(mInfos.mnodeInfos[index].mnodeEp, pDnode->dnodeEp);
- if (pMnode->role == TAOS_SYNC_ROLE_MASTER) mInfos.inUse = index;
- index++;
- } else {
- set = false;
- }
-
- mnodeDecDnodeRef(pDnode);
- mnodeDecMnodeRef(pMnode);
- }
-
- mInfos.mnodeNum = index;
- if (mInfos.mnodeNum < sdbGetReplicaNum()) {
- set = false;
- mDebug("vgId:1, mnodes info not synced, current:%d syncCfgNum:%d", mInfos.mnodeNum, sdbGetReplicaNum());
- }
- }
-
- mnodeMnodeWrLock();
-
- if (set) {
- memset(&tsMEpForShell, 0, sizeof(SRpcEpSet));
- memset(&tsMEpForPeer, 0, sizeof(SRpcEpSet));
- memcpy(&tsMInfos, &mInfos, sizeof(SMInfos));
- tsMEpForShell.inUse = tsMInfos.inUse;
- tsMEpForPeer.inUse = tsMInfos.inUse;
- tsMEpForShell.numOfEps = tsMInfos.mnodeNum;
- tsMEpForPeer.numOfEps = tsMInfos.mnodeNum;
-
- mInfo("vgId:1, mnodes epSet is set, num:%d inUse:%d", tsMInfos.mnodeNum, tsMInfos.inUse);
- for (int index = 0; index < mInfos.mnodeNum; ++index) {
- SMInfo *pInfo = &tsMInfos.mnodeInfos[index];
- taosGetFqdnPortFromEp(pInfo->mnodeEp, tsMEpForShell.fqdn[index], &tsMEpForShell.port[index]);
- taosGetFqdnPortFromEp(pInfo->mnodeEp, tsMEpForPeer.fqdn[index], &tsMEpForPeer.port[index]);
- tsMEpForPeer.port[index] = tsMEpForPeer.port[index] + TSDB_PORT_DNODEDNODE;
-
- mInfo("vgId:1, mnode:%d, fqdn:%s shell:%u peer:%u", pInfo->mnodeId, tsMEpForShell.fqdn[index],
- tsMEpForShell.port[index], tsMEpForPeer.port[index]);
-
- tsMEpForShell.port[index] = htons(tsMEpForShell.port[index]);
- tsMEpForPeer.port[index] = htons(tsMEpForPeer.port[index]);
- pInfo->mnodeId = htonl(pInfo->mnodeId);
- }
- } else {
- mInfo("vgId:1, mnodes epSet not set, num:%d inUse:%d", tsMInfos.mnodeNum, tsMInfos.inUse);
- for (int index = 0; index < tsMInfos.mnodeNum; ++index) {
- mInfo("vgId:1, index:%d, ep:%s:%u", index, tsMEpForShell.fqdn[index], htons(tsMEpForShell.port[index]));
- }
- }
-
- mnodeMnodeUnLock();
-}
-
-void mnodeGetMnodeEpSetForPeer(SRpcEpSet *epSet, bool redirect) {
- mnodeMnodeRdLock();
- *epSet = tsMEpForPeer;
- mnodeMnodeUnLock();
-
- mTrace("vgId:1, mnodes epSet for peer is returned, num:%d inUse:%d", tsMEpForPeer.numOfEps, tsMEpForPeer.inUse);
- for (int32_t i = 0; i < epSet->numOfEps; ++i) {
- if (redirect && strcmp(epSet->fqdn[i], tsLocalFqdn) == 0 && htons(epSet->port[i]) == tsServerPort + TSDB_PORT_DNODEDNODE) {
- epSet->inUse = (i + 1) % epSet->numOfEps;
- mTrace("vgId:1, mnode:%d, for peer ep:%s:%u, set inUse to %d", i, epSet->fqdn[i], htons(epSet->port[i]), epSet->inUse);
- } else {
- mTrace("vgId:1, mpeer:%d, for peer ep:%s:%u", i, epSet->fqdn[i], htons(epSet->port[i]));
- }
- }
-}
-
-void mnodeGetMnodeEpSetForShell(SRpcEpSet *epSet, bool redirect) {
- mnodeMnodeRdLock();
- *epSet = tsMEpForShell;
- mnodeMnodeUnLock();
-
- if (mnodeGetDnodesNum() <= 1) {
- epSet->numOfEps = 0;
- return;
- }
-
- mTrace("vgId:1, mnodes epSet for shell is returned, num:%d inUse:%d", tsMEpForShell.numOfEps, tsMEpForShell.inUse);
- for (int32_t i = 0; i < epSet->numOfEps; ++i) {
- if (redirect && strcmp(epSet->fqdn[i], tsLocalFqdn) == 0 && htons(epSet->port[i]) == tsServerPort) {
- epSet->inUse = (i + 1) % epSet->numOfEps;
- mTrace("vgId:1, mnode:%d, for shell ep:%s:%u, set inUse to %d", i, epSet->fqdn[i], htons(epSet->port[i]), epSet->inUse);
- } else {
- mTrace("vgId:1, mnode:%d, for shell ep:%s:%u", i, epSet->fqdn[i], htons(epSet->port[i]));
- }
- }
-}
-
-char* mnodeGetMnodeMasterEp() {
- return tsMInfos.mnodeInfos[tsMInfos.inUse].mnodeEp;
-}
-
-void mnodeGetMnodeInfos(void *pMinfos) {
- mnodeMnodeRdLock();
- *(SMInfos *)pMinfos = tsMInfos;
- mnodeMnodeUnLock();
-}
-
-static int32_t mnodeSendCreateMnodeMsg(int32_t dnodeId, char *dnodeEp) {
- SCreateMnodeMsg *pCreate = rpcMallocCont(sizeof(SCreateMnodeMsg));
- if (pCreate == NULL) {
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- } else {
- pCreate->dnodeId = htonl(dnodeId);
- tstrncpy(pCreate->dnodeEp, dnodeEp, sizeof(pCreate->dnodeEp));
- mnodeGetMnodeInfos(&pCreate->mnodes);
- bool found = false;
- for (int i = 0; i < pCreate->mnodes.mnodeNum; ++i) {
- if (pCreate->mnodes.mnodeInfos[i].mnodeId == htonl(dnodeId)) {
- found = true;
- }
- }
- if (!found) {
- pCreate->mnodes.mnodeInfos[pCreate->mnodes.mnodeNum].mnodeId = htonl(dnodeId);
- tstrncpy(pCreate->mnodes.mnodeInfos[pCreate->mnodes.mnodeNum].mnodeEp, dnodeEp, sizeof(pCreate->dnodeEp));
- pCreate->mnodes.mnodeNum++;
- }
- }
-
- mDebug("dnode:%d, send create mnode msg to dnode %s, numOfMnodes:%d", dnodeId, dnodeEp, pCreate->mnodes.mnodeNum);
- for (int32_t i = 0; i < pCreate->mnodes.mnodeNum; ++i) {
- mDebug("index:%d, mnodeId:%d ep:%s", i, pCreate->mnodes.mnodeInfos[i].mnodeId, pCreate->mnodes.mnodeInfos[i].mnodeEp);
- }
-
- SRpcMsg rpcMsg = {0};
- rpcMsg.pCont = pCreate;
- rpcMsg.contLen = sizeof(SCreateMnodeMsg);
- rpcMsg.msgType = TSDB_MSG_TYPE_MD_CREATE_MNODE;
-
- SRpcMsg rpcRsp = {0};
- SRpcEpSet epSet = mnodeGetEpSetFromIp(pCreate->dnodeEp);
- dnodeSendMsgToDnodeRecv(&rpcMsg, &rpcRsp, &epSet);
-
- if (rpcRsp.code != TSDB_CODE_SUCCESS) {
- mError("dnode:%d, failed to send create mnode msg, ep:%s reason:%s", dnodeId, dnodeEp, tstrerror(rpcRsp.code));
- } else {
- mDebug("dnode:%d, create mnode msg is disposed, mnode is created in dnode", dnodeId);
- }
-
- rpcFreeCont(rpcRsp.pCont);
- return rpcRsp.code;
-}
-
-static int32_t mnodeCreateMnodeCb(SMnodeMsg *pMsg, int32_t code) {
- if (code != TSDB_CODE_SUCCESS) {
- mError("failed to create mnode, reason:%s", tstrerror(code));
- } else {
- mDebug("mnode is created successfully");
- mnodeUpdateMnodeEpSet(NULL);
- sdbUpdateAsync();
- }
-
- return code;
-}
-
-static bool mnodeAllOnline() {
- void *pIter = NULL;
- bool allOnline = true;
-
- sdbUpdateMnodeRoles();
-
- while (1) {
- SMnodeObj *pMnode = NULL;
- pIter = mnodeGetNextMnode(pIter, &pMnode);
- if (pMnode == NULL) break;
- if (pMnode->role != TAOS_SYNC_ROLE_MASTER && pMnode->role != TAOS_SYNC_ROLE_SLAVE) {
- allOnline = false;
- mDebug("mnode:%d, role:%s, not online", pMnode->mnodeId, syncRole[pMnode->role]);
- mnodeDecMnodeRef(pMnode);
- }
- }
- mnodeCancelGetNextMnode(pIter);
-
- return allOnline;
-}
-
-void mnodeCreateMnode(int32_t dnodeId, char *dnodeEp, bool needConfirm) {
- SMnodeObj *pMnode = calloc(1, sizeof(SMnodeObj));
- pMnode->mnodeId = dnodeId;
- pMnode->createdTime = taosGetTimestampMs();
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsMnodeSdb,
- .pObj = pMnode,
- .fpRsp = mnodeCreateMnodeCb
- };
-
- if (needConfirm && !mnodeAllOnline()) {
- mDebug("wait all mnode online then create new mnode");
- return;
- }
-
- int32_t code = TSDB_CODE_SUCCESS;
- if (needConfirm) {
- code = mnodeSendCreateMnodeMsg(dnodeId, dnodeEp);
- }
-
- if (code != TSDB_CODE_SUCCESS) {
- tfree(pMnode);
- return;
- }
-
- code = sdbInsertRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("dnode:%d, failed to create mnode, ep:%s reason:%s", dnodeId, dnodeEp, tstrerror(code));
- tfree(pMnode);
- }
-}
-
-void mnodeDropMnodeLocal(int32_t dnodeId) {
- SMnodeObj *pMnode = mnodeGetMnode(dnodeId);
- if (pMnode != NULL) {
- SSdbRow row = {.type = SDB_OPER_LOCAL, .pTable = tsMnodeSdb, .pObj = pMnode};
- sdbDeleteRow(&row);
- mnodeDecMnodeRef(pMnode);
- }
-
- mnodeUpdateMnodeEpSet(NULL);
- sdbUpdateAsync();
-}
-
-int32_t mnodeDropMnode(int32_t dnodeId) {
- SMnodeObj *pMnode = mnodeGetMnode(dnodeId);
- if (pMnode == NULL) {
- return TSDB_CODE_MND_DNODE_NOT_EXIST;
- }
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsMnodeSdb,
- .pObj = pMnode
- };
-
- int32_t code = sdbDeleteRow(&row);
-
- sdbDecRef(tsMnodeSdb, pMnode);
-
- mnodeUpdateMnodeEpSet(NULL);
- sdbUpdateAsync();
-
- return code;
-}
-
-static int32_t mnodeGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- sdbUpdateMnodeRoles();
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) return 0;
-
- if (strcmp(pUser->pAcct->user, TSDB_DEFAULT_USER) != 0) {
- mnodeDecUserRef(pUser);
- return TSDB_CODE_MND_NO_RIGHTS;
- }
-
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "id");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_EP_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "end_point");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 12 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "role");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "role_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "create_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = mnodeGetMnodesNum();
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
- pShow->pIter = NULL;
- mnodeDecUserRef(pUser);
-
- return 0;
-}
-
-static int32_t mnodeRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- int32_t cols = 0;
- SMnodeObj *pMnode = NULL;
- char *pWrite;
-
- while (numOfRows < rows) {
- pShow->pIter = mnodeGetNextMnode(pShow->pIter, &pMnode);
- if (pMnode == NULL) break;
-
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = pMnode->mnodeId;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
- SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
- if (pDnode != NULL) {
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDnode->dnodeEp, pShow->bytes[cols]);
- } else {
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, "invalid ep", pShow->bytes[cols]);
- }
- mnodeDecDnodeRef(pDnode);
-
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- char* roles = syncRole[pMnode->role];
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, roles, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = pMnode->roleTime;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = pMnode->createdTime;
- cols++;
-
- numOfRows++;
-
- mnodeDecMnodeRef(pMnode);
- }
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- pShow->numOfReads += numOfRows;
-
- return numOfRows;
-}
-
-int32_t mnodeCompactMnodes() {
- void *pIter = NULL;
- SMnodeObj *pMnode = NULL;
-
- mInfo("start to compact mnodes table...");
-
- while (1) {
- pIter = mnodeGetNextMnode(pIter, &pMnode);
- if (pMnode == NULL) break;
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsMnodeSdb,
- .pObj = pMnode,
- .rowSize = sizeof(SMnodeObj),
- };
-
- mInfo("compact mnode %d", pMnode->mnodeId);
-
- sdbInsertCompactRow(&row);
- }
-
- mInfo("end to compact mnodes table...");
-
- return 0;
-}
\ No newline at end of file
diff --git a/src/mnode/src/mnodePeer.c b/src/mnode/src/mnodePeer.c
deleted file mode 100644
index 9bd8d7e4d7b0723ac4c5e4248e3c1193dfc15ceb..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodePeer.c
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "tsched.h"
-#include "tutil.h"
-#include "tgrant.h"
-#include "tbn.h"
-#include "tglobal.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeDb.h"
-#include "mnodeMnode.h"
-#include "mnodeProfile.h"
-#include "mnodeShow.h"
-#include "mnodeSdb.h"
-#include "mnodeTable.h"
-#include "mnodeVgroup.h"
-
-static int32_t (*tsMnodeProcessPeerMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *);
-static void (*tsMnodeProcessPeerRspFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *);
-
-void mnodeAddPeerMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg)) {
- tsMnodeProcessPeerMsgFp[msgType] = fp;
-}
-
-void mnodeAddPeerRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)) {
- tsMnodeProcessPeerRspFp[msgType] = fp;
-}
-
-int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg) {
- if (pMsg->rpcMsg.pCont == NULL) {
- mError("msg:%p, ahandle:%p type:%s in mpeer queue, content is null", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
- return TSDB_CODE_MND_INVALID_MSG_LEN;
- }
-
- if (!sdbIsMaster()) {
- SMnodeRsp *rpcRsp = &pMsg->rpcRsp;
- SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
- mnodeGetMnodeEpSetForPeer(epSet, true);
- rpcRsp->rsp = epSet;
- rpcRsp->len = sizeof(SRpcEpSet);
-
- mDebug("msg:%p, ahandle:%p type:%s in mpeer queue is redirected, numOfEps:%d inUse:%d", pMsg, pMsg->rpcMsg.ahandle,
- taosMsg[pMsg->rpcMsg.msgType], epSet->numOfEps, epSet->inUse);
-
- return TSDB_CODE_RPC_REDIRECT;
- }
-
- if (tsMnodeProcessPeerMsgFp[pMsg->rpcMsg.msgType] == NULL) {
- mError("msg:%p, ahandle:%p type:%s in mpeer queue, not processed", pMsg, pMsg->rpcMsg.ahandle,
- taosMsg[pMsg->rpcMsg.msgType]);
- return TSDB_CODE_MND_MSG_NOT_PROCESSED;
- }
-
- return (*tsMnodeProcessPeerMsgFp[pMsg->rpcMsg.msgType])(pMsg);
-}
-
-void mnodeProcessPeerRsp(SRpcMsg *pMsg) {
- if (!sdbIsMaster()) {
- mError("msg:%p, ahandle:%p type:%s is not processed for it is not master", pMsg, pMsg->ahandle,
- taosMsg[pMsg->msgType]);
- return;
- }
-
- if (tsMnodeProcessPeerRspFp[pMsg->msgType]) {
- (*tsMnodeProcessPeerRspFp[pMsg->msgType])(pMsg);
- } else {
- mError("msg:%p, ahandle:%p type:%s is not processed", pMsg, pMsg->ahandle, taosMsg[pMsg->msgType]);
- }
-}
diff --git a/src/mnode/src/mnodeProfile.c b/src/mnode/src/mnodeProfile.c
deleted file mode 100644
index 15438fc234bb60089e9d0f52fe92eb5bf8b3eeae..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeProfile.c
+++ /dev/null
@@ -1,742 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosmsg.h"
-#include "taoserror.h"
-#include "tutil.h"
-#include "tcache.h"
-#include "tglobal.h"
-#include "tdataformat.h"
-#include "mnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeProfile.h"
-#include "mnodeShow.h"
-#include "mnodeUser.h"
-#include "mnodeWrite.h"
-
-#define CONN_KEEP_TIME (tsShellActivityTimer * 3)
-#define CONN_CHECK_TIME (tsShellActivityTimer * 2)
-#define QUERY_ID_SIZE 20
-#define QUERY_OBJ_ID_SIZE 18
-#define SUBQUERY_INFO_SIZE 6
-#define QUERY_STREAM_SAVE_SIZE 20
-
-static SCacheObj *tsMnodeConnCache = NULL;
-static int32_t tsConnIndex = 0;
-
-static int32_t mnodeGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveConns(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void mnodeCancelGetNextConn(void *pIter);
-static int32_t mnodeGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void mnodeFreeConn(void *data);
-static int32_t mnodeProcessKillQueryMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessKillStreamMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessKillConnectionMsg(SMnodeMsg *pMsg);
-
-int32_t mnodeInitProfile() {
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mnodeGetQueryMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mnodeRetrieveQueries);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_QUERIES, mnodeCancelGetNextConn);
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mnodeGetConnsMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mnodeRetrieveConns);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_CONNS, mnodeCancelGetNextConn);
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_STREAMS, mnodeGetStreamMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMS, mnodeRetrieveStreams);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_STREAMS, mnodeCancelGetNextConn);
-
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mnodeProcessKillQueryMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mnodeProcessKillStreamMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_CONN, mnodeProcessKillConnectionMsg);
-
- tsMnodeConnCache = taosCacheInit(TSDB_DATA_TYPE_INT, CONN_CHECK_TIME, true, mnodeFreeConn, "conn");
- return 0;
-}
-
-void mnodeCleanupProfile() {
- if (tsMnodeConnCache != NULL) {
- taosCacheCleanup(tsMnodeConnCache);
- tsMnodeConnCache = NULL;
- }
-}
-
-SConnObj *mnodeCreateConn(char *user, uint32_t ip, uint16_t port, int32_t pid, const char* app) {
-#if 0
- int32_t connSize = taosHashGetSize(tsMnodeConnCache->pHashTable);
- if (connSize > tsMaxShellConns) {
- mError("failed to create conn for user:%s ip:%s:%u, conns:%d larger than maxShellConns:%d, ", user, taosIpStr(ip),
- port, connSize, tsMaxShellConns);
- terrno = TSDB_CODE_MND_TOO_MANY_SHELL_CONNS;
- return NULL;
- }
-#endif
-
- int32_t connId = atomic_add_fetch_32(&tsConnIndex, 1);
- if (connId == 0) atomic_add_fetch_32(&tsConnIndex, 1);
-
- SConnObj connObj = {
- .ip = ip,
- .port = port,
- .connId = connId,
- .stime = taosGetTimestampMs(),
- .pid = pid,
- };
-
- tstrncpy(connObj.user, user, tListLen(connObj.user));
- tstrncpy(connObj.appName, app, tListLen(connObj.appName));
-
- connObj.lastAccess = connObj.stime;
-
- SConnObj *pConn = taosCachePut(tsMnodeConnCache, &connId, sizeof(int32_t), &connObj, sizeof(connObj), CONN_KEEP_TIME * 1000);
-
- mDebug("connId:%d, is created, user:%s ip:%s:%u", connId, user, taosIpStr(ip), port);
- return pConn;
-}
-
-void mnodeReleaseConn(SConnObj *pConn) {
- if (pConn == NULL) return;
- taosCacheRelease(tsMnodeConnCache, (void **)&pConn, false);
-}
-
-SConnObj *mnodeAccquireConn(int32_t connId, char *user, uint32_t ip, uint16_t port) {
- SConnObj *pConn = taosCacheAcquireByKey(tsMnodeConnCache, &connId, sizeof(int32_t));
- if (pConn == NULL) {
- mDebug("connId:%d, is already destroyed, user:%s ip:%s:%u", connId, user, taosIpStr(ip), port);
- return NULL;
- }
-
- if (/* pConn->ip != ip || */ pConn->port != port /* || strcmp(pConn->user, user) != 0 */) {
- mDebug("connId:%d, incoming conn user:%s ip:%s:%u, not match exist conn user:%s ip:%s:%u", connId, user,
- taosIpStr(ip), port, pConn->user, taosIpStr(pConn->ip), pConn->port);
- pConn->port = port;
- //taosCacheRelease(tsMnodeConnCache, (void **)&pConn, false);
- //return NULL;
- }
-
- // mDebug("connId:%d, is incoming, user:%s ip:%s:%u", connId, pConn->user, taosIpStr(pConn->ip), pConn->port);
- pConn->lastAccess = CONN_KEEP_TIME * 1000 + (uint64_t)taosGetTimestampMs();
- return pConn;
-}
-
-static void mnodeFreeConn(void *data) {
- SConnObj *pConn = data;
- tfree(pConn->pQueries);
- tfree(pConn->pStreams);
-
- mDebug("connId:%d, is destroyed", pConn->connId);
-}
-
-static void *mnodeGetNextConn(void *pIter, SConnObj **pConn) {
- *pConn = NULL;
-
- pIter = taosHashIterate(tsMnodeConnCache->pHashTable, pIter);
- if (pIter == NULL) return NULL;
-
- SCacheDataNode **pNode = pIter;
- if (pNode == NULL || *pNode == NULL) {
- taosHashCancelIterate(tsMnodeConnCache->pHashTable, pIter);
- return NULL;
- }
-
- *pConn = (SConnObj*)((*pNode)->data);
- return pIter;
-}
-
-static void mnodeCancelGetNextConn(void *pIter) {
- taosHashCancelIterate(tsMnodeConnCache->pHashTable, pIter);
-}
-
-static int32_t mnodeGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) return 0;
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "connId");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "user");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- // app name
- pShow->bytes[cols] = TSDB_APPNAME_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "program");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- // app pid
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "pid");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "ip:port");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "login_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "last_access");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = taosHashGetSize(tsMnodeConnCache->pHashTable);
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
- return 0;
-}
-
-static int32_t mnodeRetrieveConns(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- SConnObj *pConnObj = NULL;
- int32_t cols = 0;
- char * pWrite;
- char ipStr[TSDB_IPv4ADDR_LEN + 6];
-
- while (numOfRows < rows) {
- pShow->pIter = mnodeGetNextConn(pShow->pIter, &pConnObj);
- if (pConnObj == NULL) break;
-
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *) pWrite = pConnObj->connId;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pConnObj->user, pShow->bytes[cols]);
- cols++;
-
- // app name
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pConnObj->appName, pShow->bytes[cols]);
- cols++;
-
- // app pid
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t*)pWrite = pConnObj->pid;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- snprintf(ipStr, sizeof(ipStr), "%s:%u", taosIpStr(pConnObj->ip), pConnObj->port);
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, ipStr, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = pConnObj->stime;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- if (pConnObj->lastAccess < pConnObj->stime) pConnObj->lastAccess = pConnObj->stime;
- *(int64_t *)pWrite = pConnObj->lastAccess;
- cols++;
-
- numOfRows++;
- }
-
- pShow->numOfReads += numOfRows;
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-
- return numOfRows;
-}
-
-// not thread safe, need optimized
-int32_t mnodeSaveQueryStreamList(SConnObj *pConn, SHeartBeatMsg *pHBMsg) {
- pConn->numOfQueries = 0;
- pConn->numOfStreams = 0;
- int32_t numOfQueries = htonl(pHBMsg->numOfQueries);
- int32_t numOfStreams = htonl(pHBMsg->numOfStreams);
-
- if (numOfQueries > 0) {
- if (pConn->pQueries == NULL) {
- pConn->pQueries = calloc(sizeof(SQueryDesc), QUERY_STREAM_SAVE_SIZE);
- }
-
- pConn->numOfQueries = MIN(QUERY_STREAM_SAVE_SIZE, numOfQueries);
-
- int32_t saveSize = pConn->numOfQueries * sizeof(SQueryDesc);
- if (saveSize > 0 && pConn->pQueries != NULL) {
- memcpy(pConn->pQueries, pHBMsg->pData, saveSize);
- }
- }
-
- if (numOfStreams > 0) {
- if (pConn->pStreams == NULL) {
- pConn->pStreams = calloc(sizeof(SStreamDesc), QUERY_STREAM_SAVE_SIZE);
- }
-
- pConn->numOfStreams = MIN(QUERY_STREAM_SAVE_SIZE, numOfStreams);
-
- int32_t saveSize = pConn->numOfStreams * sizeof(SStreamDesc);
- if (saveSize > 0 && pConn->pStreams != NULL) {
- memcpy(pConn->pStreams, pHBMsg->pData + numOfQueries * sizeof(SQueryDesc), saveSize);
- }
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) return 0;
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = QUERY_ID_SIZE + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "query_id");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "user");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "ip:port");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 24;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "qid");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "created_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_BIGINT;
- strcpy(pSchema[cols].name, "time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = QUERY_OBJ_ID_SIZE + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "sql_obj_id");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "pid");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_EP_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "ep");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 1;
- pSchema[cols].type = TSDB_DATA_TYPE_BOOL;
- strcpy(pSchema[cols].name, "stable_query");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "sub_queries");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_SHOW_SUBQUERY_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "sub_query_info");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "sql");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = 1000000;
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
- return 0;
-}
-
-static int32_t mnodeRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- SConnObj *pConnObj = NULL;
- int32_t cols = 0;
- char * pWrite;
- void * pIter;
- char str[TSDB_IPv4ADDR_LEN + 6] = {0};
-
- while (numOfRows < rows) {
- pIter = mnodeGetNextConn(pShow->pIter, &pConnObj);
- if (pConnObj == NULL) {
- pShow->pIter = pIter;
- break;
- }
-
- if (numOfRows + pConnObj->numOfQueries >= rows) {
- mnodeCancelGetNextConn(pIter);
- break;
- }
-
- pShow->pIter = pIter;
- for (int32_t i = 0; i < pConnObj->numOfQueries; ++i) {
- SQueryDesc *pDesc = pConnObj->pQueries + i;
- cols = 0;
-
- snprintf(str, QUERY_ID_SIZE + 1, "%u:%u", pConnObj->connId, htonl(pDesc->queryId));
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, str, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pConnObj->user, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- snprintf(str, tListLen(str), "%s:%u", taosIpStr(pConnObj->ip), pConnObj->port);
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, str, pShow->bytes[cols]);
- cols++;
-
- char handleBuf[24] = {0};
- snprintf(handleBuf, tListLen(handleBuf), "%"PRIu64, htobe64(pDesc->qId));
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, handleBuf, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = htobe64(pDesc->stime);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = htobe64(pDesc->useconds);
- cols++;
-
- snprintf(str, tListLen(str), "0x%" PRIx64, htobe64(pDesc->sqlObjId));
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, str, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = htonl(pDesc->pid);
- cols++;
-
- char epBuf[TSDB_EP_LEN + 1] = {0};
- snprintf(epBuf, tListLen(epBuf), "%s:%u", pDesc->fqdn, pConnObj->port);
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, epBuf, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(bool *)pWrite = pDesc->stableQuery;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = htonl(pDesc->numOfSub);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDesc->subSqlInfo, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDesc->sql, pShow->bytes[cols]);
- cols++;
-
- numOfRows++;
- }
- }
-
- pShow->numOfReads += numOfRows;
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- return numOfRows;
-}
-
-static int32_t mnodeGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) return 0;
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = QUERY_ID_SIZE + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "streamId");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "user");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "dest table");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "ip:port");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "created time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "exec time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_BIGINT;
- strcpy(pSchema[cols].name, "time(us)");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "sql");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "cycles");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = 1000000;
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
- return 0;
-}
-
-static int32_t mnodeRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- SConnObj *pConnObj = NULL;
- int32_t cols = 0;
- char * pWrite;
- void * pIter;
- char ipStr[TSDB_IPv4ADDR_LEN + 6];
-
- while (numOfRows < rows) {
- pIter = mnodeGetNextConn(pShow->pIter, &pConnObj);
- if (pConnObj == NULL) {
- pShow->pIter = pIter;
- break;
- }
-
- if (numOfRows + pConnObj->numOfStreams >= rows) {
- mnodeCancelGetNextConn(pIter);
- break;
- }
-
- pShow->pIter = pIter;
- for (int32_t i = 0; i < pConnObj->numOfStreams; ++i) {
- SStreamDesc *pDesc = pConnObj->pStreams + i;
- cols = 0;
-
- snprintf(ipStr, QUERY_ID_SIZE + 1, "%u:%u", pConnObj->connId, htonl(pDesc->streamId));
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, ipStr, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pConnObj->user, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDesc->dstTable, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- snprintf(ipStr, sizeof(ipStr), "%s:%u", taosIpStr(pConnObj->ip), pConnObj->port);
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, ipStr, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = htobe64(pDesc->ctime);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = htobe64(pDesc->stime);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = htobe64(pDesc->useconds);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDesc->sql, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = (int32_t)htobe64(pDesc->num);
- cols++;
-
- numOfRows++;
- }
- }
-
- pShow->numOfReads += numOfRows;
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- return numOfRows;
-}
-
-static int32_t mnodeProcessKillQueryMsg(SMnodeMsg *pMsg) {
- SUserObj *pUser = pMsg->pUser;
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-
- SKillQueryMsg *pKill = pMsg->rpcMsg.pCont;
- mInfo("kill query msg is received, queryId:%s", pKill->queryId);
-
- const char delim = ':';
- char* connIdStr = strtok(pKill->queryId, &delim);
- char* queryIdStr = strtok(NULL, &delim);
-
- if (queryIdStr == NULL || connIdStr == NULL) {
- mInfo("failed to kill query, queryId:%s", pKill->queryId);
- return TSDB_CODE_MND_INVALID_QUERY_ID;
- }
-
- int32_t queryId = (int32_t)strtol(queryIdStr, NULL, 10);
-
- int32_t connId = atoi(connIdStr);
- SConnObj *pConn = taosCacheAcquireByKey(tsMnodeConnCache, &connId, sizeof(int32_t));
- if (pConn == NULL) {
- mError("connId:%s, failed to kill queryId:%d, conn not exist", connIdStr, queryId);
- return TSDB_CODE_MND_INVALID_CONN_ID;
- } else {
- mInfo("connId:%s, queryId:%d is killed by user:%s", connIdStr, queryId, pUser->user);
- pConn->queryId = queryId;
- taosCacheRelease(tsMnodeConnCache, (void **)&pConn, false);
- return TSDB_CODE_SUCCESS;
- }
-}
-
-static int32_t mnodeProcessKillStreamMsg(SMnodeMsg *pMsg) {
- SUserObj *pUser = pMsg->pUser;
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-
- SKillQueryMsg *pKill = pMsg->rpcMsg.pCont;
- mInfo("kill stream msg is received, streamId:%s", pKill->queryId);
-
- const char delim = ':';
- char* connIdStr = strtok(pKill->queryId, &delim);
- char* streamIdStr = strtok(NULL, &delim);
-
- if (streamIdStr == NULL || connIdStr == NULL) {
- mInfo("failed to kill stream, streamId:%s", pKill->queryId);
- return TSDB_CODE_MND_INVALID_STREAM_ID;
- }
-
- int32_t streamId = (int32_t)strtol(streamIdStr, NULL, 10);
- int32_t connId = atoi(connIdStr);
-
- SConnObj *pConn = taosCacheAcquireByKey(tsMnodeConnCache, &connId, sizeof(int32_t));
- if (pConn == NULL) {
- mError("connId:%s, failed to kill streamId:%d, conn not exist", connIdStr, streamId);
- return TSDB_CODE_MND_INVALID_CONN_ID;
- } else {
- mInfo("connId:%s, streamId:%d is killed by user:%s", connIdStr, streamId, pUser->user);
- pConn->streamId = streamId;
- taosCacheRelease(tsMnodeConnCache, (void **)&pConn, false);
- return TSDB_CODE_SUCCESS;
- }
-}
-
-static int32_t mnodeProcessKillConnectionMsg(SMnodeMsg *pMsg) {
- SUserObj *pUser = pMsg->pUser;
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) != 0) return TSDB_CODE_MND_NO_RIGHTS;
-
- SKillConnMsg *pKill = pMsg->rpcMsg.pCont;
- int32_t connId = atoi(pKill->queryId);
- SConnObj *pConn = taosCacheAcquireByKey(tsMnodeConnCache, &connId, sizeof(int32_t));
- if (pConn == NULL) {
- mError("connId:%s, failed to kill, conn not exist", pKill->queryId);
- return TSDB_CODE_MND_INVALID_CONN_ID;
- } else {
- mInfo("connId:%s, is killed by user:%s", pKill->queryId, pUser->user);
- pConn->killed = 1;
- taosCacheRelease(tsMnodeConnCache, (void**)&pConn, false);
- return TSDB_CODE_SUCCESS;
- }
-}
diff --git a/src/mnode/src/mnodeRead.c b/src/mnode/src/mnodeRead.c
deleted file mode 100644
index dadd8155d8648244dba762afec63bfc6f2ac3721..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeRead.c
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosdef.h"
-#include "tsched.h"
-#include "tbn.h"
-#include "tgrant.h"
-#include "ttimer.h"
-#include "tglobal.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeDnode.h"
-#include "mnodeMnode.h"
-#include "mnodeDb.h"
-#include "mnodeSdb.h"
-#include "mnodeVgroup.h"
-#include "mnodeUser.h"
-#include "mnodeTable.h"
-#include "mnodeShow.h"
-
-static int32_t (*tsMnodeProcessReadMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *);
-
-void mnodeAddReadMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *pMsg)) {
- tsMnodeProcessReadMsgFp[msgType] = fp;
-}
-
-int32_t mnodeProcessRead(SMnodeMsg *pMsg) {
- if (pMsg->rpcMsg.pCont == NULL) {
- mError("msg:%p, app:%p type:%s in mread queue, content is null", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
- return TSDB_CODE_MND_INVALID_MSG_LEN;
- }
-
- if (!sdbIsMaster()) {
- SMnodeRsp *rpcRsp = &pMsg->rpcRsp;
- SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
- if (!epSet) {
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
- mnodeGetMnodeEpSetForShell(epSet, true);
- rpcRsp->rsp = epSet;
- rpcRsp->len = sizeof(SRpcEpSet);
-
- mDebug("msg:%p, app:%p type:%s in mread queue is redirected, numOfEps:%d inUse:%d", pMsg, pMsg->rpcMsg.ahandle,
- taosMsg[pMsg->rpcMsg.msgType], epSet->numOfEps, epSet->inUse);
-
- return TSDB_CODE_RPC_REDIRECT;
- }
-
- if (tsMnodeProcessReadMsgFp[pMsg->rpcMsg.msgType] == NULL) {
- mError("msg:%p, app:%p type:%s in mread queue, not processed", pMsg, pMsg->rpcMsg.ahandle,
- taosMsg[pMsg->rpcMsg.msgType]);
- return TSDB_CODE_MND_MSG_NOT_PROCESSED;
- }
-
- int32_t code = mnodeInitMsg(pMsg);
- if (code != TSDB_CODE_SUCCESS) {
- mError("msg:%p, app:%p type:%s in mread queue, not processed reason:%s", pMsg, pMsg->rpcMsg.ahandle,
- taosMsg[pMsg->rpcMsg.msgType], tstrerror(code));
- return code;
- }
-
- return (*tsMnodeProcessReadMsgFp[pMsg->rpcMsg.msgType])(pMsg);
-}
diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c
deleted file mode 100644
index 1e3057f27021e8874b96c0116dd0319fcd999da7..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeSdb.c
+++ /dev/null
@@ -1,1207 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "hash.h"
-#include "tutil.h"
-#include "tref.h"
-#include "tbn.h"
-#include "tfs.h"
-#include "tqueue.h"
-#include "twal.h"
-#include "tsync.h"
-#include "ttimer.h"
-#include "tglobal.h"
-#include "dnode.h"
-#include "mnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeMnode.h"
-#include "mnodeDnode.h"
-#include "mnodeCluster.h"
-#include "mnodeSdb.h"
-
-#define SDB_TABLE_LEN 12
-#define MAX_QUEUED_MSG_NUM 100000
-
-typedef enum {
- SDB_ACTION_INSERT = 0,
- SDB_ACTION_DELETE = 1,
- SDB_ACTION_UPDATE = 2
-} ESdbAction;
-
-typedef enum {
- SDB_STATUS_OFFLINE = 0,
- SDB_STATUS_SERVING = 1,
- SDB_STATUS_CLOSING = 2
-} ESdbStatus;
-
-char *actStr[] = {
- "insert",
- "delete",
- "update",
- "invalid"
-};
-
-typedef struct SSdbTable {
- char name[SDB_TABLE_LEN];
- ESdbTable id;
- ESdbKey keyType;
- int32_t hashSessions;
- int32_t maxRowSize;
- int32_t refCountPos;
- int32_t autoIndex;
- int64_t numOfRows;
- void * iHandle;
- int32_t (*fpInsert)(SSdbRow *pRow);
- int32_t (*fpDelete)(SSdbRow *pRow);
- int32_t (*fpUpdate)(SSdbRow *pRow);
- int32_t (*fpDecode)(SSdbRow *pRow);
- int32_t (*fpEncode)(SSdbRow *pRow);
- int32_t (*fpDestroy)(SSdbRow *pRow);
- int32_t (*fpRestored)();
- pthread_mutex_t mutex;
-} SSdbTable;
-
-typedef struct {
- ESyncRole role;
- ESdbStatus status;
- uint64_t version;
- int64_t sync;
- void * wal;
- SSyncCfg cfg;
- int32_t queuedMsg;
- int32_t numOfTables;
- SSdbTable *tableList[SDB_TABLE_MAX];
- pthread_mutex_t mutex;
-} SSdbMgmt;
-
-typedef struct {
- pthread_t thread;
- int32_t workerId;
-} SSdbWorker;
-
-typedef struct {
- int32_t num;
- SSdbWorker *worker;
-} SSdbWorkerPool;
-
-int32_t tsSdbRid;
-extern void * tsMnodeTmr;
-static void * tsSdbTmr;
-static SSdbMgmt tsSdbMgmt = {0};
-static taos_qset tsSdbWQset;
-static taos_qall tsSdbWQall;
-static taos_queue tsSdbWQueue;
-static SSdbWorkerPool tsSdbPool;
-
-static int32_t sdbProcessWrite(void *pRow, void *pHead, int32_t qtype, void *unused);
-static int32_t sdbWriteFwdToQueue(int32_t vgId, void *pHead, int32_t qtype, void *rparam);
-static int32_t sdbWriteRowToQueue(SSdbRow *pRow, int32_t action);
-static void sdbFreeFromQueue(SSdbRow *pRow);
-static void * sdbWorkerFp(void *pWorker);
-static int32_t sdbInitWorker();
-static void sdbCleanupWorker();
-static int32_t sdbAllocQueue();
-static void sdbFreeQueue();
-static int32_t sdbInsertHash(SSdbTable *pTable, SSdbRow *pRow);
-static int32_t sdbUpdateHash(SSdbTable *pTable, SSdbRow *pRow);
-static int32_t sdbDeleteHash(SSdbTable *pTable, SSdbRow *pRow);
-static void sdbCloseTableObj(void *handle);
-
-int32_t sdbGetId(void *pTable) {
- return ((SSdbTable *)pTable)->autoIndex;
-}
-
-int64_t sdbGetNumOfRows(void *pTable) {
- return ((SSdbTable *)pTable)->numOfRows;
-}
-
-uint64_t sdbGetVersion() {
- return tsSdbMgmt.version;
-}
-
-bool sdbIsMaster() {
- return tsSdbMgmt.role == TAOS_SYNC_ROLE_MASTER;
-}
-
-bool sdbIsServing() {
- return tsSdbMgmt.status == SDB_STATUS_SERVING;
-}
-
-static void *sdbGetObjKey(SSdbTable *pTable, void *key) {
- if (pTable->keyType == SDB_KEY_VAR_STRING) {
- return *(char **)key;
- }
-
- return key;
-}
-
-static char *sdbGetKeyStr(SSdbTable *pTable, void *key) {
- static char str[16];
- switch (pTable->keyType) {
- case SDB_KEY_STRING:
- case SDB_KEY_VAR_STRING:
- return (char *)key;
- case SDB_KEY_INT:
- case SDB_KEY_AUTO:
- sprintf(str, "%d", *(int32_t *)key);
- return str;
- default:
- return "invalid";
- }
-}
-
-static char *sdbGetRowStr(SSdbTable *pTable, void *key) {
- return sdbGetKeyStr(pTable, sdbGetObjKey(pTable, key));
-}
-
-static void *sdbGetTableFromId(int32_t tableId) {
- return tsSdbMgmt.tableList[tableId];
-}
-
-static int32_t sdbInitWal() {
- SWalCfg walCfg = {.vgId = 1, .walLevel = TAOS_WAL_FSYNC, .keep = TAOS_WAL_KEEP, .fsyncPeriod = 0};
- char temp[TSDB_FILENAME_LEN] = {0};
- sprintf(temp, "%s/wal", tsMnodeDir);
- tsSdbMgmt.wal = walOpen(temp, &walCfg);
- if (tsSdbMgmt.wal == NULL) {
- sdbError("vgId:1, failed to open wal in %s", tsMnodeDir);
- return -1;
- }
-
- sdbInfo("vgId:1, open sdb wal for restore");
- int32_t code = walRestore(tsSdbMgmt.wal, NULL, sdbProcessWrite);
- if (code != TSDB_CODE_SUCCESS) {
- sdbError("vgId:1, failed to open wal for restore since %s", tstrerror(code));
- return -1;
- }
-
- sdbInfo("vgId:1, sdb wal load success");
- return 0;
-}
-
-static void sdbRestoreTables() {
- int32_t totalRows = 0;
- int32_t numOfTables = 0;
-
- sdbInfo("vgId:1, sdb start to check for integrity");
-
- for (int32_t tableId = 0; tableId < SDB_TABLE_MAX; ++tableId) {
- SSdbTable *pTable = sdbGetTableFromId(tableId);
- if (pTable == NULL) continue;
- if (pTable->fpRestored) {
- (*pTable->fpRestored)();
- }
-
- totalRows += (int32_t)pTable->numOfRows;
- numOfTables++;
- sdbInfo("vgId:1, sdb:%s is checked, rows:%" PRId64, pTable->name, pTable->numOfRows);
- }
-
- sdbInfo("vgId:1, sdb is restored, mver:%" PRIu64 " rows:%d tables:%d", tsSdbMgmt.version, totalRows, numOfTables);
-}
-
-void sdbUpdateMnodeRoles() {
- if (tsSdbMgmt.sync <= 0) return;
-
- SNodesRole roles = {0};
- if (syncGetNodesRole(tsSdbMgmt.sync, &roles) != 0) return;
-
- sdbInfo("vgId:1, update mnodes role, replica:%d", tsSdbMgmt.cfg.replica);
- for (int32_t i = 0; i < tsSdbMgmt.cfg.replica; ++i) {
- SMnodeObj *pMnode = mnodeGetMnode(roles.nodeId[i]);
- if (pMnode != NULL) {
- if (pMnode->role != roles.role[i]) {
- pMnode->roleTime = taosGetTimestampMs();
- bnNotify();
- }
-
- pMnode->role = roles.role[i];
- sdbInfo("vgId:1, mnode:%d, role:%s", pMnode->mnodeId, syncRole[pMnode->role]);
- if (pMnode->mnodeId == dnodeGetDnodeId()) tsSdbMgmt.role = pMnode->role;
- mnodeDecMnodeRef(pMnode);
- } else {
- sdbDebug("vgId:1, mnode:%d not found", roles.nodeId[i]);
- }
- }
-
- mnodeUpdateClusterId();
- mnodeUpdateMnodeEpSet(NULL);
-}
-
-static int32_t sdbGetWalInfo(int32_t vgId, char *fileName, int64_t *fileId) {
- return walGetWalFile(tsSdbMgmt.wal, fileName, fileId);
-}
-
-static void sdbNotifyRole(int32_t vgId, int8_t role) {
- sdbInfo("vgId:1, mnode role changed from %s to %s", syncRole[tsSdbMgmt.role], syncRole[role]);
-
- if (role == TAOS_SYNC_ROLE_MASTER && tsSdbMgmt.role != TAOS_SYNC_ROLE_MASTER) {
- bnReset();
- }
- tsSdbMgmt.role = role;
-
- sdbUpdateMnodeRoles();
-}
-
-static void sdbStartFileSync(int32_t vgId) {}
-
-static void sdbStopFileSync(int32_t vgId, uint64_t fversion) {}
-
-static void sdbNotifyFlowCtrl(int32_t vgId, int32_t level) {}
-
-static int32_t sdbGetSyncVersion(int32_t vgId, uint64_t *fver, uint64_t *vver) {
- *fver = 0;
- *vver = 0;
- return 0;
-}
-
-// failed to forward, need revert insert
-static void sdbHandleFailedConfirm(SSdbRow *pRow) {
- SWalHead *pHead = &pRow->pHead;
- int32_t action = pHead->msgType % 10;
-
- sdbError("vgId:1, row:%p:%s hver:%" PRIu64 " action:%s, failed to foward since %s", pRow->pObj,
- sdbGetKeyStr(pRow->pTable, pHead->cont), pHead->version, actStr[action], tstrerror(pRow->code));
-
- // It's better to create a table in two stages, create it first and then set it success
- if (action == SDB_ACTION_INSERT) {
- SSdbRow row = {.type = SDB_OPER_GLOBAL, .pTable = pRow->pTable, .pObj = pRow->pObj};
- sdbDeleteRow(&row);
- }
-}
-
-FORCE_INLINE
-static void sdbConfirmForward(int32_t vgId, void *wparam, int32_t code) {
- if (wparam == NULL) return;
- SSdbRow *pRow = wparam;
- SMnodeMsg * pMsg = pRow->pMsg;
-
- if (code <= 0) pRow->code = code;
- int32_t count = atomic_add_fetch_32(&pRow->processedCount, 1);
- if (count <= 1) {
- if (pMsg != NULL) sdbTrace("vgId:1, msg:%p waiting for confirm, count:%d code:%x", pMsg, count, code);
- return;
- } else {
- if (pMsg != NULL) sdbTrace("vgId:1, msg:%p is confirmed, code:%x", pMsg, code);
- }
-
- if (pRow->code != TSDB_CODE_SUCCESS) sdbHandleFailedConfirm(pRow);
-
- if (pRow->fpRsp != NULL) {
- pRow->code = (*pRow->fpRsp)(pMsg, pRow->code);
- }
-
- dnodeSendRpcMWriteRsp(pMsg, pRow->code);
- sdbFreeFromQueue(pRow);
-}
-
-static void sdbUpdateSyncTmrFp(void *param, void *tmrId) { sdbUpdateSync(NULL); }
-
-void sdbUpdateAsync() {
- taosTmrReset(sdbUpdateSyncTmrFp, 200, NULL, tsMnodeTmr, &tsSdbTmr);
-}
-
-static int node_cmp(const void *l, const void *r) {
- return ((SNodeInfo *)l)->nodeId - ((SNodeInfo *)r)->nodeId;
-}
-
-int32_t sdbUpdateSync(void *pMnodes) {
- SMInfos *pMinfos = pMnodes;
- if (!mnodeIsRunning()) {
- mDebug("vgId:1, mnode not start yet, update sync config later");
- return TSDB_CODE_MND_MNODE_IS_RUNNING;
- }
-
- mDebug("vgId:1, update sync config, pMnodes:%p", pMnodes);
-
- SSyncCfg syncCfg = {0};
- int32_t index = 0;
-
- if (pMinfos == NULL) {
- mDebug("vgId:1, mInfos not input, use mInfos in sdb, numOfMnodes:%d", syncCfg.replica);
-
- void *pIter = NULL;
- while (1) {
- SMnodeObj *pMnode = NULL;
- pIter = mnodeGetNextMnode(pIter, &pMnode);
- if (pMnode == NULL) break;
-
- syncCfg.nodeInfo[index].nodeId = pMnode->mnodeId;
-
- SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId);
- if (pDnode != NULL) {
- syncCfg.nodeInfo[index].nodePort = pDnode->dnodePort + TSDB_PORT_SYNC;
- tstrncpy(syncCfg.nodeInfo[index].nodeFqdn, pDnode->dnodeFqdn, TSDB_FQDN_LEN);
- index++;
- }
-
- mnodeDecDnodeRef(pDnode);
- mnodeDecMnodeRef(pMnode);
- }
- syncCfg.replica = index;
- } else {
- mDebug("vgId:1, mInfos input, numOfMnodes:%d", pMinfos->mnodeNum);
-
- for (index = 0; index < pMinfos->mnodeNum; ++index) {
- SMInfo *node = &pMinfos->mnodeInfos[index];
- syncCfg.nodeInfo[index].nodeId = node->mnodeId;
- taosGetFqdnPortFromEp(node->mnodeEp, syncCfg.nodeInfo[index].nodeFqdn, &syncCfg.nodeInfo[index].nodePort);
- syncCfg.nodeInfo[index].nodePort += TSDB_PORT_SYNC;
- }
- syncCfg.replica = index;
- mnodeUpdateMnodeEpSet(pMnodes);
- }
-
- syncCfg.quorum = (syncCfg.replica == 1) ? 1 : 2;
-
- bool hasThisDnode = false;
- for (int32_t i = 0; i < syncCfg.replica; ++i) {
- if (syncCfg.nodeInfo[i].nodeId == dnodeGetDnodeId()) {
- hasThisDnode = true;
- break;
- }
- }
-
- if (!hasThisDnode) {
- sdbDebug("vgId:1, update sync config, this dnode not exist");
- return TSDB_CODE_MND_FAILED_TO_CONFIG_SYNC;
- }
-
- if (memcmp(&syncCfg, &tsSdbMgmt.cfg, sizeof(SSyncCfg)) == 0) {
- sdbDebug("vgId:1, update sync config, info not changed");
- return TSDB_CODE_SUCCESS;
- }
-
- qsort(syncCfg.nodeInfo, syncCfg.replica, sizeof(syncCfg.nodeInfo[0]), node_cmp);
-
- sdbInfo("vgId:1, work as mnode, replica:%d", syncCfg.replica);
- for (int32_t i = 0; i < syncCfg.replica; ++i) {
- sdbInfo("vgId:1, mnode:%d, %s:%d", syncCfg.nodeInfo[i].nodeId, syncCfg.nodeInfo[i].nodeFqdn,
- syncCfg.nodeInfo[i].nodePort);
- }
-
- SSyncInfo syncInfo = {0};
- syncInfo.vgId = 1;
- syncInfo.version = sdbGetVersion();
- syncInfo.syncCfg = syncCfg;
- sprintf(syncInfo.path, "%s", tsMnodeDir);
- syncInfo.getWalInfoFp = sdbGetWalInfo;
- syncInfo.writeToCacheFp = sdbWriteFwdToQueue;
- syncInfo.confirmForward = sdbConfirmForward;
- syncInfo.notifyRoleFp = sdbNotifyRole;
- syncInfo.startSyncFileFp = sdbStartFileSync;
- syncInfo.stopSyncFileFp = sdbStopFileSync;
- syncInfo.notifyFlowCtrlFp = sdbNotifyFlowCtrl;
- syncInfo.getVersionFp = sdbGetSyncVersion;
- tsSdbMgmt.cfg = syncCfg;
-
- if (tsSdbMgmt.sync) {
- int32_t code = syncReconfig(tsSdbMgmt.sync, &syncCfg);
- if (code != 0) return code;
- } else {
- tsSdbMgmt.sync = syncStart(&syncInfo);
- if (tsSdbMgmt.sync <= 0) return TSDB_CODE_MND_FAILED_TO_START_SYNC;
- }
-
- sdbUpdateMnodeRoles();
- return TSDB_CODE_SUCCESS;
-}
-
-int32_t sdbInitRef() {
- tsSdbRid = taosOpenRef(10, sdbCloseTableObj);
- if (tsSdbRid <= 0) {
- sdbError("failed to init sdb ref");
- return -1;
- }
- return 0;
-}
-
-void sdbCleanUpRef() { taosCloseRef(tsSdbRid); }
-
-int32_t sdbInit() {
- pthread_mutex_init(&tsSdbMgmt.mutex, NULL);
-
- if (sdbInitWorker() != 0) {
- return -1;
- }
-
- if (sdbInitWal() != 0) {
- return -1;
- }
-
- sdbRestoreTables();
-
- if (mnodeGetMnodesNum() == 1) {
- tsSdbMgmt.role = TAOS_SYNC_ROLE_MASTER;
- }
-
- tsSdbMgmt.status = SDB_STATUS_SERVING;
-
- if (tsCompactMnodeWal) {
- mnodeCompactWal();
- exit(EXIT_SUCCESS);
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-void sdbCleanUp() {
- if (tsSdbMgmt.status != SDB_STATUS_SERVING) return;
-
- tsSdbMgmt.status = SDB_STATUS_CLOSING;
-
- sdbCleanupWorker();
- sdbDebug("vgId:1, sdb will be closed, mver:%" PRIu64, tsSdbMgmt.version);
-
- if (tsSdbMgmt.sync) {
- syncStop(tsSdbMgmt.sync);
- tsSdbMgmt.sync = -1;
- }
-
- if (tsSdbMgmt.wal) {
- walClose(tsSdbMgmt.wal);
- tsSdbMgmt.wal = NULL;
- }
-
- pthread_mutex_destroy(&tsSdbMgmt.mutex);
-}
-
-void sdbIncRef(void *tparam, void *pRow) {
- if (pRow == NULL || tparam == NULL) return;
-
- SSdbTable *pTable = tparam;
- int32_t * pRefCount = (int32_t *)((char *)pRow + pTable->refCountPos);
- int32_t refCount = atomic_add_fetch_32(pRefCount, 1);
- sdbTrace("vgId:1, sdb:%s, inc ref to row:%p:%s:%d", pTable->name, pRow, sdbGetRowStr(pTable, pRow), refCount);
-}
-
-void sdbDecRef(void *tparam, void *pRow) {
- if (pRow == NULL || tparam == NULL) return;
-
- SSdbTable *pTable = tparam;
- int32_t * pRefCount = (int32_t *)((char *)pRow + pTable->refCountPos);
- int32_t refCount = atomic_sub_fetch_32(pRefCount, 1);
- sdbTrace("vgId:1, sdb:%s, dec ref to row:%p:%s:%d", pTable->name, pRow, sdbGetRowStr(pTable, pRow), refCount);
-
- int32_t *updateEnd = (int32_t *)((char *)pRow + pTable->refCountPos - 4);
- if (refCount <= 0 && *updateEnd) {
- sdbTrace("vgId:1, sdb:%s, row:%p:%s:%d destroyed", pTable->name, pRow, sdbGetRowStr(pTable, pRow), refCount);
- SSdbRow row = {.pObj = pRow};
- (*pTable->fpDestroy)(&row);
- }
-}
-
-static void *sdbGetRowMeta(SSdbTable *pTable, void *key) {
- if (pTable == NULL) return NULL;
-
- int32_t keySize = sizeof(int32_t);
- if (pTable->keyType == SDB_KEY_STRING || pTable->keyType == SDB_KEY_VAR_STRING) {
- keySize = (int32_t)strlen((char *)key);
- }
-
- void **ppRow = (void **)taosHashGet(pTable->iHandle, key, keySize);
- if (ppRow != NULL) return *ppRow;
-
- return NULL;
-}
-
-static void *sdbGetRowMetaFromObj(SSdbTable *pTable, void *key) {
- return sdbGetRowMeta(pTable, sdbGetObjKey(pTable, key));
-}
-
-void *sdbGetRow(void *tparam, void *key) {
- SSdbTable *pTable = tparam;
-
- pthread_mutex_lock(&pTable->mutex);
- void *pRow = sdbGetRowMeta(pTable, key);
- if (pRow) sdbIncRef(pTable, pRow);
- pthread_mutex_unlock(&pTable->mutex);
-
- return pRow;
-}
-
-static void *sdbGetRowFromObj(SSdbTable *pTable, void *key) {
- return sdbGetRow(pTable, sdbGetObjKey(pTable, key));
-}
-
-static int32_t sdbInsertHash(SSdbTable *pTable, SSdbRow *pRow) {
- void * key = sdbGetObjKey(pTable, pRow->pObj);
- int32_t keySize = sizeof(int32_t);
-
- if (pTable->keyType == SDB_KEY_STRING || pTable->keyType == SDB_KEY_VAR_STRING) {
- keySize = (int32_t)strlen((char *)key);
- }
-
- pthread_mutex_lock(&pTable->mutex);
- taosHashPut(pTable->iHandle, key, keySize, &pRow->pObj, sizeof(int64_t));
- pthread_mutex_unlock(&pTable->mutex);
-
- sdbIncRef(pTable, pRow->pObj);
- atomic_add_fetch_32(&pTable->numOfRows, 1);
-
- if (pTable->keyType == SDB_KEY_AUTO) {
- pTable->autoIndex = MAX(pTable->autoIndex, *((uint32_t *)pRow->pObj));
- } else {
- atomic_add_fetch_32(&pTable->autoIndex, 1);
- }
-
- sdbTrace("vgId:1, sdb:%s, insert key:%s to hash, rowSize:%d rows:%" PRId64 ", msg:%p", pTable->name,
- sdbGetRowStr(pTable, pRow->pObj), pRow->rowSize, pTable->numOfRows, pRow->pMsg);
-
- int32_t code = (*pTable->fpInsert)(pRow);
- if (code != TSDB_CODE_SUCCESS) {
- sdbError("vgId:1, sdb:%s, failed to perform insert action for key:%s, remove it", pTable->name,
- sdbGetRowStr(pTable, pRow->pObj));
- sdbDeleteHash(pTable, pRow);
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t sdbDeleteHash(SSdbTable *pTable, SSdbRow *pRow) {
- int32_t *updateEnd = (int32_t *)((char*)pRow->pObj + pTable->refCountPos - 4);
- bool set = atomic_val_compare_exchange_32(updateEnd, 0, 1) == 0;
- if (!set) {
- sdbError("vgId:1, sdb:%s, failed to delete key:%s from hash, for it already removed", pTable->name,
- sdbGetRowStr(pTable, pRow->pObj));
- return TSDB_CODE_MND_SDB_OBJ_NOT_THERE;
- }
-
- (*pTable->fpDelete)(pRow);
-
- void * key = sdbGetObjKey(pTable, pRow->pObj);
- int32_t keySize = sizeof(int32_t);
- if (pTable->keyType == SDB_KEY_STRING || pTable->keyType == SDB_KEY_VAR_STRING) {
- keySize = (int32_t)strlen((char *)key);
- }
-
- pthread_mutex_lock(&pTable->mutex);
- taosHashRemove(pTable->iHandle, key, keySize);
- pthread_mutex_unlock(&pTable->mutex);
-
- atomic_sub_fetch_32(&pTable->numOfRows, 1);
-
- sdbTrace("vgId:1, sdb:%s, delete key:%s from hash, numOfRows:%" PRId64 ", msg:%p", pTable->name,
- sdbGetRowStr(pTable, pRow->pObj), pTable->numOfRows, pRow->pMsg);
-
- sdbDecRef(pTable, pRow->pObj);
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t sdbUpdateHash(SSdbTable *pTable, SSdbRow *pRow) {
- sdbTrace("vgId:1, sdb:%s, update key:%s in hash, numOfRows:%" PRId64 ", msg:%p", pTable->name,
- sdbGetRowStr(pTable, pRow->pObj), pTable->numOfRows, pRow->pMsg);
-
- (*pTable->fpUpdate)(pRow);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t sdbPerformInsertAction(SWalHead *pHead, SSdbTable *pTable) {
- SSdbRow row = {.rowSize = pHead->len, .rowData = pHead->cont, .pTable = pTable};
- (*pTable->fpDecode)(&row);
- return sdbInsertHash(pTable, &row);
-}
-
-static int32_t sdbPerformDeleteAction(SWalHead *pHead, SSdbTable *pTable) {
- void *pObj = sdbGetRowMeta(pTable, pHead->cont);
- if (pObj == NULL) {
- sdbDebug("vgId:1, sdb:%s, object:%s not exist in hash, ignore delete action", pTable->name,
- sdbGetKeyStr(pTable, pHead->cont));
- return TSDB_CODE_SUCCESS;
- }
- SSdbRow row = {.pTable = pTable, .pObj = pObj};
- return sdbDeleteHash(pTable, &row);
-}
-
-static int32_t sdbPerformUpdateAction(SWalHead *pHead, SSdbTable *pTable) {
- void *pObj = sdbGetRowMeta(pTable, pHead->cont);
- if (pObj == NULL) {
- sdbDebug("vgId:1, sdb:%s, object:%s not exist in hash, ignore update action", pTable->name,
- sdbGetKeyStr(pTable, pHead->cont));
- return TSDB_CODE_SUCCESS;
- }
- SSdbRow row = {.rowSize = pHead->len, .rowData = pHead->cont, .pTable = pTable};
- (*pTable->fpDecode)(&row);
- return sdbUpdateHash(pTable, &row);
-}
-
-static int32_t sdbProcessWrite(void *wparam, void *hparam, int32_t qtype, void *unused) {
- SSdbRow *pRow = wparam;
- SWalHead *pHead = hparam;
- int32_t tableId = pHead->msgType / 10;
- int32_t action = pHead->msgType % 10;
-
- SSdbTable *pTable = sdbGetTableFromId(tableId);
- assert(pTable != NULL);
-
- if (!mnodeIsRunning() && tsSdbMgmt.version % 100000 == 0) {
- char stepDesc[TSDB_STEP_DESC_LEN] = {0};
- snprintf(stepDesc, TSDB_STEP_DESC_LEN, "%" PRIu64 " rows have been restored", tsSdbMgmt.version);
- dnodeReportStep("mnode-sdb", stepDesc, 0);
- }
-
- pthread_mutex_lock(&tsSdbMgmt.mutex);
-
- if (pHead->version == 0) {
- // assign version
- tsSdbMgmt.version++;
- pHead->version = tsSdbMgmt.version;
- } else {
- // for data from WAL or forward, version may be smaller
- if (pHead->version <= tsSdbMgmt.version) {
- pthread_mutex_unlock(&tsSdbMgmt.mutex);
- sdbDebug("vgId:1, sdb:%s, failed to restore %s key:%s from source(%d), hver:%" PRIu64 " too large, mver:%" PRIu64,
- pTable->name, actStr[action], sdbGetKeyStr(pTable, pHead->cont), qtype, pHead->version, tsSdbMgmt.version);
- return TSDB_CODE_SUCCESS;
- } else if (pHead->version != tsSdbMgmt.version + 1) {
- if (qtype != TAOS_QTYPE_WAL) {
- pthread_mutex_unlock(&tsSdbMgmt.mutex);
- sdbError(
- "vgId:1, sdb:%s, failed to restore %s key:%s from source(%d), hver:%" PRIu64 " too large, mver:%" PRIu64,
- pTable->name, actStr[action], sdbGetKeyStr(pTable, pHead->cont), qtype, pHead->version, tsSdbMgmt.version);
- return TSDB_CODE_SYN_INVALID_VERSION;
- } else {
- // If cksum is wrong when recovering wal, use this code
- tsSdbMgmt.version = pHead->version;
- }
-
- } else {
- tsSdbMgmt.version = pHead->version;
- }
- }
-
- int32_t code = walWrite(tsSdbMgmt.wal, pHead);
- if (code < 0) {
- pthread_mutex_unlock(&tsSdbMgmt.mutex);
- return code;
- }
-
- pthread_mutex_unlock(&tsSdbMgmt.mutex);
-
- // from app, row is created
- if (pRow != NULL && tsCompactMnodeWal != 1) {
- // forward to peers
- pRow->processedCount = 0;
- int32_t syncCode = syncForwardToPeer(tsSdbMgmt.sync, pHead, pRow, TAOS_QTYPE_RPC, false);
- if (syncCode <= 0) pRow->processedCount = 1;
-
- if (syncCode < 0) {
- sdbError("vgId:1, sdb:%s, failed to forward req since %s action:%s key:%s hver:%" PRIu64 ", msg:%p", pTable->name,
- tstrerror(syncCode), actStr[action], sdbGetKeyStr(pTable, pHead->cont), pHead->version, pRow->pMsg);
- } else if (syncCode > 0) {
- sdbDebug("vgId:1, sdb:%s, forward req is sent, action:%s key:%s hver:%" PRIu64 ", msg:%p", pTable->name,
- actStr[action], sdbGetKeyStr(pTable, pHead->cont), pHead->version, pRow->pMsg);
- } else {
- sdbTrace("vgId:1, sdb:%s, no need to send fwd req, action:%s key:%s hver:%" PRIu64 ", msg:%p", pTable->name,
- actStr[action], sdbGetKeyStr(pTable, pHead->cont), pHead->version, pRow->pMsg);
- }
- return syncCode;
- }
-
- sdbTrace("vgId:1, sdb:%s, record from %s is disposed, action:%s key:%s hver:%" PRIu64, pTable->name, qtypeStr[qtype],
- actStr[action], sdbGetKeyStr(pTable, pHead->cont), pHead->version);
-
- // even it is WAL/FWD, it shall be called to update version in sync
- if (tsCompactMnodeWal != 1) {
- syncForwardToPeer(tsSdbMgmt.sync, pHead, pRow, TAOS_QTYPE_RPC, false);
- }
-
- // from wal or forward msg, row not created, should add into hash
- if (action == SDB_ACTION_INSERT) {
- return sdbPerformInsertAction(pHead, pTable);
- } else if (action == SDB_ACTION_DELETE) {
- if (qtype == TAOS_QTYPE_FWD) {
- // Drop database/stable may take a long time and cause a timeout, so we confirm first
- syncConfirmForward(tsSdbMgmt.sync, pHead->version, TSDB_CODE_SUCCESS, false);
- }
- return sdbPerformDeleteAction(pHead, pTable);
- } else if (action == SDB_ACTION_UPDATE) {
- return sdbPerformUpdateAction(pHead, pTable);
- } else {
- return TSDB_CODE_MND_INVALID_MSG_TYPE;
- }
-}
-
-int32_t sdbInsertCompactRow(SSdbRow *pRow) {
- SSdbTable *pTable = pRow->pTable;
- if (pTable == NULL) return TSDB_CODE_MND_SDB_INVALID_TABLE_TYPE;
- return sdbWriteRowToQueue(pRow, SDB_ACTION_INSERT);
-}
-
-int32_t sdbInsertRow(SSdbRow *pRow) {
- SSdbTable *pTable = pRow->pTable;
- if (pTable == NULL) return TSDB_CODE_MND_SDB_INVALID_TABLE_TYPE;
-
- if (sdbGetRowFromObj(pTable, pRow->pObj)) {
- sdbError("vgId:1, sdb:%s, failed to insert:%s since it exist", pTable->name, sdbGetRowStr(pTable, pRow->pObj));
- sdbDecRef(pTable, pRow->pObj);
- return TSDB_CODE_MND_SDB_OBJ_ALREADY_THERE;
- }
-
- if (pTable->keyType == SDB_KEY_AUTO) {
- *((uint32_t *)pRow->pObj) = atomic_add_fetch_32(&pTable->autoIndex, 1);
-
- // let vgId increase from 2
- if (pTable->autoIndex == 1 && pTable->id == SDB_TABLE_VGROUP) {
- *((uint32_t *)pRow->pObj) = atomic_add_fetch_32(&pTable->autoIndex, 1);
- }
- }
-
- int32_t code = sdbInsertHash(pTable, pRow);
- if (code != TSDB_CODE_SUCCESS) {
- sdbError("vgId:1, sdb:%s, failed to insert:%s into hash", pTable->name, sdbGetRowStr(pTable, pRow->pObj));
- return code;
- }
-
- // just insert data into memory
- if (pRow->type != SDB_OPER_GLOBAL) {
- return TSDB_CODE_SUCCESS;
- }
-
- if (pRow->fpReq) {
- return (*pRow->fpReq)(pRow->pMsg);
- } else {
- return sdbWriteRowToQueue(pRow, SDB_ACTION_INSERT);
- }
-}
-
-bool sdbCheckRowDeleted(void *tparam, void *pRow) {
- SSdbTable *pTable = tparam;
- if (pTable == NULL) return false;
-
- int32_t *updateEnd = (int32_t *)((char*)pRow + pTable->refCountPos - 4);
- return atomic_val_compare_exchange_32(updateEnd, 1, 1) == 1;
-}
-
-int32_t sdbDeleteRow(SSdbRow *pRow) {
- SSdbTable *pTable = pRow->pTable;
- if (pTable == NULL) return TSDB_CODE_MND_SDB_INVALID_TABLE_TYPE;
-
- void *pObj = sdbGetRowMetaFromObj(pTable, pRow->pObj);
- if (pObj == NULL) {
- sdbDebug("vgId:1, sdb:%s, record is not there, delete failed", pTable->name);
- return TSDB_CODE_MND_SDB_OBJ_NOT_THERE;
- }
-
- int32_t code = sdbDeleteHash(pTable, pRow);
- if (code != TSDB_CODE_SUCCESS) {
- sdbError("vgId:1, sdb:%s, failed to delete from hash", pTable->name);
- return code;
- }
-
- // just delete data from memory
- if (pRow->type != SDB_OPER_GLOBAL) {
- return TSDB_CODE_SUCCESS;
- }
-
- if (pRow->fpReq) {
- return (*pRow->fpReq)(pRow->pMsg);
- } else {
- return sdbWriteRowToQueue(pRow, SDB_ACTION_DELETE);
- }
-}
-
-int32_t sdbUpdateRow(SSdbRow *pRow) {
- SSdbTable *pTable = pRow->pTable;
- if (pTable == NULL) return TSDB_CODE_MND_SDB_INVALID_TABLE_TYPE;
-
- void *pObj = sdbGetRowMetaFromObj(pTable, pRow->pObj);
- if (pObj == NULL) {
- sdbDebug("vgId:1, sdb:%s, record is not there, update failed", pTable->name);
- return TSDB_CODE_MND_SDB_OBJ_NOT_THERE;
- }
-
- int32_t code = sdbUpdateHash(pTable, pRow);
- if (code != TSDB_CODE_SUCCESS) {
- sdbError("vgId:1, sdb:%s, failed to update hash", pTable->name);
- return code;
- }
-
- // just update data in memory
- if (pRow->type != SDB_OPER_GLOBAL) {
- return TSDB_CODE_SUCCESS;
- }
-
- if (pRow->fpReq) {
- return (*pRow->fpReq)(pRow->pMsg);
- } else {
- return sdbWriteRowToQueue(pRow, SDB_ACTION_UPDATE);
- }
-}
-
-void *sdbFetchRow(void *tparam, void *pIter, void **ppRow) {
- SSdbTable *pTable = tparam;
- *ppRow = NULL;
- if (pTable == NULL) return NULL;
-
- pIter = taosHashIterate(pTable->iHandle, pIter);
- if (pIter == NULL) return NULL;
-
- void **ppMetaRow = pIter;
- if (ppMetaRow == NULL) {
- taosHashCancelIterate(pTable->iHandle, pIter);
- return NULL;
- }
-
- *ppRow = *ppMetaRow;
- sdbIncRef(pTable, *ppMetaRow);
-
- return pIter;
-}
-
-void sdbFreeIter(void *tparam, void *pIter) {
- SSdbTable *pTable = tparam;
- if (pTable == NULL || pIter == NULL) return;
-
- taosHashCancelIterate(pTable->iHandle, pIter);
-}
-
-int64_t sdbOpenTable(SSdbTableDesc *pDesc) {
- SSdbTable *pTable = (SSdbTable *)calloc(1, sizeof(SSdbTable));
-
- if (pTable == NULL) return -1;
-
- pthread_mutex_init(&pTable->mutex, NULL);
- tstrncpy(pTable->name, pDesc->name, SDB_TABLE_LEN);
- pTable->keyType = pDesc->keyType;
- pTable->id = pDesc->id;
- pTable->hashSessions = pDesc->hashSessions;
- pTable->maxRowSize = pDesc->maxRowSize;
- pTable->refCountPos = pDesc->refCountPos;
- pTable->fpInsert = pDesc->fpInsert;
- pTable->fpDelete = pDesc->fpDelete;
- pTable->fpUpdate = pDesc->fpUpdate;
- pTable->fpEncode = pDesc->fpEncode;
- pTable->fpDecode = pDesc->fpDecode;
- pTable->fpDestroy = pDesc->fpDestroy;
- pTable->fpRestored = pDesc->fpRestored;
-
- _hash_fn_t hashFp = taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT);
- if (pTable->keyType == SDB_KEY_STRING || pTable->keyType == SDB_KEY_VAR_STRING) {
- hashFp = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
- }
- pTable->iHandle = taosHashInit(pTable->hashSessions, hashFp, true, HASH_ENTRY_LOCK);
-
- tsSdbMgmt.numOfTables++;
- tsSdbMgmt.tableList[pTable->id] = pTable;
-
- return taosAddRef(tsSdbRid, pTable);
-}
-
-void sdbCloseTable(int64_t rid) {
- taosRemoveRef(tsSdbRid, rid);
-}
-
-void *sdbGetTableByRid(int64_t rid) {
- void *handle = taosAcquireRef(tsSdbRid, rid);
- taosReleaseRef(tsSdbRid, rid);
- return handle;
-}
-
-static void sdbCloseTableObj(void *handle) {
- SSdbTable *pTable = (SSdbTable *)handle;
- if (pTable == NULL) return;
-
- tsSdbMgmt.numOfTables--;
- tsSdbMgmt.tableList[pTable->id] = NULL;
-
- void *pIter = taosHashIterate(pTable->iHandle, NULL);
- while (pIter) {
- void **ppRow = pIter;
- pIter = taosHashIterate(pTable->iHandle, pIter);
- if (ppRow == NULL) continue;
-
- SSdbRow row = {
- .pObj = *ppRow,
- .pTable = pTable,
- };
-
- (*pTable->fpDestroy)(&row);
- }
-
- taosHashCancelIterate(pTable->iHandle, pIter);
- taosHashCleanup(pTable->iHandle);
- pTable->iHandle = NULL;
- pthread_mutex_destroy(&pTable->mutex);
-
- sdbDebug("vgId:1, sdb:%s, is closed, numOfTables:%d", pTable->name, tsSdbMgmt.numOfTables);
- free(pTable);
-}
-
-static int32_t sdbInitWorker() {
- tsSdbPool.num = 1;
- tsSdbPool.worker = calloc(sizeof(SSdbWorker), tsSdbPool.num);
-
- if (tsSdbPool.worker == NULL) return -1;
- for (int32_t i = 0; i < tsSdbPool.num; ++i) {
- SSdbWorker *pWorker = tsSdbPool.worker + i;
- pWorker->workerId = i;
- }
-
- sdbAllocQueue();
-
- mInfo("vgId:1, sdb write is opened");
- return 0;
-}
-
-static void sdbCleanupWorker() {
- for (int32_t i = 0; i < tsSdbPool.num; ++i) {
- SSdbWorker *pWorker = tsSdbPool.worker + i;
- if (taosCheckPthreadValid(pWorker->thread)) {
- taosQsetThreadResume(tsSdbWQset);
- }
- }
-
- for (int32_t i = 0; i < tsSdbPool.num; ++i) {
- SSdbWorker *pWorker = tsSdbPool.worker + i;
- if (taosCheckPthreadValid(pWorker->thread)) {
- pthread_join(pWorker->thread, NULL);
- }
- }
-
- sdbFreeQueue();
- tfree(tsSdbPool.worker);
-
- mInfo("vgId:1, sdb write is closed");
-}
-
-static int32_t sdbAllocQueue() {
- tsSdbWQueue = taosOpenQueue();
- if (tsSdbWQueue == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
- tsSdbWQset = taosOpenQset();
- if (tsSdbWQset == NULL) {
- taosCloseQueue(tsSdbWQueue);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
- taosAddIntoQset(tsSdbWQset, tsSdbWQueue, NULL);
-
- tsSdbWQall = taosAllocateQall();
- if (tsSdbWQall == NULL) {
- taosCloseQset(tsSdbWQset);
- taosCloseQueue(tsSdbWQueue);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- for (int32_t i = 0; i < tsSdbPool.num; ++i) {
- SSdbWorker *pWorker = tsSdbPool.worker + i;
- pWorker->workerId = i;
-
- pthread_attr_t thAttr;
- pthread_attr_init(&thAttr);
- pthread_attr_setdetachstate(&thAttr, PTHREAD_CREATE_JOINABLE);
-
- if (pthread_create(&pWorker->thread, &thAttr, sdbWorkerFp, pWorker) != 0) {
- mError("failed to create thread to process sdb write queue, reason:%s", strerror(errno));
- taosFreeQall(tsSdbWQall);
- taosCloseQset(tsSdbWQset);
- taosCloseQueue(tsSdbWQueue);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- pthread_attr_destroy(&thAttr);
- mDebug("sdb write worker:%d is launched, total:%d", pWorker->workerId, tsSdbPool.num);
- }
-
- mDebug("sdb write queue:%p is allocated", tsSdbWQueue);
- return TSDB_CODE_SUCCESS;
-}
-
-static void sdbFreeQueue() {
- taosCloseQueue(tsSdbWQueue);
- taosFreeQall(tsSdbWQall);
- taosCloseQset(tsSdbWQset);
- tsSdbWQall = NULL;
- tsSdbWQset = NULL;
- tsSdbWQueue = NULL;
-}
-
-static int32_t sdbWriteToQueue(SSdbRow *pRow, int32_t qtype) {
- SWalHead *pHead = &pRow->pHead;
-
- if (pHead->len > TSDB_MAX_WAL_SIZE) {
- sdbError("vgId:1, wal len:%d exceeds limit, hver:%" PRIu64, pHead->len, pHead->version);
- taosFreeQitem(pRow);
- return TSDB_CODE_WAL_SIZE_LIMIT;
- }
-
- int32_t queued = atomic_add_fetch_32(&tsSdbMgmt.queuedMsg, 1);
- if (queued > MAX_QUEUED_MSG_NUM) {
- sdbInfo("vgId:1, too many msg:%d in sdb queue, flow control", queued);
- taosMsleep(1);
- }
-
- sdbIncRef(pRow->pTable, pRow->pObj);
-
- sdbTrace("vgId:1, msg:%p qtype:%s write into to sdb queue, queued:%d", pRow->pMsg, qtypeStr[qtype], queued);
- taosWriteQitem(tsSdbWQueue, qtype, pRow);
-
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-static void sdbFreeFromQueue(SSdbRow *pRow) {
- int32_t queued = atomic_sub_fetch_32(&tsSdbMgmt.queuedMsg, 1);
- sdbTrace("vgId:1, msg:%p free from sdb queue, queued:%d", pRow->pMsg, queued);
-
- sdbDecRef(pRow->pTable, pRow->pObj);
- taosFreeQitem(pRow);
-}
-
-static int32_t sdbWriteFwdToQueue(int32_t vgId, void *wparam, int32_t qtype, void *rparam) {
- SWalHead *pHead = wparam;
-
- int32_t size = sizeof(SSdbRow) + sizeof(SWalHead) + pHead->len;
- SSdbRow *pRow = taosAllocateQitem(size);
- if (pRow == NULL) {
- return TSDB_CODE_VND_OUT_OF_MEMORY;
- }
-
- memcpy(&pRow->pHead, pHead, sizeof(SWalHead) + pHead->len);
- pRow->rowData = pRow->pHead.cont;
-
- int32_t code = sdbWriteToQueue(pRow, qtype);
- if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) code = 0;
-
- return code;
-}
-
-static int32_t sdbWriteRowToQueue(SSdbRow *pInputRow, int32_t action) {
- SSdbTable *pTable = pInputRow->pTable;
- if (pTable == NULL) return TSDB_CODE_MND_SDB_INVALID_TABLE_TYPE;
-
- int32_t size = sizeof(SSdbRow) + sizeof(SWalHead) + pTable->maxRowSize;
- SSdbRow *pRow = taosAllocateQitem(size);
- if (pRow == NULL) {
- return TSDB_CODE_VND_OUT_OF_MEMORY;
- }
-
- memcpy(pRow, pInputRow, sizeof(SSdbRow));
- pRow->processedCount = 1;
-
- SWalHead *pHead = &pRow->pHead;
- pRow->rowData = pHead->cont;
- (*pTable->fpEncode)(pRow);
-
- pHead->len = pRow->rowSize;
- pHead->version = 0;
- pHead->msgType = pTable->id * 10 + action;
-
- return sdbWriteToQueue(pRow, TAOS_QTYPE_RPC);
-}
-
-int32_t sdbInsertRowToQueue(SSdbRow *pRow) { return sdbWriteRowToQueue(pRow, SDB_ACTION_INSERT); }
-
-static void *sdbWorkerFp(void *pWorker) {
- SSdbRow *pRow;
- int32_t qtype;
- void * unUsed;
-
- taosBlockSIGPIPE();
- setThreadName("sdbWorker");
-
- while (1) {
- int32_t numOfMsgs = taosReadAllQitemsFromQset(tsSdbWQset, tsSdbWQall, &unUsed);
- if (numOfMsgs == 0) {
- sdbDebug("qset:%p, sdb got no message from qset, exiting", tsSdbWQset);
- break;
- }
-
- for (int32_t i = 0; i < numOfMsgs; ++i) {
- taosGetQitem(tsSdbWQall, &qtype, (void **)&pRow);
- sdbTrace("vgId:1, msg:%p, row:%p hver:%" PRIu64 ", will be processed in sdb queue", pRow->pMsg, pRow->pObj,
- pRow->pHead.version);
-
- pRow->code = sdbProcessWrite((qtype == TAOS_QTYPE_RPC) ? pRow : NULL, &pRow->pHead, qtype, NULL);
- if (pRow->code > 0) pRow->code = 0;
-
- sdbTrace("vgId:1, msg:%p is processed in sdb queue, code:%x", pRow->pMsg, pRow->code);
- }
-
- walFsync(tsSdbMgmt.wal, true);
-
- // browse all items, and process them one by one
- taosResetQitems(tsSdbWQall);
- for (int32_t i = 0; i < numOfMsgs; ++i) {
- taosGetQitem(tsSdbWQall, &qtype, (void **)&pRow);
-
- if (qtype == TAOS_QTYPE_RPC) {
- sdbConfirmForward(1, pRow, pRow->code);
- } else {
- if (qtype == TAOS_QTYPE_FWD) {
- int32_t action = pRow->pHead.msgType % 10;
- if (action != SDB_ACTION_DELETE) {
- syncConfirmForward(tsSdbMgmt.sync, pRow->pHead.version, pRow->code, false);
- }
- }
- sdbFreeFromQueue(pRow);
- }
- }
- }
-
- return NULL;
-}
-
-int32_t sdbGetReplicaNum() {
- return tsSdbMgmt.cfg.replica;
-}
-
-int32_t mnodeCompactWal() {
- sdbInfo("vgId:1, start compact mnode wal...");
-
- // close old wal
- walFsync(tsSdbMgmt.wal, true);
- walClose(tsSdbMgmt.wal);
-
- // reset version,then compacted wal log can start from version 1
- tsSdbMgmt.version = 0;
-
- // change wal to wal_tmp dir
- SWalCfg walCfg = {.vgId = 1, .walLevel = TAOS_WAL_FSYNC, .keep = TAOS_WAL_KEEP, .fsyncPeriod = 0};
- char temp[TSDB_FILENAME_LEN] = {0};
- sprintf(temp, "%s/wal", tsMnodeTmpDir);
- tsSdbMgmt.wal = walOpen(temp, &walCfg);
- walRenew(tsSdbMgmt.wal);
-
- // compact memory tables info to wal tmp dir
- if (mnodeCompactComponents() != 0) {
- tfsRmdir(tsMnodeTmpDir);
- return -1;
- }
-
- // close sdb and sync to disk
- //walFsync(tsSdbMgmt.wal, true);
- //walClose(tsSdbMgmt.wal);
- sdbCleanUp();
-
- // rename old wal to wal_bak
- if (taosRename(tsMnodeDir, tsMnodeBakDir) != 0) {
- return -1;
- }
-
- // rename wal_tmp to wal
- if (taosRename(tsMnodeTmpDir, tsMnodeDir) != 0) {
- return -1;
- }
-
- // del wal_tmp dir
- sdbInfo("vgId:1, compact mnode wal success");
-
- return 0;
-}
diff --git a/src/mnode/src/mnodeShow.c b/src/mnode/src/mnodeShow.c
deleted file mode 100644
index bbfdb52e058c9e8c4ce3d3fe9d06715e9c0483aa..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeShow.c
+++ /dev/null
@@ -1,452 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosmsg.h"
-#include "taoserror.h"
-#include "tsched.h"
-#include "tutil.h"
-#include "ttimer.h"
-#include "tgrant.h"
-#include "tglobal.h"
-#include "tcache.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeDb.h"
-#include "mnodeDnode.h"
-#include "mnodeMnode.h"
-#include "mnodeProfile.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeTable.h"
-#include "mnodeUser.h"
-#include "mnodeVgroup.h"
-#include "mnodeWrite.h"
-#include "mnodeRead.h"
-
-static int32_t mnodeProcessShowMsg(SMnodeMsg *mnodeMsg);
-static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *mnodeMsg);
-static int32_t mnodeProcessHeartBeatMsg(SMnodeMsg *mnodeMsg);
-static int32_t mnodeProcessConnectMsg(SMnodeMsg *mnodeMsg);
-static int32_t mnodeProcessUseMsg(SMnodeMsg *mnodeMsg);
-
-static void mnodeFreeShowObj(void *data);
-static bool mnodeAccquireShowObj(SShowObj *pShow);
-static bool mnodeCheckShowFinished(SShowObj *pShow);
-static void *mnodePutShowObj(SShowObj *pShow);
-static void mnodeReleaseShowObj(SShowObj *pShow, bool forceRemove);
-
-static void *tsMnodeShowCache = NULL;
-static int32_t tsShowObjIndex = 0;
-static SShowMetaFp tsMnodeShowMetaFp[TSDB_MGMT_TABLE_MAX] = {0};
-static SShowRetrieveFp tsMnodeShowRetrieveFp[TSDB_MGMT_TABLE_MAX] = {0};
-static SShowFreeIterFp tsMnodeShowFreeIterFp[TSDB_MGMT_TABLE_MAX] = {0};
-
-int32_t mnodeInitShow() {
- mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_SHOW, mnodeProcessShowMsg);
- mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_RETRIEVE, mnodeProcessRetrieveMsg);
- mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_HEARTBEAT, mnodeProcessHeartBeatMsg);
- mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_CONNECT, mnodeProcessConnectMsg);
- mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_USE_DB, mnodeProcessUseMsg);
-
- tsMnodeShowCache = taosCacheInit(TSDB_CACHE_PTR_KEY, 5, true, mnodeFreeShowObj, "show");
- return 0;
-}
-
-void mnodeCleanUpShow() {
- if (tsMnodeShowCache != NULL) {
- mInfo("show cache is cleanup");
- taosCacheCleanup(tsMnodeShowCache);
- tsMnodeShowCache = NULL;
- }
-}
-
-void mnodeAddShowMetaHandle(uint8_t showType, SShowMetaFp fp) {
- tsMnodeShowMetaFp[showType] = fp;
-}
-
-void mnodeAddShowRetrieveHandle(uint8_t msgType, SShowRetrieveFp fp) {
- tsMnodeShowRetrieveFp[msgType] = fp;
-}
-
-void mnodeAddShowFreeIterHandle(uint8_t msgType, SShowFreeIterFp fp) {
- tsMnodeShowFreeIterFp[msgType] = fp;
-}
-
-static char *mnodeGetShowType(int32_t showType) {
- switch (showType) {
- case TSDB_MGMT_TABLE_ACCT: return "show accounts";
- case TSDB_MGMT_TABLE_USER: return "show users";
- case TSDB_MGMT_TABLE_DB: return "show databases";
- case TSDB_MGMT_TABLE_TABLE: return "show tables";
- case TSDB_MGMT_TABLE_DNODE: return "show dnodes";
- case TSDB_MGMT_TABLE_MNODE: return "show mnodes";
- case TSDB_MGMT_TABLE_VGROUP: return "show vgroups";
- case TSDB_MGMT_TABLE_METRIC: return "show stables";
- case TSDB_MGMT_TABLE_MODULE: return "show modules";
- case TSDB_MGMT_TABLE_QUERIES: return "show queries";
- case TSDB_MGMT_TABLE_STREAMS: return "show streams";
- case TSDB_MGMT_TABLE_VARIABLES: return "show configs";
- case TSDB_MGMT_TABLE_CONNS: return "show connections";
- case TSDB_MGMT_TABLE_SCORES: return "show scores";
- case TSDB_MGMT_TABLE_GRANTS: return "show grants";
- case TSDB_MGMT_TABLE_VNODES: return "show vnodes";
- case TSDB_MGMT_TABLE_CLUSTER: return "show clusters";
- case TSDB_MGMT_TABLE_STREAMTABLES : return "show streamtables";
- case TSDB_MGMT_TABLE_TP: return "show topics";
- default: return "undefined";
- }
-}
-
-static int32_t mnodeProcessShowMsg(SMnodeMsg *pMsg) {
- SShowMsg *pShowMsg = pMsg->rpcMsg.pCont;
- if (pShowMsg->type >= TSDB_MGMT_TABLE_MAX) {
- return TSDB_CODE_MND_INVALID_MSG_TYPE;
- }
-
- if (!tsMnodeShowMetaFp[pShowMsg->type] || !tsMnodeShowRetrieveFp[pShowMsg->type]) {
- mError("show type:%s is not support", mnodeGetShowType(pShowMsg->type));
- return TSDB_CODE_COM_OPS_NOT_SUPPORT;
- }
-
- int32_t showObjSize = sizeof(SShowObj) + htons(pShowMsg->payloadLen);
- SShowObj *pShow = calloc(1, showObjSize);
- pShow->type = pShowMsg->type;
- pShow->payloadLen = htons(pShowMsg->payloadLen);
- tstrncpy(pShow->db, pShowMsg->db, TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN);
- memcpy(pShow->payload, pShowMsg->payload, pShow->payloadLen);
-
- pShow = mnodePutShowObj(pShow);
- if (pShow == NULL) {
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- int32_t size = sizeof(SShowRsp) + sizeof(SSchema) * TSDB_MAX_COLUMNS + TSDB_EXTRA_PAYLOAD_SIZE;
- SShowRsp *pShowRsp = rpcMallocCont(size);
- if (pShowRsp == NULL) {
- mnodeReleaseShowObj(pShow, true);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
- pShowRsp->qhandle = htobe64((uint64_t) pShow);
-
- int32_t code = (*tsMnodeShowMetaFp[pShowMsg->type])(&pShowRsp->tableMeta, pShow, pMsg->rpcMsg.handle);
- mDebug("%p, show type:%s index:%d, get meta finished, numOfRows:%d cols:%d result:%s", pShow,
- mnodeGetShowType(pShowMsg->type), pShow->index, pShow->numOfRows, pShow->numOfColumns, tstrerror(code));
-
- if (code == TSDB_CODE_SUCCESS) {
- pMsg->rpcRsp.rsp = pShowRsp;
- pMsg->rpcRsp.len = sizeof(SShowRsp) + sizeof(SSchema) * pShow->numOfColumns;
- mnodeReleaseShowObj(pShow, false);
- return TSDB_CODE_SUCCESS;
- } else {
- rpcFreeCont(pShowRsp);
- mnodeReleaseShowObj(pShow, true);
- return code;
- }
-}
-
-static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) {
- int32_t rowsToRead = 0;
- int32_t size = 0;
- int32_t rowsRead = 0;
- SRetrieveTableMsg *pRetrieve = pMsg->rpcMsg.pCont;
- pRetrieve->qhandle = htobe64(pRetrieve->qhandle);
-
- SShowObj *pShow = (SShowObj *)pRetrieve->qhandle;
-
- /*
- * in case of server restart, apps may hold qhandle created by server before
- * restart, which is actually invalid, therefore, signature check is required.
- */
- if (!mnodeAccquireShowObj(pShow)) {
- mError("%p, show is invalid", pShow);
- return TSDB_CODE_MND_INVALID_SHOWOBJ;
- }
-
- mDebug("%p, show type:%s index:%d, start retrieve data, numOfReads:%d numOfRows:%d", pShow,
- mnodeGetShowType(pShow->type), pShow->index, pShow->numOfReads, pShow->numOfRows);
-
- if (mnodeCheckShowFinished(pShow)) {
- mDebug("%p, show is already read finished, numOfReads:%d numOfRows:%d", pShow, pShow->numOfReads, pShow->numOfRows);
- pShow->numOfReads = pShow->numOfRows;
- }
-
- if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) {
- rowsToRead = pShow->numOfRows - pShow->numOfReads;
- }
-
- /* return no more than 100 tables in one round trip */
- if (rowsToRead > 100) rowsToRead = 100;
-
- /*
- * the actual number of table may be larger than the value of pShow->numOfRows, if a query is
- * issued during a continuous create table operation. Therefore, rowToRead may be less than 0.
- */
- if (rowsToRead < 0) rowsToRead = 0;
- size = pShow->rowSize * rowsToRead;
-
- size += 100;
- SRetrieveTableRsp *pRsp = rpcMallocCont(size);
-
- // if free flag is set, client wants to clean the resources
- if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE)
- rowsRead = (*tsMnodeShowRetrieveFp[pShow->type])(pShow, pRsp->data, rowsToRead, pMsg->rpcMsg.handle);
-
- mDebug("%p, show type:%s index:%d, stop retrieve data, rowsRead:%d rowsToRead:%d", pShow,
- mnodeGetShowType(pShow->type), pShow->index, rowsRead, rowsToRead);
-
- if (rowsRead < 0) {
- rpcFreeCont(pRsp);
- mnodeReleaseShowObj(pShow, false);
- assert(false);
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
- }
-
- pRsp->numOfRows = htonl(rowsRead);
- pRsp->precision = (int16_t)htonl(TSDB_TIME_PRECISION_MILLI); // millisecond time precision
-
- pMsg->rpcRsp.rsp = pRsp;
- pMsg->rpcRsp.len = size;
-
- if (rowsToRead == 0 || (rowsRead == rowsToRead && pShow->numOfRows == pShow->numOfReads)) {
- pRsp->completed = 1;
- mDebug("%p, retrieve completed", pShow);
- mnodeReleaseShowObj(pShow, true);
- } else {
- mDebug("%p, retrieve not completed yet", pShow);
- mnodeReleaseShowObj(pShow, false);
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeProcessHeartBeatMsg(SMnodeMsg *pMsg) {
- SHeartBeatRsp *pRsp = (SHeartBeatRsp *)rpcMallocCont(sizeof(SHeartBeatRsp));
- if (pRsp == NULL) {
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- SHeartBeatMsg *pHBMsg = pMsg->rpcMsg.pCont;
- if (taosCheckVersion(pHBMsg->clientVer, version, 3) != TSDB_CODE_SUCCESS) {
- rpcFreeCont(pRsp);
- return TSDB_CODE_TSC_INVALID_VERSION; // todo change the error code
- }
-
- SRpcConnInfo connInfo = {0};
- rpcGetConnInfo(pMsg->rpcMsg.handle, &connInfo);
-
- int32_t connId = htonl(pHBMsg->connId);
- SConnObj *pConn = mnodeAccquireConn(connId, connInfo.user, connInfo.clientIp, connInfo.clientPort);
- if (pConn == NULL) {
- pHBMsg->pid = htonl(pHBMsg->pid);
- pConn = mnodeCreateConn(connInfo.user, connInfo.clientIp, connInfo.clientPort, pHBMsg->pid, pHBMsg->appName);
- }
-
- if (pConn == NULL) {
- // do not close existing links, otherwise
- // mError("failed to create connId, close connect");
- // pRsp->killConnection = 1;
- } else {
- pRsp->connId = htonl(pConn->connId);
- mnodeSaveQueryStreamList(pConn, pHBMsg);
-
- if (pConn->killed != 0) {
- pRsp->killConnection = 1;
- }
-
- if (pConn->streamId != 0) {
- pRsp->streamId = htonl(pConn->streamId);
- pConn->streamId = 0;
- }
-
- if (pConn->queryId != 0) {
- pRsp->queryId = htonl(pConn->queryId);
- pConn->queryId = 0;
- }
- }
-
- int32_t onlineDnodes = 0, totalDnodes = 0;
- mnodeGetOnlineAndTotalDnodesNum(&onlineDnodes, &totalDnodes);
-
- pRsp->onlineDnodes = htonl(onlineDnodes);
- pRsp->totalDnodes = htonl(totalDnodes);
- mnodeGetMnodeEpSetForShell(&pRsp->epSet, false);
-
- pMsg->rpcRsp.rsp = pRsp;
- pMsg->rpcRsp.len = sizeof(SHeartBeatRsp);
-
- mnodeReleaseConn(pConn);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeProcessConnectMsg(SMnodeMsg *pMsg) {
- SConnectMsg *pConnectMsg = pMsg->rpcMsg.pCont;
- SConnectRsp *pConnectRsp = NULL;
- int32_t code = TSDB_CODE_SUCCESS;
-
- SRpcConnInfo connInfo = {0};
- if (rpcGetConnInfo(pMsg->rpcMsg.handle, &connInfo) != 0) {
- mError("thandle:%p is already released while process connect msg", pMsg->rpcMsg.handle);
- code = TSDB_CODE_MND_INVALID_CONNECTION;
- goto connect_over;
- }
-
- code = taosCheckVersion(pConnectMsg->clientVersion, version, 3);
- if (code != TSDB_CODE_SUCCESS) {
- goto connect_over;
- }
-
- SUserObj *pUser = pMsg->pUser;
- SAcctObj *pAcct = pUser->pAcct;
-
- if (pConnectMsg->db[0]) {
- char dbName[TSDB_TABLE_FNAME_LEN * 3] = {0};
- sprintf(dbName, "%x%s%s", pAcct->acctId, TS_PATH_DELIMITER, pConnectMsg->db);
- SDbObj *pDb = mnodeGetDb(dbName);
- if (pDb == NULL) {
- code = TSDB_CODE_MND_INVALID_DB;
- goto connect_over;
- }
-
- if (pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
- code = TSDB_CODE_MND_DB_IN_DROPPING;
- mnodeDecDbRef(pDb);
- goto connect_over;
- }
- mnodeDecDbRef(pDb);
- }
-
- pConnectRsp = rpcMallocCont(sizeof(SConnectRsp));
- if (pConnectRsp == NULL) {
- code = TSDB_CODE_MND_OUT_OF_MEMORY;
- goto connect_over;
- }
-
- pConnectMsg->pid = htonl(pConnectMsg->pid);
- SConnObj *pConn = mnodeCreateConn(connInfo.user, connInfo.clientIp, connInfo.clientPort, pConnectMsg->pid, pConnectMsg->appName);
- if (pConn == NULL) {
- code = terrno;
- } else {
- pConnectRsp->connId = htonl(pConn->connId);
- mnodeReleaseConn(pConn);
- }
-
- sprintf(pConnectRsp->acctId, "%x", pAcct->acctId);
- memcpy(pConnectRsp->serverVersion, version, TSDB_VERSION_LEN);
- pConnectRsp->writeAuth = pUser->writeAuth;
- pConnectRsp->superAuth = pUser->superAuth;
-
- mnodeGetMnodeEpSetForShell(&pConnectRsp->epSet, false);
-
- dnodeGetClusterId(pConnectRsp->clusterId);
-
-connect_over:
- if (code != TSDB_CODE_SUCCESS) {
- if (pConnectRsp) rpcFreeCont(pConnectRsp);
- mLError("user:%s login from %s, result:%s", connInfo.user, taosIpStr(connInfo.clientIp), tstrerror(code));
- } else {
- mLInfo("user:%s login from %s, result:%s", connInfo.user, taosIpStr(connInfo.clientIp), tstrerror(code));
- pMsg->rpcRsp.rsp = pConnectRsp;
- pMsg->rpcRsp.len = sizeof(SConnectRsp);
- }
-
- return code;
-}
-
-static int32_t mnodeProcessUseMsg(SMnodeMsg *pMsg) {
- SUseDbMsg *pUseDbMsg = pMsg->rpcMsg.pCont;
-
- int32_t code = TSDB_CODE_SUCCESS;
- if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pUseDbMsg->db);
- if (pMsg->pDb == NULL) {
- return TSDB_CODE_MND_INVALID_DB;
- }
-
- if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- return code;
-}
-
-static bool mnodeCheckShowFinished(SShowObj *pShow) {
- if (pShow->pIter == NULL && pShow->numOfReads != 0) {
- return true;
- }
- return false;
-}
-
-static bool mnodeAccquireShowObj(SShowObj *pShow) {
- TSDB_CACHE_PTR_TYPE handleVal = (TSDB_CACHE_PTR_TYPE)pShow;
- SShowObj **ppShow = taosCacheAcquireByKey(tsMnodeShowCache, &handleVal, sizeof(TSDB_CACHE_PTR_TYPE));
- if (ppShow) {
- mDebug("%p, show is accquired from cache, data:%p, index:%d", pShow, ppShow, pShow->index);
- return true;
- }
-
- return false;
-}
-
-static void* mnodePutShowObj(SShowObj *pShow) {
- const int32_t DEFAULT_SHOWHANDLE_LIFE_SPAN = tsShellActivityTimer * 6 * 1000;
-
- if (tsMnodeShowCache != NULL) {
- pShow->index = atomic_add_fetch_32(&tsShowObjIndex, 1);
- TSDB_CACHE_PTR_TYPE handleVal = (TSDB_CACHE_PTR_TYPE)pShow;
- SShowObj **ppShow = taosCachePut(tsMnodeShowCache, &handleVal, sizeof(TSDB_CACHE_PTR_TYPE), &pShow, sizeof(TSDB_CACHE_PTR_TYPE), DEFAULT_SHOWHANDLE_LIFE_SPAN);
- pShow->ppShow = (void**)ppShow;
- mDebug("%p, show is put into cache, data:%p index:%d", pShow, ppShow, pShow->index);
- return pShow;
- }
-
- return NULL;
-}
-
-static void mnodeFreeShowObj(void *data) {
- SShowObj *pShow = *(SShowObj **)data;
- if (tsMnodeShowFreeIterFp[pShow->type] != NULL) {
- if (pShow->pVgIter != NULL) {
- // only used in 'show vnodes "ep"'
- (*tsMnodeShowFreeIterFp[pShow->type])(pShow->pVgIter);
- } else {
- if (pShow->pIter != NULL) (*tsMnodeShowFreeIterFp[pShow->type])(pShow->pIter);
- }
- }
-
- mDebug("%p, show is destroyed, data:%p index:%d", pShow, data, pShow->index);
- tfree(pShow);
-}
-
-static void mnodeReleaseShowObj(SShowObj *pShow, bool forceRemove) {
- SShowObj **ppShow = (SShowObj **)pShow->ppShow;
- mDebug("%p, show is released, force:%s data:%p index:%d", pShow, forceRemove ? "true" : "false", ppShow,
- pShow->index);
-
- taosCacheRelease(tsMnodeShowCache, (void **)(&ppShow), forceRemove);
-}
-
-void mnodeVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_t capacity, SShowObj *pShow) {
- if (rows < capacity) {
- for (int32_t i = 0; i < numOfCols; ++i) {
- memmove(data + pShow->offset[i] * rows, data + pShow->offset[i] * capacity, pShow->bytes[i] * rows);
- }
- }
-}
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
deleted file mode 100644
index 44dae0aed182fc93241c6d25ea55ea4991fbf0ac..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeTable.c
+++ /dev/null
@@ -1,3605 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "mnodeTable.h"
-#include "dnode.h"
-#include "hash.h"
-#include "mnode.h"
-#include "mnodeAcct.h"
-#include "mnodeDb.h"
-#include "mnodeDef.h"
-#include "mnodeDnode.h"
-#include "mnodeFunc.h"
-#include "mnodeInt.h"
-#include "mnodePeer.h"
-#include "mnodeRead.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeVgroup.h"
-#include "mnodeWrite.h"
-#include "os.h"
-#include "taoserror.h"
-#include "taosmsg.h"
-#include "tcompare.h"
-#include "tcompression.h"
-#include "tdataformat.h"
-#include "tglobal.h"
-#include "tgrant.h"
-#include "tidpool.h"
-#include "tname.h"
-#include "tqueue.h"
-#include "tutil.h"
-
-#define ALTER_CTABLE_RETRY_TIMES 3
-#define CREATE_CTABLE_RETRY_TIMES 10
-#define CREATE_CTABLE_RETRY_SEC 14
-
-int64_t tsCTableRid = -1;
-static void * tsChildTableSdb;
-int64_t tsSTableRid = -1;
-static void * tsSuperTableSdb;
-static SHashObj *tsSTableUidHash;
-static int32_t tsChildTableUpdateSize;
-static int32_t tsSuperTableUpdateSize;
-
-static void * mnodeGetChildTable(char *tableId);
-static void * mnodeGetSuperTable(char *tableId);
-static void * mnodeGetSuperTableByUid(uint64_t uid);
-static void mnodeDropAllChildTablesInStable(SSTableObj *pStable);
-static void mnodeAddTableIntoStable(SSTableObj *pStable, SCTableObj *pCtable);
-static void mnodeRemoveTableFromStable(SSTableObj *pStable, SCTableObj *pCtable);
-
-static int32_t mnodeGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeGetStreamTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveStreamTables(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-
-static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg);
-static void mnodeProcessCreateChildTableRsp(SRpcMsg *rpcMsg);
-
-static int32_t mnodeProcessDropTableMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessDropSuperTableMsg(SMnodeMsg *pMsg);
-static void mnodeProcessDropSuperTableRsp(SRpcMsg *rpcMsg);
-static int32_t mnodeProcessDropChildTableMsg(SMnodeMsg *pMsg);
-static void mnodeProcessDropChildTableRsp(SRpcMsg *rpcMsg);
-
-static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessTableCfgMsg(SMnodeMsg *pMsg);
-
-static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *pMsg);
-static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg);
-static int32_t mnodeGetChildTableMeta(SMnodeMsg *pMsg);
-static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg);
-
-static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg);
-static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg);
-
-static int32_t mnodeFindSuperTableColumnIndex(SSTableObj *pStable, char *colName);
-static int32_t mnodeChangeSuperTableColumn(SMnodeMsg *pMsg);
-static int32_t mnodeChangeSuperTableTag(SMnodeMsg *pMsg);
-static int32_t mnodeChangeNormalTableColumn(SMnodeMsg *pMsg);
-
-static void mnodeDestroyChildTable(SCTableObj *pTable) {
- tfree(pTable->info.tableId);
- tfree(pTable->schema);
- tfree(pTable->sql);
- tfree(pTable);
-}
-
-static char* mnodeGetTableShowPattern(SShowObj *pShow) {
- char* pattern = NULL;
- if (pShow != NULL && pShow->payloadLen > 0) {
- pattern = (char*)malloc(pShow->payloadLen + 1);
- if (pattern == NULL) {
- terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
- return NULL;
- }
- memcpy(pattern, pShow->payload, pShow->payloadLen);
- pattern[pShow->payloadLen] = 0;
- }
- return pattern;
-}
-
-static int32_t mnodeChildTableActionDestroy(SSdbRow *pRow) {
- mnodeDestroyChildTable(pRow->pObj);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeChildTableActionInsert(SSdbRow *pRow) {
- SCTableObj *pTable = pRow->pObj;
- int32_t code = 0;
-
- SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId);
- if (pVgroup == NULL) {
- mError("ctable:%s, not in vgId:%d", pTable->info.tableId, pTable->vgId);
- code = -1;
- }
-
- SDbObj *pDb = NULL;
- if (pVgroup != NULL) {
- pDb = mnodeGetDb(pVgroup->dbName);
- if (pDb == NULL) {
- mError("ctable:%s, vgId:%d not in db:%s", pTable->info.tableId, pVgroup->vgId, pVgroup->dbName);
- code = -1;
- }
- }
-
- SAcctObj *pAcct = NULL;
- if (pDb != NULL) {
- pAcct = mnodeGetAcct(pDb->acct);
- if (pAcct == NULL) {
- mError("ctable:%s, acct:%s not exists", pTable->info.tableId, pDb->acct);
- code = -1;
- }
- }
-
- if (pTable->info.type == TSDB_CHILD_TABLE) {
- // add ref
- pTable->superTable = mnodeGetSuperTableByUid(pTable->suid);
- if (pTable->superTable != NULL) {
- mnodeAddTableIntoStable(pTable->superTable, pTable);
- grantAdd(TSDB_GRANT_TIMESERIES, pTable->superTable->numOfColumns - 1);
- if (pAcct) pAcct->acctInfo.numOfTimeSeries += (pTable->superTable->numOfColumns - 1);
- } else {
- mError("table:%s:%p, correspond stable not found suid:%" PRIu64, pTable->info.tableId, pTable, pTable->suid);
- code = -1;
- }
- } else {
- grantAdd(TSDB_GRANT_TIMESERIES, pTable->numOfColumns - 1);
- if (pAcct) pAcct->acctInfo.numOfTimeSeries += (pTable->numOfColumns - 1);
- }
-
- if (pDb) mnodeAddTableIntoDb(pDb);
- if (pVgroup) {
- if (mnodeAddTableIntoVgroup(pVgroup, pTable, pRow->pMsg == NULL) != 0) {
- mError("table:%s, vgId:%d tid:%d, failed to perform insert action, uid:%" PRIu64 " suid:%" PRIu64,
- pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid, pTable->suid);
- code = -1;
- }
- }
-
- mnodeDecVgroupRef(pVgroup);
- mnodeDecDbRef(pDb);
- mnodeDecAcctRef(pAcct);
-
- if (code == 0) {
- mTrace("table:%s, vgId:%d tid:%d, perform insert action, uid:%" PRIu64 " suid:%" PRIu64, pTable->info.tableId,
- pTable->vgId, pTable->tid, pTable->uid, pTable->suid);
- }
-
- return code;
-}
-
-static int32_t mnodeChildTableActionDelete(SSdbRow *pRow) {
- SCTableObj *pTable = pRow->pObj;
- if (pTable->vgId == 0) {
- mError("table:%s, vgId:%d tid:%d, failed to perform delete action, uid:%" PRIu64 " suid:%" PRIu64,
- pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid, pTable->suid);
- return TSDB_CODE_MND_VGROUP_NOT_EXIST;
- }
-
- SVgObj *pVgroup = NULL;
- SDbObj *pDb = NULL;
- SAcctObj *pAcct = NULL;
-
- pVgroup = mnodeGetVgroup(pTable->vgId);
- if (pVgroup != NULL) pDb = mnodeGetDb(pVgroup->dbName);
- if (pDb != NULL) pAcct = mnodeGetAcct(pDb->acct);
-
- if (pTable->info.type == TSDB_CHILD_TABLE) {
- if (pTable->superTable) {
- grantRestore(TSDB_GRANT_TIMESERIES, pTable->superTable->numOfColumns - 1);
- if (pAcct != NULL) pAcct->acctInfo.numOfTimeSeries -= (pTable->superTable->numOfColumns - 1);
- mnodeRemoveTableFromStable(pTable->superTable, pTable);
- mnodeDecTableRef(pTable->superTable);
- }
- } else {
- grantRestore(TSDB_GRANT_TIMESERIES, pTable->numOfColumns - 1);
- if (pAcct != NULL) pAcct->acctInfo.numOfTimeSeries -= (pTable->numOfColumns - 1);
- }
-
- if (pDb != NULL) mnodeRemoveTableFromDb(pDb);
- if (pVgroup != NULL) mnodeRemoveTableFromVgroup(pVgroup, pTable);
-
- mnodeDecVgroupRef(pVgroup);
- mnodeDecDbRef(pDb);
- mnodeDecAcctRef(pAcct);
-
- mTrace("table:%s, vgId:%d tid:%d, perform delete action, uid:%" PRIu64 " suid:%" PRIu64, pTable->info.tableId,
- pTable->vgId, pTable->tid, pTable->uid, pTable->suid);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeChildTableActionUpdate(SSdbRow *pRow) {
- SCTableObj *pNew = pRow->pObj;
- SCTableObj *pTable = mnodeGetChildTable(pNew->info.tableId);
- if (pTable != pNew) {
- void *oldTableId = pTable->info.tableId;
- void *oldSql = pTable->sql;
- void *oldSchema = pTable->schema;
- void *oldSTable = pTable->superTable;
- int32_t oldRefCount = pTable->refCount;
-
- memcpy(pTable, pNew, sizeof(SCTableObj));
-
- pTable->refCount = oldRefCount;
- pTable->sql = pNew->sql;
- pTable->schema = pNew->schema;
- pTable->superTable = oldSTable;
-
- free(pNew);
- free(oldSql);
- free(oldSchema);
- free(oldTableId);
- }
- mnodeDecTableRef(pTable);
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeChildTableActionEncode(SSdbRow *pRow) {
- SCTableObj *pTable = pRow->pObj;
- assert(pTable != NULL && pRow->rowData != NULL);
-
- int32_t len = (int32_t)strlen(pTable->info.tableId);
- if (len >= TSDB_TABLE_FNAME_LEN) return TSDB_CODE_MND_INVALID_TABLE_ID;
-
- memcpy(pRow->rowData, pTable->info.tableId, len);
- memset((char *)pRow->rowData + len, 0, 1);
- len++;
-
- memcpy((char *)pRow->rowData + len, (char *)pTable + sizeof(char *), tsChildTableUpdateSize);
- len += tsChildTableUpdateSize;
-
- if (pTable->info.type != TSDB_CHILD_TABLE) {
- int32_t schemaSize = pTable->numOfColumns * sizeof(SSchema);
- memcpy((char *)pRow->rowData + len, pTable->schema, schemaSize);
- len += schemaSize;
-
- if (pTable->sqlLen != 0) {
- memcpy((char *)pRow->rowData + len, pTable->sql, pTable->sqlLen);
- len += pTable->sqlLen;
- }
- }
-
- pRow->rowSize = len;
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeChildTableActionDecode(SSdbRow *pRow) {
- assert(pRow->rowData != NULL);
- SCTableObj *pTable = calloc(1, sizeof(SCTableObj));
- if (pTable == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
- int32_t len = (int32_t)strlen(pRow->rowData);
- if (len >= TSDB_TABLE_FNAME_LEN) {
- free(pTable);
- return TSDB_CODE_MND_INVALID_TABLE_ID;
- }
- pTable->info.tableId = strdup(pRow->rowData);
- len++;
-
- memcpy((char *)pTable + sizeof(char *), (char *)pRow->rowData + len, tsChildTableUpdateSize);
- len += tsChildTableUpdateSize;
-
- if (pTable->info.type != TSDB_CHILD_TABLE) {
- int32_t schemaSize = pTable->numOfColumns * sizeof(SSchema);
- pTable->schema = (SSchema *)malloc(schemaSize);
- if (pTable->schema == NULL) {
- mnodeDestroyChildTable(pTable);
- return TSDB_CODE_MND_INVALID_TABLE_TYPE;
- }
- memcpy(pTable->schema, (char *)pRow->rowData + len, schemaSize);
- len += schemaSize;
-
- if (pTable->sqlLen != 0) {
- pTable->sql = malloc(pTable->sqlLen);
- if (pTable->sql == NULL) {
- mnodeDestroyChildTable(pTable);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
- memcpy(pTable->sql, (char *)pRow->rowData + len, pTable->sqlLen);
- }
- }
-
- pRow->pObj = pTable;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeChildTableActionRestored() {
-#if 0
- void *pIter = NULL;
- SCTableObj *pTable = NULL;
-
- while (1) {
- pIter = mnodeGetNextChildTable(pIter, &pTable);
- if (pTable == NULL) break;
-
- SDbObj *pDb = mnodeGetDbByTableName(pTable->info.tableId);
- if (pDb == NULL || pDb->status != TSDB_DB_STATUS_READY) {
- mError("ctable:%s, failed to get db or db in dropping, discard it", pTable->info.tableId);
- SSdbRow desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .pTable = tsChildTableSdb};
- sdbDeleteRow(&desc);
- mnodeDecTableRef(pTable);
- mnodeDecDbRef(pDb);
- continue;
- }
- mnodeDecDbRef(pDb);
-
- SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId);
- if (pVgroup == NULL) {
- mError("ctable:%s, failed to get vgId:%d tid:%d, discard it", pTable->info.tableId, pTable->vgId, pTable->tid);
- pTable->vgId = 0;
- SSdbRow desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .pTable = tsChildTableSdb};
- sdbDeleteRow(&desc);
- mnodeDecTableRef(pTable);
- continue;
- }
- mnodeDecVgroupRef(pVgroup);
-
- if (strcmp(pVgroup->dbName, pDb->name) != 0) {
- mError("ctable:%s, db:%s not match with vgId:%d db:%s sid:%d, discard it",
- pTable->info.tableId, pDb->name, pTable->vgId, pVgroup->dbName, pTable->tid);
- pTable->vgId = 0;
- SSdbRow desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .pTable = tsChildTableSdb};
- sdbDeleteRow(&desc);
- mnodeDecTableRef(pTable);
- continue;
- }
-
- if (pTable->info.type == TSDB_CHILD_TABLE) {
- SSTableObj *pSuperTable = mnodeGetSuperTableByUid(pTable->suid);
- if (pSuperTable == NULL) {
- mError("ctable:%s, stable:%" PRIu64 " not exist", pTable->info.tableId, pTable->suid);
- pTable->vgId = 0;
- SSdbRow desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .pTable = tsChildTableSdb};
- sdbDeleteRow(&desc);
- mnodeDecTableRef(pTable);
- continue;
- }
- mnodeDecTableRef(pSuperTable);
- }
-
- mnodeDecTableRef(pTable);
- }
-
- mnodeCancelGetNextChildTable(pIter);
-#endif
- return 0;
-}
-
-static int32_t mnodeInitChildTables() {
- SCTableObj tObj;
- tsChildTableUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj.info.type);
-
- SSdbTableDesc desc = {
- .id = SDB_TABLE_CTABLE,
- .name = "ctables",
- .hashSessions = TSDB_DEFAULT_CTABLES_HASH_SIZE,
- .maxRowSize = sizeof(SCTableObj) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16) + TSDB_TABLE_FNAME_LEN + TSDB_CQ_SQL_SIZE,
- .refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
- .keyType = SDB_KEY_VAR_STRING,
- .fpInsert = mnodeChildTableActionInsert,
- .fpDelete = mnodeChildTableActionDelete,
- .fpUpdate = mnodeChildTableActionUpdate,
- .fpEncode = mnodeChildTableActionEncode,
- .fpDecode = mnodeChildTableActionDecode,
- .fpDestroy = mnodeChildTableActionDestroy,
- .fpRestored = mnodeChildTableActionRestored
- };
-
- tsCTableRid = sdbOpenTable(&desc);
- tsChildTableSdb = sdbGetTableByRid(tsCTableRid);
- if (tsChildTableSdb == NULL) {
- mError("failed to init child table data");
- return -1;
- }
-
- mDebug("table:ctables is created");
- return 0;
-}
-
-static void mnodeCleanupChildTables() {
- sdbCloseTable(tsCTableRid);
- tsChildTableSdb = NULL;
-}
-
-int64_t mnodeGetSuperTableNum() {
- return sdbGetNumOfRows(tsSuperTableSdb);
-}
-
-int64_t mnodeGetChildTableNum() {
- return sdbGetNumOfRows(tsChildTableSdb);
-}
-
-static void mnodeAddTableIntoStable(SSTableObj *pStable, SCTableObj *pCtable) {
- atomic_add_fetch_32(&pStable->numOfTables, 1);
-
- if (pStable->vgHash == NULL) {
- pStable->vgHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK);
- mDebug("stable:%s, create vgId hash:%p", pStable->info.tableId, pStable->vgHash);
- }
-
- if (pStable->vgHash != NULL) {
- if (taosHashGet(pStable->vgHash, &pCtable->vgId, sizeof(pCtable->vgId)) == NULL) {
- taosHashPut(pStable->vgHash, &pCtable->vgId, sizeof(pCtable->vgId), &pCtable->vgId, sizeof(pCtable->vgId));
- mDebug("stable:%s, vgId:%d is put into stable vgId hash:%p, sizeOfVgList:%d", pStable->info.tableId, pCtable->vgId,
- pStable->vgHash, taosHashGetSize(pStable->vgHash));
- }
- }
-}
-
-static void mnodeRemoveTableFromStable(SSTableObj *pStable, SCTableObj *pCtable) {
- atomic_sub_fetch_32(&pStable->numOfTables, 1);
-
- if (pStable->vgHash == NULL) return;
-
- SVgObj *pVgroup = mnodeGetVgroup(pCtable->vgId);
- if (pVgroup == NULL) {
- taosHashRemove(pStable->vgHash, &pCtable->vgId, sizeof(pCtable->vgId));
- mDebug("table:%s, vgId:%d is remove from stable hash:%p sizeOfVgList:%d", pStable->info.tableId, pCtable->vgId,
- pStable->vgHash, taosHashGetSize(pStable->vgHash));
- }
- mnodeDecVgroupRef(pVgroup);
-}
-
-static void mnodeDestroySuperTable(SSTableObj *pStable) {
- mDebug("table:%s, is destroyed, stable hash:%p", pStable->info.tableId, pStable->vgHash);
- if (pStable->vgHash != NULL) {
- taosHashCleanup(pStable->vgHash);
- pStable->vgHash = NULL;
- }
- tfree(pStable->info.tableId);
- tfree(pStable->schema);
- tfree(pStable);
-}
-
-static int32_t mnodeSuperTableActionDestroy(SSdbRow *pRow) {
- mnodeDestroySuperTable(pRow->pObj);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionInsert(SSdbRow *pRow) {
- SSTableObj *pStable = pRow->pObj;
- SDbObj * pDb = mnodeGetDbByTableName(pStable->info.tableId);
- if (pDb != NULL && pDb->status == TSDB_DB_STATUS_READY) {
- mnodeAddSuperTableIntoDb(pDb);
- }
- mnodeDecDbRef(pDb);
-
- taosHashPut(tsSTableUidHash, &pStable->uid, sizeof(int64_t), &pStable, sizeof(int64_t));
-
- mTrace("stable:%s, perform insert action, uid:%" PRIu64, pStable->info.tableId, pStable->uid);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionDelete(SSdbRow *pRow) {
- SSTableObj *pStable = pRow->pObj;
- SDbObj * pDb = mnodeGetDbByTableName(pStable->info.tableId);
- if (pDb != NULL) {
- mnodeRemoveSuperTableFromDb(pDb);
- mnodeDropAllChildTablesInStable((SSTableObj *)pStable);
- }
- mnodeDecDbRef(pDb);
-
- taosHashRemove(tsSTableUidHash, &pStable->uid, sizeof(int64_t));
-
- mTrace("stable:%s, perform delete action, uid:%" PRIu64, pStable->info.tableId, pStable->uid);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionUpdate(SSdbRow *pRow) {
- SSTableObj *pNew = pRow->pObj;
- SSTableObj *pTable = mnodeGetSuperTable(pNew->info.tableId);
- if (pTable != NULL && pTable != pNew) {
- mDebug("table:%s, will be updated, hash:%p sizeOfVgList:%d, new hash:%p sizeOfVgList:%d", pTable->info.tableId,
- pTable->vgHash, taosHashGetSize(pTable->vgHash), pNew->vgHash, taosHashGetSize(pNew->vgHash));
-
- void *oldTableId = pTable->info.tableId;
- void *oldSchema = pTable->schema;
- void *oldVgHash = pTable->vgHash;
- int32_t oldRefCount = pTable->refCount;
- int32_t oldNumOfTables = pTable->numOfTables;
-
- memcpy(pTable, pNew, sizeof(SSTableObj));
-
- pTable->vgHash = oldVgHash;
- pTable->refCount = oldRefCount;
- pTable->schema = pNew->schema;
- pTable->numOfTables = oldNumOfTables;
- free(pNew);
- free(oldTableId);
- free(oldSchema);
-
- mDebug("table:%s, update finished, hash:%p sizeOfVgList:%d", pTable->info.tableId, pTable->vgHash,
- taosHashGetSize(pTable->vgHash));
- }
-
- mnodeDecTableRef(pTable);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionEncode(SSdbRow *pRow) {
- SSTableObj *pStable = pRow->pObj;
- assert(pRow->pObj != NULL && pRow->rowData != NULL);
-
- int32_t len = (int32_t)strlen(pStable->info.tableId);
- if (len >= TSDB_TABLE_FNAME_LEN) len = TSDB_CODE_MND_INVALID_TABLE_ID;
-
- memcpy(pRow->rowData, pStable->info.tableId, len);
- memset((char *)pRow->rowData + len, 0, 1);
- len++;
-
- memcpy((char *)pRow->rowData + len, (char *)pStable + sizeof(char *), tsSuperTableUpdateSize);
- len += tsSuperTableUpdateSize;
-
- int32_t schemaSize = sizeof(SSchema) * (pStable->numOfColumns + pStable->numOfTags);
- memcpy((char *)pRow->rowData + len, pStable->schema, schemaSize);
- len += schemaSize;
-
- pRow->rowSize = len;
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionDecode(SSdbRow *pRow) {
- assert(pRow->rowData != NULL);
- SSTableObj *pStable = (SSTableObj *) calloc(1, sizeof(SSTableObj));
- if (pStable == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
- int32_t len = (int32_t)strlen(pRow->rowData);
- if (len >= TSDB_TABLE_FNAME_LEN){
- free(pStable);
- return TSDB_CODE_MND_INVALID_TABLE_ID;
- }
- pStable->info.tableId = strdup(pRow->rowData);
- len++;
-
- memcpy((char *)pStable + sizeof(char *), (char *)pRow->rowData + len, tsSuperTableUpdateSize);
- len += tsSuperTableUpdateSize;
-
- int32_t schemaSize = sizeof(SSchema) * (pStable->numOfColumns + pStable->numOfTags);
- pStable->schema = malloc(schemaSize);
- if (pStable->schema == NULL) {
- mnodeDestroySuperTable(pStable);
- return TSDB_CODE_MND_NOT_SUPER_TABLE;
- }
-
- memcpy(pStable->schema, (char *)pRow->rowData + len, schemaSize);
- pRow->pObj = pStable;
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeSuperTableActionRestored() {
- return 0;
-}
-
-static int32_t mnodeInitSuperTables() {
- SSTableObj tObj;
- tsSuperTableUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj.info.type);
-
- SSdbTableDesc desc = {
- .id = SDB_TABLE_STABLE,
- .name = "stables",
- .hashSessions = TSDB_DEFAULT_STABLES_HASH_SIZE,
- .maxRowSize = sizeof(SSTableObj) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16) + TSDB_TABLE_FNAME_LEN,
- .refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
- .keyType = SDB_KEY_VAR_STRING,
- .fpInsert = mnodeSuperTableActionInsert,
- .fpDelete = mnodeSuperTableActionDelete,
- .fpUpdate = mnodeSuperTableActionUpdate,
- .fpEncode = mnodeSuperTableActionEncode,
- .fpDecode = mnodeSuperTableActionDecode,
- .fpDestroy = mnodeSuperTableActionDestroy,
- .fpRestored = mnodeSuperTableActionRestored
- };
-
- tsSTableUidHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
- tsSTableRid = sdbOpenTable(&desc);
- tsSuperTableSdb = sdbGetTableByRid(tsSTableRid);
- if (tsSuperTableSdb == NULL) {
- mError("failed to init stables data");
- return -1;
- }
-
- mDebug("table:stables is created");
- return 0;
-}
-
-static void mnodeCleanupSuperTables() {
- sdbCloseTable(tsSTableRid);
- tsSuperTableSdb = NULL;
-
- taosHashCleanup(tsSTableUidHash);
- tsSTableUidHash = NULL;
-}
-
-int32_t mnodeInitTables() {
- int32_t code = mnodeInitSuperTables();
- if (code != TSDB_CODE_SUCCESS) {
- return code;
- }
-
- code = mnodeInitChildTables();
- if (code != TSDB_CODE_SUCCESS) {
- return code;
- }
-
- mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_TABLES_META, mnodeProcessMultiTableMetaMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_TABLE, mnodeProcessCreateTableMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_TABLE, mnodeProcessDropTableMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_ALTER_TABLE, mnodeProcessAlterTableMsg);
- mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_TABLE_META, mnodeProcessTableMetaMsg);
- mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_STABLE_VGROUP, mnodeProcessSuperTableVgroupMsg);
-
- mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP, mnodeProcessCreateChildTableRsp);
- mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_DROP_TABLE_RSP, mnodeProcessDropChildTableRsp);
- mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_DROP_STABLE_RSP, mnodeProcessDropSuperTableRsp);
- mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP, mnodeProcessAlterTableRsp);
-
- mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_TABLE, mnodeProcessTableCfgMsg);
-
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_TABLE, mnodeGetShowTableMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_TABLE, mnodeRetrieveShowTables);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_TABLE, mnodeCancelGetNextChildTable);
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_METRIC, mnodeGetShowSuperTableMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_METRIC, mnodeRetrieveShowSuperTables);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_METRIC, mnodeCancelGetNextSuperTable);
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_STREAMTABLES, mnodeGetStreamTableMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMTABLES, mnodeRetrieveStreamTables);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_STREAMTABLES, mnodeCancelGetNextChildTable);
-
- return TSDB_CODE_SUCCESS;
-}
-
-static void *mnodeGetChildTable(char *tableId) {
- return sdbGetRow(tsChildTableSdb, tableId);
-}
-
-static void *mnodeGetSuperTable(char *tableId) {
- return sdbGetRow(tsSuperTableSdb, tableId);
-}
-
-static void *mnodeGetSuperTableByUid(uint64_t uid) {
- SSTableObj **ppStable = taosHashGet(tsSTableUidHash, &uid, sizeof(int64_t));
- if (ppStable == NULL || *ppStable == NULL) return NULL;
-
- SSTableObj *pStable = *ppStable;
- mnodeIncTableRef(pStable);
- return pStable;
-}
-
-void *mnodeGetTable(char *tableId) {
- void *pTable = mnodeGetSuperTable(tableId);
- if (pTable != NULL) {
- return pTable;
- }
-
- pTable = mnodeGetChildTable(tableId);
- if (pTable != NULL) {
- return pTable;
- }
-
- return NULL;
-}
-
-void *mnodeGetNextChildTable(void *pIter, SCTableObj **pTable) {
- return sdbFetchRow(tsChildTableSdb, pIter, (void **)pTable);
-}
-
-void mnodeCancelGetNextChildTable(void *pIter) {
- sdbFreeIter(tsChildTableSdb, pIter);
-}
-
-void *mnodeGetNextSuperTable(void *pIter, SSTableObj **pTable) {
- return sdbFetchRow(tsSuperTableSdb, pIter, (void **)pTable);
-}
-
-void mnodeCancelGetNextSuperTable(void *pIter) {
- sdbFreeIter(tsSuperTableSdb, pIter);
-}
-
-void mnodeIncTableRef(void *p1) {
- STableObj *pTable = (STableObj *)p1;
- if (pTable->type == TSDB_SUPER_TABLE) {
- sdbIncRef(tsSuperTableSdb, pTable);
- } else {
- sdbIncRef(tsChildTableSdb, pTable);
- }
-}
-
-void mnodeDecTableRef(void *p1) {
- if (p1 == NULL) return;
-
- STableObj *pTable = (STableObj *)p1;
- if (pTable->type == TSDB_SUPER_TABLE) {
- sdbDecRef(tsSuperTableSdb, pTable);
- } else {
- sdbDecRef(tsChildTableSdb, pTable);
- }
-}
-
-void mnodeCleanupTables() {
- mnodeCleanupChildTables();
- mnodeCleanupSuperTables();
-}
-
-// todo move to name.h, add length of table name
-static void mnodeExtractTableName(char* tableId, char* name) {
- int pos = -1;
- int num = 0;
- for (pos = 0; tableId[pos] != 0; ++pos) {
- if (tableId[pos] == '.') num++;
- if (num == 2) break;
- }
-
- if (num == 2) {
- strcpy(name, tableId + pos + 1);
- }
-}
-
-static SMnodeMsg *mnodeCreateSubMsg(SMnodeMsg *pBatchMasterMsg, int32_t contSize) {
- SMnodeMsg *pSubMsg = taosAllocateQitem(sizeof(*pBatchMasterMsg) + contSize);
- *pSubMsg = *pBatchMasterMsg;
-
- //pSubMsg->pCont = (char *) pSubMsg + sizeof(SMnodeMsg);
- pSubMsg->rpcMsg.pCont = pSubMsg->pCont;
- pSubMsg->successed = 0;
- pSubMsg->expected = 0;
- SCMCreateTableMsg *pCM = pSubMsg->rpcMsg.pCont;
- pCM->numOfTables = htonl(1);
- pCM->contLen = htonl(contSize);
-
- return pSubMsg;
-}
-
-void mnodeDestroySubMsg(SMnodeMsg *pSubMsg) {
- if (pSubMsg) {
- // pUser is retained in batch master msg
- if (pSubMsg->pDb) mnodeDecDbRef(pSubMsg->pDb);
- if (pSubMsg->pVgroup) mnodeDecVgroupRef(pSubMsg->pVgroup);
- if (pSubMsg->pTable) mnodeDecTableRef(pSubMsg->pTable);
- if (pSubMsg->pSTable) mnodeDecTableRef(pSubMsg->pSTable);
- if (pSubMsg->pAcct) mnodeDecAcctRef(pSubMsg->pAcct);
- if (pSubMsg->pDnode) mnodeDecDnodeRef(pSubMsg->pDnode);
-
- taosFreeQitem(pSubMsg);
- }
-}
-
-static int32_t mnodeValidateCreateTableMsg(SCreateTableMsg *pCreateTable, SMnodeMsg *pMsg) {
- if (pMsg->pDb == NULL) {
- pMsg->pDb = mnodeGetDbByTableName(pCreateTable->tableName);
- }
-
- if (pMsg->pDb == NULL) {
- mError("msg:%p, app:%p table:%s, failed to create, db not selected", pMsg, pMsg->rpcMsg.ahandle, pCreateTable->tableName);
- return TSDB_CODE_MND_DB_NOT_SELECTED;
- }
-
- if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pCreateTable->tableName);
- if (pMsg->pTable != NULL && pMsg->retry == 0) {
- if (pCreateTable->getMeta) {
- mDebug("msg:%p, app:%p table:%s, continue to get meta", pMsg, pMsg->rpcMsg.ahandle, pCreateTable->tableName);
- return mnodeGetChildTableMeta(pMsg);
- } else if (pCreateTable->igExists) {
- mDebug("msg:%p, app:%p table:%s, is already exist", pMsg, pMsg->rpcMsg.ahandle, pCreateTable->tableName);
- return TSDB_CODE_SUCCESS;
- } else {
- mError("msg:%p, app:%p table:%s, failed to create, table already exist", pMsg, pMsg->rpcMsg.ahandle,
- pCreateTable->tableName);
- return TSDB_CODE_MND_TABLE_ALREADY_EXIST;
- }
- }
-
- if (pCreateTable->numOfTags != 0) {
- mDebug("msg:%p, app:%p table:%s, batch create stable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
- pCreateTable->tableName, pMsg->rpcMsg.handle);
- return mnodeProcessCreateSuperTableMsg(pMsg);
- } else {
- mDebug("msg:%p, app:%p table:%s, batch create ctable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
- pCreateTable->tableName, pMsg->rpcMsg.handle);
- return mnodeProcessCreateChildTableMsg(pMsg);
- }
-}
-
-static int32_t mnodeProcessBatchCreateTableMsg(SMnodeMsg *pMsg) {
- if (pMsg->pBatchMasterMsg == NULL) { // batch master first round
- pMsg->pBatchMasterMsg = pMsg;
-
- SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
- int32_t numOfTables = htonl(pCreate->numOfTables);
- int32_t contentLen = htonl(pCreate->contLen);
- pMsg->expected = numOfTables;
-
- int32_t code = TSDB_CODE_SUCCESS;
- SCreateTableMsg *pCreateTable = (SCreateTableMsg*) ((char*) pCreate + sizeof(SCMCreateTableMsg));
- for (SCreateTableMsg *p = pCreateTable; p < (SCreateTableMsg *) ((char *) pCreate + contentLen); p = (SCreateTableMsg *) ((char *) p + htonl(p->len))) {
- SMnodeMsg *pSubMsg = mnodeCreateSubMsg(pMsg, sizeof(SCMCreateTableMsg) + htonl(p->len));
- memcpy(pSubMsg->pCont + sizeof(SCMCreateTableMsg), p, htonl(p->len));
- code = mnodeValidateCreateTableMsg(p, pSubMsg);
-
- if (code == TSDB_CODE_SUCCESS || code == TSDB_CODE_MND_TABLE_ALREADY_EXIST) {
- ++pSubMsg->pBatchMasterMsg->successed;
- mnodeDestroySubMsg(pSubMsg);
- continue;
- }
-
- if (code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mnodeDestroySubMsg(pSubMsg);
- return code;
- }
- }
-
- if (pMsg->successed >= pMsg->expected) {
- return code;
- } else {
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
- }
- } else {
- if (pMsg->pBatchMasterMsg != pMsg) { // batch sub replay
- SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
- SCreateTableMsg *pCreateTable = (SCreateTableMsg*) ((char*) pCreate + sizeof(SCMCreateTableMsg));
- int32_t code = mnodeValidateCreateTableMsg(pCreateTable, pMsg);
- if (code == TSDB_CODE_SUCCESS || code == TSDB_CODE_MND_TABLE_ALREADY_EXIST) {
- ++pMsg->pBatchMasterMsg->successed;
- mnodeDestroySubMsg(pMsg);
- } else if (code == TSDB_CODE_MND_ACTION_NEED_REPROCESSED) {
- return code;
- } else if (code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- ++pMsg->pBatchMasterMsg->received;
- pMsg->pBatchMasterMsg->code = code;
- mnodeDestroySubMsg(pMsg);
- }
-
- if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received
- >= pMsg->pBatchMasterMsg->expected) {
- dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, pMsg->pBatchMasterMsg->code);
- }
-
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
- } else { // batch master replay, reprocess the whole batch
- assert(0);
- return TSDB_CODE_MND_MSG_NOT_PROCESSED;
- }
- }
-}
-
-static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) {
- SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
-
- int32_t numOfTables = htonl(pCreate->numOfTables);
- int32_t contentLen = htonl(pCreate->contLen);
- if (numOfTables == 0 || contentLen == 0) {
- // todo return error
- }
-
- // batch master msg first round or reprocessing and batch sub msg reprocessing
- if (numOfTables > 1 || pMsg->pBatchMasterMsg != NULL) {
- return mnodeProcessBatchCreateTableMsg(pMsg);
- }
-
- SCreateTableMsg *p = (SCreateTableMsg*)((char*) pCreate + sizeof(SCMCreateTableMsg));
- if (pMsg->pDb == NULL) {
- pMsg->pDb = mnodeGetDbByTableName(p->tableName);
- }
-
- if (pMsg->pDb == NULL) {
- mError("msg:%p, app:%p table:%s, failed to create, db not selected", pMsg, pMsg->rpcMsg.ahandle, p->tableName);
- return TSDB_CODE_MND_DB_NOT_SELECTED;
- }
-
- if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(p->tableName);
- if (pMsg->pTable != NULL && pMsg->retry == 0) {
- if (p->getMeta) {
- mDebug("msg:%p, app:%p table:%s, continue to get meta", pMsg, pMsg->rpcMsg.ahandle, p->tableName);
- return mnodeGetChildTableMeta(pMsg);
- } else if (p->igExists) {
- mDebug("msg:%p, app:%p table:%s, is already exist", pMsg, pMsg->rpcMsg.ahandle, p->tableName);
- return TSDB_CODE_SUCCESS;
- } else {
- mError("msg:%p, app:%p table:%s, failed to create, table already exist", pMsg, pMsg->rpcMsg.ahandle, p->tableName);
- return TSDB_CODE_MND_TABLE_ALREADY_EXIST;
- }
- }
-
- if (p->numOfTags != 0) {
- mDebug("msg:%p, app:%p table:%s, create stable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
- p->tableName, pMsg->rpcMsg.handle);
- return mnodeProcessCreateSuperTableMsg(pMsg);
- } else {
- mDebug("msg:%p, app:%p table:%s, create ctable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
- p->tableName, pMsg->rpcMsg.handle);
- return mnodeProcessCreateChildTableMsg(pMsg);
- }
-}
-
-static int32_t mnodeProcessDropTableMsg(SMnodeMsg *pMsg) {
- SCMDropTableMsg *pDrop = pMsg->rpcMsg.pCont;
- if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableName(pDrop->name);
- if (pMsg->pDb == NULL) {
- mError("msg:%p, app:%p table:%s, failed to drop table, db not selected or db in dropping", pMsg,
- pMsg->rpcMsg.ahandle, pDrop->name);
- return TSDB_CODE_MND_DB_NOT_SELECTED;
- }
-
- if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
-#if 0
- if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) {
- mError("msg:%p, app:%p table:%s, failed to drop table, in monitor database", pMsg, pMsg->rpcMsg.ahandle,
- pDrop->name);
- return TSDB_CODE_MND_MONITOR_DB_FORBIDDEN;
- }
-#endif
-
- if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pDrop->name);
- if (pMsg->pTable == NULL) {
- if (pDrop->igNotExists) {
- mDebug("msg:%p, app:%p table:%s is not exist, treat as success", pMsg, pMsg->rpcMsg.ahandle, pDrop->name);
- return TSDB_CODE_SUCCESS;
- } else {
- mError("msg:%p, app:%p table:%s, failed to drop, table not exist", pMsg, pMsg->rpcMsg.ahandle, pDrop->name);
- return TSDB_CODE_MND_INVALID_TABLE_NAME;
- }
- }
-
- if (pMsg->pTable->type == TSDB_SUPER_TABLE) {
- SSTableObj *pSTable = (SSTableObj *)pMsg->pTable;
- mInfo("msg:%p, app:%p table:%s, start to drop stable, uid:%" PRIu64 ", numOfChildTables:%d, sizeOfVgList:%d", pMsg,
- pMsg->rpcMsg.ahandle, pDrop->name, pSTable->uid, pSTable->numOfTables, taosHashGetSize(pSTable->vgHash));
- return mnodeProcessDropSuperTableMsg(pMsg);
- } else {
- // user specify the "DROP STABLE" sql statement, but it is actually a normal table, return error msg.
- if (pDrop->supertable) {
- return TSDB_CODE_MND_INVALID_TABLE_TYPE;
- }
-
- SCTableObj *pCTable = (SCTableObj *)pMsg->pTable;
- mInfo("msg:%p, app:%p table:%s, start to drop ctable, vgId:%d tid:%d uid:%" PRIu64, pMsg, pMsg->rpcMsg.ahandle,
- pDrop->name, pCTable->vgId, pCTable->tid, pCTable->uid);
- return mnodeProcessDropChildTableMsg(pMsg);
- }
-}
-
-static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *pMsg) {
- STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
- pInfo->createFlag = htons(pInfo->createFlag);
- mDebug("msg:%p, app:%p table:%s, table meta msg is received from thandle:%p, createFlag:%d", pMsg, pMsg->rpcMsg.ahandle,
- pInfo->tableFname, pMsg->rpcMsg.handle, pInfo->createFlag);
-
- if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableName(pInfo->tableFname);
- if (pMsg->pDb == NULL) {
- mError("msg:%p, app:%p table:%s, failed to get table meta, db not selected", pMsg, pMsg->rpcMsg.ahandle,
- pInfo->tableFname);
- return TSDB_CODE_MND_DB_NOT_SELECTED;
- }
-
- if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pInfo->tableFname);
- if (pMsg->pTable == NULL) {
- if (!pInfo->createFlag) {
- mError("msg:%p, app:%p table:%s, failed to get table meta, table not exist", pMsg, pMsg->rpcMsg.ahandle,
- pInfo->tableFname);
- return TSDB_CODE_MND_INVALID_TABLE_NAME;
- } else {
- mDebug("msg:%p, app:%p table:%s, failed to get table meta, start auto create table ", pMsg, pMsg->rpcMsg.ahandle,
- pInfo->tableFname);
- return mnodeAutoCreateChildTable(pMsg);
- }
- } else {
- if (pMsg->pTable->type != TSDB_SUPER_TABLE) {
- return mnodeGetChildTableMeta(pMsg);
- } else {
- return mnodeGetSuperTableMeta(pMsg);
- }
- }
-}
-
-static int32_t mnodeCreateSuperTableCb(SMnodeMsg *pMsg, int32_t code) {
- SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
- assert(pTable);
-
- if (code == TSDB_CODE_SUCCESS) {
- mLInfo("stable:%s, is created in sdb, uid:%" PRIu64, pTable->info.tableId, pTable->uid);
- } else {
- mError("msg:%p, app:%p stable:%s, failed to create in sdb, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
- tstrerror(code));
- SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pTable, .pTable = tsSuperTableSdb};
- sdbDeleteRow(&desc);
- }
-
- return code;
-}
-
-static uint64_t mnodeCreateSuperTableUid() {
- int64_t us = taosGetTimestampUs();
- uint64_t x = (us & ((((uint64_t)1)<<40) - 1));
- x = x << 24;
-
- return x + ((sdbGetVersion() & ((1ul << 16) - 1ul)) << 8) + (taosRand() & ((1ul << 8) - 1ul));
-}
-
-static uint64_t mnodeCreateTableUid(int32_t vgId, int32_t tid) {
- uint64_t uid = (((uint64_t)vgId) << 48) + ((((uint64_t)tid) & ((1ul << 24) - 1ul)) << 24) +
- ((sdbGetVersion() & ((1ul << 16) - 1ul)) << 8) + (taosRand() & ((1ul << 8) - 1ul));
- return uid;
-}
-
-static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) {
- if (pMsg == NULL) return TSDB_CODE_MND_APP_ERROR;
-
- SCMCreateTableMsg *pCreate1 = pMsg->rpcMsg.pCont;
- if (pCreate1->numOfTables == 0) {
- return TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG;
- }
-
- SCreateTableMsg* pCreate = (SCreateTableMsg*)((char*)pCreate1 + sizeof(SCMCreateTableMsg));
-
- int16_t numOfTags = htons(pCreate->numOfTags);
- if (numOfTags > TSDB_MAX_TAGS) {
- mError("msg:%p, app:%p table:%s, failed to create, too many tags", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
- return TSDB_CODE_MND_TOO_MANY_TAGS;
- }
-
- int16_t numOfColumns = htons(pCreate->numOfColumns);
- int32_t numOfCols = numOfColumns + numOfTags;
- if (numOfCols > TSDB_MAX_COLUMNS) {
- mError("msg:%p, app:%p table:%s, failed to create, too many columns", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
- return TSDB_CODE_MND_TOO_MANY_COLUMNS;
- }
-
- SSTableObj *pStable = calloc(1, sizeof(SSTableObj));
- if (pStable == NULL) {
- mError("msg:%p, app:%p table:%s, failed to create, no enough memory", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- pStable->info.tableId = strdup(pCreate->tableName);
- pStable->info.type = TSDB_SUPER_TABLE;
- pStable->createdTime = taosGetTimestampMs();
- pStable->uid = mnodeCreateSuperTableUid();
- pStable->sversion = 0;
- pStable->tversion = 0;
- pStable->numOfColumns = numOfColumns;
- pStable->numOfTags = numOfTags;
-
- int32_t schemaSize = numOfCols * sizeof(SSchema);
- pStable->schema = (SSchema *)calloc(1, schemaSize);
- if (pStable->schema == NULL) {
- tfree(pStable->info.tableId);
- tfree(pStable);
- mError("msg:%p, app:%p table:%s, failed to create, no schema input", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
- return TSDB_CODE_MND_INVALID_TABLE_NAME;
- }
-
- memcpy(pStable->schema, pCreate->schema, numOfCols * sizeof(SSchema));
-
- pStable->nextColId = 0;
-
- for (int32_t col = 0; col < numOfCols; col++) {
- SSchema *tschema = pStable->schema;
- tschema[col].colId = pStable->nextColId++;
- tschema[col].bytes = htons(tschema[col].bytes);
- }
-
- if (!tIsValidSchema(pStable->schema, pStable->numOfColumns, pStable->numOfTags)) {
- mError("msg:%p, app:%p table:%s, failed to create table, invalid schema", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
- tfree(pStable->info.tableId);
- tfree(pStable->schema);
- tfree(pStable);
- return TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG;
- }
-
- pMsg->pTable = (STableObj *)pStable;
- mnodeIncTableRef(pMsg->pTable);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsSuperTableSdb,
- .pObj = pStable,
- .rowSize = sizeof(SSTableObj) + schemaSize,
- .pMsg = pMsg,
- .fpRsp = mnodeCreateSuperTableCb
- };
-
- int32_t code = sdbInsertRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mnodeDestroySuperTable(pStable);
- pMsg->pTable = NULL;
- mError("msg:%p, app:%p table:%s, failed to create, sdb error", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
- }
-
- return code;
-}
-
-static int32_t mnodeDropSuperTableCb(SMnodeMsg *pMsg, int32_t code) {
- SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
- if (code != TSDB_CODE_SUCCESS) {
- mError("msg:%p, app:%p stable:%s, failed to drop, sdb error", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
-
- return code;
- }
-
- mLInfo("msg:%p, app:%p stable:%s, is dropped from sdb", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
-
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- if (pStable->vgHash != NULL /*pStable->numOfTables != 0*/) {
- int32_t *pVgId = taosHashIterate(pStable->vgHash, NULL);
- while (pVgId) {
- SVgObj *pVgroup = mnodeGetVgroup(*pVgId);
- pVgId = taosHashIterate(pStable->vgHash, pVgId);
- if (pVgroup == NULL) break;
-
- SDropSTableMsg *pDrop = rpcMallocCont(sizeof(SDropSTableMsg));
- pDrop->contLen = htonl(sizeof(SDropSTableMsg));
- pDrop->vgId = htonl(pVgroup->vgId);
- pDrop->uid = htobe64(pStable->uid);
- mnodeExtractTableName(pStable->info.tableId, pDrop->tableFname);
-
- mInfo("msg:%p, app:%p stable:%s, send drop stable msg to vgId:%d, hash:%p sizeOfVgList:%d", pMsg,
- pMsg->rpcMsg.ahandle, pStable->info.tableId, pVgroup->vgId, pStable->vgHash,
- taosHashGetSize(pStable->vgHash));
- SRpcEpSet epSet = mnodeGetEpSetFromVgroup(pVgroup);
- SRpcMsg rpcMsg = {.pCont = pDrop, .contLen = sizeof(SDropSTableMsg), .msgType = TSDB_MSG_TYPE_MD_DROP_STABLE};
- dnodeSendMsgToDnode(&epSet, &rpcMsg);
- mnodeDecVgroupRef(pVgroup);
- }
-
- taosHashCancelIterate(pStable->vgHash, pVgId);
-
- mnodeDropAllChildTablesInStable(pStable);
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeProcessDropSuperTableMsg(SMnodeMsg *pMsg) {
- if (pMsg == NULL) return TSDB_CODE_MND_APP_ERROR;
-
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- mInfo("msg:%p, app:%p stable:%s will be dropped, hash:%p sizeOfVgList:%d", pMsg, pMsg->rpcMsg.ahandle,
- pStable->info.tableId, pStable->vgHash, taosHashGetSize(pStable->vgHash));
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsSuperTableSdb,
- .pObj = pStable,
- .pMsg = pMsg,
- .fpRsp = mnodeDropSuperTableCb
- };
-
- int32_t code = sdbDeleteRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("msg:%p, app:%p table:%s, failed to drop, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- tstrerror(code));
- }
-
- return code;
-}
-
-static int32_t mnodeFindSuperTableTagIndex(SSTableObj *pStable, const char *tagName) {
- SSchema *schema = (SSchema *) pStable->schema;
- for (int32_t tag = 0; tag < pStable->numOfTags; tag++) {
- if (strcasecmp(schema[pStable->numOfColumns + tag].name, tagName) == 0) {
- return tag;
- }
- }
-
- return -1;
-}
-
-static int32_t mnodeAddSuperTableTagCb(SMnodeMsg *pMsg, int32_t code) {
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- mLInfo("msg:%p, app:%p stable %s, add tag result:%s, numOfTags:%d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- tstrerror(code), pStable->numOfTags);
- if (code == TSDB_CODE_SUCCESS) {
- code = mnodeGetSuperTableMeta(pMsg);
- }
- return code;
-}
-
-static int32_t mnodeAddSuperTableTag(SMnodeMsg *pMsg, SSchema schema[], int32_t ntags) {
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- if (pStable->numOfTags + ntags > TSDB_MAX_TAGS) {
- mError("msg:%p, app:%p stable:%s, add tag, too many tags", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId);
- return TSDB_CODE_MND_TOO_MANY_TAGS;
- }
-
- for (int32_t i = 0; i < ntags; i++) {
- if (mnodeFindSuperTableColumnIndex(pStable, schema[i].name) > 0) {
- mError("msg:%p, app:%p stable:%s, add tag, column:%s already exist", pMsg, pMsg->rpcMsg.ahandle,
- pStable->info.tableId, schema[i].name);
- return TSDB_CODE_MND_TAG_ALREAY_EXIST;
- }
-
- if (mnodeFindSuperTableTagIndex(pStable, schema[i].name) > 0) {
- mError("msg:%p, app:%p stable:%s, add tag, tag:%s already exist", pMsg, pMsg->rpcMsg.ahandle,
- pStable->info.tableId, schema[i].name);
- return TSDB_CODE_MND_FIELD_ALREAY_EXIST;
- }
- }
-
- int32_t schemaSize = sizeof(SSchema) * (pStable->numOfTags + pStable->numOfColumns);
- pStable->schema = realloc(pStable->schema, schemaSize + sizeof(SSchema) * ntags);
-
- memcpy(pStable->schema + pStable->numOfColumns + pStable->numOfTags, schema, sizeof(SSchema) * ntags);
-
- SSchema *tschema = (SSchema *)(pStable->schema + pStable->numOfColumns + pStable->numOfTags);
- for (int32_t i = 0; i < ntags; i++) {
- tschema[i].colId = pStable->nextColId++;
- }
-
- pStable->numOfTags += ntags;
- pStable->tversion++;
-
- mInfo("msg:%p, app:%p stable %s, start to add tag %s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- schema[0].name);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsSuperTableSdb,
- .pObj = pStable,
- .pMsg = pMsg,
- .fpRsp = mnodeAddSuperTableTagCb
- };
-
- return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeDropSuperTableTagCb(SMnodeMsg *pMsg, int32_t code) {
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- mLInfo("msg:%p, app:%p stable %s, drop tag result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- tstrerror(code));
- if (code == TSDB_CODE_SUCCESS) {
- code = mnodeGetSuperTableMeta(pMsg);
- }
- return code;
-}
-
-static int32_t mnodeDropSuperTableTag(SMnodeMsg *pMsg, char *tagName) {
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- int32_t col = mnodeFindSuperTableTagIndex(pStable, tagName);
- if (col < 0) {
- mError("msg:%p, app:%p stable:%s, drop tag, tag:%s not exist", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- tagName);
- return TSDB_CODE_MND_TAG_NOT_EXIST;
- }
-
- memmove(pStable->schema + pStable->numOfColumns + col, pStable->schema + pStable->numOfColumns + col + 1,
- sizeof(SSchema) * (pStable->numOfTags - col - 1));
- pStable->numOfTags--;
- pStable->tversion++;
-
- mInfo("msg:%p, app:%p stable %s, start to drop tag %s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId, tagName);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsSuperTableSdb,
- .pObj = pStable,
- .pMsg = pMsg,
- .fpRsp = mnodeDropSuperTableTagCb
- };
-
- return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeModifySuperTableTagNameCb(SMnodeMsg *pMsg, int32_t code) {
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- mLInfo("msg:%p, app:%p stable %s, modify tag result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- tstrerror(code));
- if (code == TSDB_CODE_SUCCESS) {
- code = mnodeGetSuperTableMeta(pMsg);
- }
- return code;
-}
-
-static int32_t mnodeModifySuperTableTagName(SMnodeMsg *pMsg, char *oldTagName, char *newTagName) {
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- int32_t col = mnodeFindSuperTableTagIndex(pStable, oldTagName);
- if (col < 0) {
- mError("msg:%p, app:%p stable:%s, failed to modify table tag, oldName: %s, newName: %s", pMsg, pMsg->rpcMsg.ahandle,
- pStable->info.tableId, oldTagName, newTagName);
- return TSDB_CODE_MND_TAG_NOT_EXIST;
- }
-
- // int32_t rowSize = 0;
- uint32_t len = (int32_t)strlen(newTagName);
- if (len >= TSDB_COL_NAME_LEN) {
- return TSDB_CODE_MND_COL_NAME_TOO_LONG;
- }
-
- if (mnodeFindSuperTableTagIndex(pStable, newTagName) >= 0) {
- return TSDB_CODE_MND_TAG_ALREAY_EXIST;
- }
-
- // update
- SSchema *schema = (SSchema *) (pStable->schema + pStable->numOfColumns + col);
- tstrncpy(schema->name, newTagName, sizeof(schema->name));
-
- mInfo("msg:%p, app:%p stable %s, start to modify tag %s to %s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- oldTagName, newTagName);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsSuperTableSdb,
- .pObj = pStable,
- .pMsg = pMsg,
- .fpRsp = mnodeModifySuperTableTagNameCb
- };
-
- return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeFindSuperTableColumnIndex(SSTableObj *pStable, char *colName) {
- SSchema *schema = (SSchema *) pStable->schema;
- for (int32_t col = 0; col < pStable->numOfColumns; col++) {
- if (strcasecmp(schema[col].name, colName) == 0) {
- return col;
- }
- }
-
- return -1;
-}
-
-static int32_t mnodeAddSuperTableColumnCb(SMnodeMsg *pMsg, int32_t code) {
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- mLInfo("msg:%p, app:%p stable %s, add column result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- tstrerror(code));
- if (code == TSDB_CODE_SUCCESS) {
- code = mnodeGetSuperTableMeta(pMsg);
- }
- return code;
-}
-
-static int32_t mnodeAddSuperTableColumn(SMnodeMsg *pMsg, SSchema schema[], int32_t ncols) {
- SDbObj *pDb = pMsg->pDb;
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- if (ncols <= 0) {
- mError("msg:%p, app:%p stable:%s, add column, ncols:%d <= 0", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId, ncols);
- return TSDB_CODE_MND_APP_ERROR;
- }
-
- if (pStable->numOfColumns + ncols + pStable->numOfTags > TSDB_MAX_COLUMNS) {
- mError("msg:%p, app:%p stable:%s, add column, too many columns", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId);
- return TSDB_CODE_MND_TOO_MANY_COLUMNS;
- }
-
- for (int32_t i = 0; i < ncols; i++) {
- if (mnodeFindSuperTableColumnIndex(pStable, schema[i].name) > 0) {
- mError("msg:%p, app:%p stable:%s, add column, column:%s already exist", pMsg, pMsg->rpcMsg.ahandle,
- pStable->info.tableId, schema[i].name);
- return TSDB_CODE_MND_FIELD_ALREAY_EXIST;
- }
-
- if (mnodeFindSuperTableTagIndex(pStable, schema[i].name) > 0) {
- mError("msg:%p, app:%p stable:%s, add column, tag:%s already exist", pMsg, pMsg->rpcMsg.ahandle,
- pStable->info.tableId, schema[i].name);
- return TSDB_CODE_MND_TAG_ALREAY_EXIST;
- }
- }
-
- int32_t schemaSize = sizeof(SSchema) * (pStable->numOfTags + pStable->numOfColumns);
- pStable->schema = realloc(pStable->schema, schemaSize + sizeof(SSchema) * ncols);
-
- memmove(pStable->schema + pStable->numOfColumns + ncols, pStable->schema + pStable->numOfColumns,
- sizeof(SSchema) * pStable->numOfTags);
- memcpy(pStable->schema + pStable->numOfColumns, schema, sizeof(SSchema) * ncols);
-
- SSchema *tschema = (SSchema *) (pStable->schema + pStable->numOfColumns);
- for (int32_t i = 0; i < ncols; i++) {
- tschema[i].colId = pStable->nextColId++;
- }
-
- pStable->numOfColumns += ncols;
- pStable->sversion++;
-
- SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
- if (pAcct != NULL) {
- pAcct->acctInfo.numOfTimeSeries += (ncols * pStable->numOfTables);
- mnodeDecAcctRef(pAcct);
- }
-
- mInfo("msg:%p, app:%p stable %s, start to add column", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsSuperTableSdb,
- .pObj = pStable,
- .pMsg = pMsg,
- .fpRsp = mnodeAddSuperTableColumnCb
- };
-
- return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeDropSuperTableColumnCb(SMnodeMsg *pMsg, int32_t code) {
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- mLInfo("msg:%p, app:%p stable %s, delete column result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- tstrerror(code));
- if (code == TSDB_CODE_SUCCESS) {
- code = mnodeGetSuperTableMeta(pMsg);
- }
- return code;
-}
-
-static int32_t mnodeDropSuperTableColumn(SMnodeMsg *pMsg, char *colName) {
- SDbObj *pDb = pMsg->pDb;
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- int32_t col = mnodeFindSuperTableColumnIndex(pStable, colName);
- if (col <= 0) {
- mError("msg:%p, app:%p stable:%s, drop column, column:%s not exist", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- colName);
- return TSDB_CODE_MND_FIELD_NOT_EXIST;
- }
-
- memmove(pStable->schema + col, pStable->schema + col + 1,
- sizeof(SSchema) * (pStable->numOfColumns + pStable->numOfTags - col - 1));
-
- pStable->numOfColumns--;
- pStable->sversion++;
-
- int32_t schemaSize = sizeof(SSchema) * (pStable->numOfTags + pStable->numOfColumns);
- pStable->schema = realloc(pStable->schema, schemaSize);
-
- SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
- if (pAcct != NULL) {
- pAcct->acctInfo.numOfTimeSeries -= pStable->numOfTables;
- mnodeDecAcctRef(pAcct);
- }
-
- mInfo("msg:%p, app:%p stable %s, start to delete column", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsSuperTableSdb,
- .pObj = pStable,
- .pMsg = pMsg,
- .fpRsp = mnodeDropSuperTableColumnCb
- };
-
- return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeChangeSuperTableColumnCb(SMnodeMsg *pMsg, int32_t code) {
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- mLInfo("msg:%p, app:%p stable %s, change column result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- tstrerror(code));
- if (code == TSDB_CODE_SUCCESS) {
- code = mnodeGetSuperTableMeta(pMsg);
- }
- return code;
-}
-
-static int32_t mnodeChangeSuperTableColumn(SMnodeMsg *pMsg) {
- SAlterTableMsg *pAlter = pMsg->rpcMsg.pCont;
- char* name = pAlter->schema[0].name;
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- int32_t col = mnodeFindSuperTableColumnIndex(pStable, name);
- if (col < 0) {
- mError("msg:%p, app:%p stable:%s, change column, name:%s", pMsg, pMsg->rpcMsg.ahandle,
- pStable->info.tableId, name);
- return TSDB_CODE_MND_FIELD_NOT_EXIST;
- }
-
- // check exceed max row bytes
- int32_t i;
- uint32_t nLen = 0;
- for (i = 0; i < pStable->numOfColumns; ++i) {
- nLen += (pStable->schema[i].colId == col) ? pAlter->schema[0].bytes : pStable->schema[i].bytes;
- }
- if (nLen > TSDB_MAX_BYTES_PER_ROW) {
- mError("msg:%p, app:%p stable:%s, change column, name:%s exceed max row bytes", pMsg, pMsg->rpcMsg.ahandle,
- pStable->info.tableId, name);
- return TSDB_CODE_MND_EXCEED_MAX_ROW_BYTES;
- }
-
- // update
- SSchema *schema = (SSchema *) (pStable->schema + col);
- ASSERT(schema->type == TSDB_DATA_TYPE_BINARY || schema->type == TSDB_DATA_TYPE_NCHAR);
-
- if (pAlter->schema[0].bytes <= schema->bytes) {
- mError("msg:%p, app:%p stable:%s, modify column len. column:%s, len from %d to %d", pMsg, pMsg->rpcMsg.ahandle,
- pStable->info.tableId, name, schema->bytes, pAlter->schema[0].bytes);
- return TSDB_CODE_MND_INVALID_COLUMN_LENGTH;
- }
-
- schema->bytes = pAlter->schema[0].bytes;
- pStable->sversion++;
- mInfo("msg:%p, app:%p stable %s, start to modify column %s len to %d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- name, schema->bytes);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsSuperTableSdb,
- .pObj = pStable,
- .pMsg = pMsg,
- .fpRsp = mnodeChangeSuperTableColumnCb
- };
-
- return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeChangeSuperTableTag(SMnodeMsg *pMsg) {
- SAlterTableMsg *pAlter = pMsg->rpcMsg.pCont;
- char* name = pAlter->schema[0].name;
- SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
- int32_t col = mnodeFindSuperTableTagIndex(pStable, name);
- if (col < 0) {
- mError("msg:%p, app:%p stable:%s, change column, name:%s", pMsg, pMsg->rpcMsg.ahandle,
- pStable->info.tableId, name);
- return TSDB_CODE_MND_FIELD_NOT_EXIST;
- }
-
- // update
- SSchema *schema = (SSchema *) (pStable->schema + col + pStable->numOfColumns);
- ASSERT(schema->type == TSDB_DATA_TYPE_BINARY || schema->type == TSDB_DATA_TYPE_NCHAR);
- if (pAlter->schema[0].bytes <= schema->bytes) {
- mError("msg:%p, app:%p stable:%s, modify tag len. tag:%s, len from %d to %d", pMsg, pMsg->rpcMsg.ahandle,
- pStable->info.tableId, name, schema->bytes, pAlter->schema[0].bytes);
- return TSDB_CODE_MND_INVALID_TAG_LENGTH;
- }
-
- schema->bytes = pAlter->schema[0].bytes;
- pStable->tversion++;
- mInfo("msg:%p, app:%p stable %s, start to modify tag len %s to %d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
- name, schema->bytes);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsSuperTableSdb,
- .pObj = pStable,
- .pMsg = pMsg,
- .fpRsp = mnodeChangeSuperTableColumnCb
- };
-
- return sdbUpdateRow(&row);
-}
-
-// show super tables
-static int32_t mnodeGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- SDbObj *pDb = mnodeGetDb(pShow->db);
- if (pDb == NULL) return TSDB_CODE_MND_DB_NOT_SELECTED;
-
- if (pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
- mnodeDecDbRef(pDb);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- SSchema* tbnameSchema = tGetTbnameColumnSchema();
- pShow->bytes[cols] = tbnameSchema->bytes;
- pSchema[cols].type = tbnameSchema->type;
- strcpy(pSchema[cols].name, "name");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "created_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "columns");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "tags");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "tables");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
-
- pShow->numOfRows = pDb->numOfSuperTables;
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
- mnodeDecDbRef(pDb);
- return 0;
-}
-
-// retrieve super tables
-int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- char * pWrite;
- int32_t cols = 0;
- SSTableObj *pTable = NULL;
- char prefix[64] = {0};
- int32_t prefixLen;
-
- SDbObj *pDb = mnodeGetDb(pShow->db);
- if (pDb == NULL) return 0;
-
- if (pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
- mnodeDecDbRef(pDb);
- return 0;
- }
-
- tstrncpy(prefix, pDb->name, 64);
- strcat(prefix, TS_PATH_DELIMITER);
- prefixLen = (int32_t)strlen(prefix);
-
- SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
- char stableName[TSDB_TABLE_NAME_LEN] = {0};
-
- char* pattern = mnodeGetTableShowPattern(pShow);
- if (pShow->payloadLen > 0 && pattern == NULL) {
- return 0;
- }
-
- while (numOfRows < rows) {
- pShow->pIter = mnodeGetNextSuperTable(pShow->pIter, &pTable);
- if (pTable == NULL) break;
- if (strncmp(pTable->info.tableId, prefix, prefixLen)) {
- mnodeDecTableRef(pTable);
- continue;
- }
-
- memset(stableName, 0, tListLen(stableName));
- mnodeExtractTableName(pTable->info.tableId, stableName);
-
- if (pShow->payloadLen > 0 && patternMatch(pattern, stableName, sizeof(stableName) - 1, &info) != TSDB_PATTERN_MATCH) {
- mnodeDecTableRef(pTable);
- continue;
- }
-
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
- int16_t len = (int16_t)strnlen(stableName, TSDB_TABLE_NAME_LEN - 1);
- *(int16_t*) pWrite = len;
- pWrite += sizeof(int16_t); // todo refactor
-
- strncpy(pWrite, stableName, len);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = pTable->createdTime;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = pTable->numOfColumns;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = pTable->numOfTags;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = pTable->numOfTables;
- cols++;
-
- numOfRows++;
- mnodeDecTableRef(pTable);
- }
-
- pShow->numOfReads += numOfRows;
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- mnodeDecDbRef(pDb);
- free(pattern);
-
- return numOfRows;
-}
-
-void mnodeDropAllSuperTables(SDbObj *pDropDb) {
- void * pIter= NULL;
- int32_t numOfTables = 0;
- SSTableObj *pTable = NULL;
-
- char prefix[64] = {0};
- tstrncpy(prefix, pDropDb->name, 64);
- strcat(prefix, TS_PATH_DELIMITER);
- int32_t prefixLen = (int32_t)strlen(prefix);
-
- mInfo("db:%s, all super tables will be dropped from sdb", pDropDb->name);
-
- while (1) {
- pIter = mnodeGetNextSuperTable(pIter, &pTable);
- if (pTable == NULL) break;
-
- if (strncmp(prefix, pTable->info.tableId, prefixLen) == 0) {
- SSdbRow row = {
- .type = SDB_OPER_LOCAL,
- .pTable = tsSuperTableSdb,
- .pObj = pTable,
- };
- sdbDeleteRow(&row);
- numOfTables ++;
- }
-
- mnodeDecTableRef(pTable);
- }
-
- mInfo("db:%s, all super tables:%d is dropped from sdb", pDropDb->name, numOfTables);
-}
-
-static int32_t mnodeSetSchemaFromSuperTable(SSchema *pSchema, SSTableObj *pTable) {
- int32_t numOfCols = pTable->numOfColumns + pTable->numOfTags;
- assert(numOfCols <= TSDB_MAX_COLUMNS);
-
- for (int32_t i = 0; i < numOfCols; ++i) {
- tstrncpy(pSchema->name, pTable->schema[i].name, sizeof(pSchema->name));
- pSchema->type = pTable->schema[i].type;
- pSchema->bytes = htons(pTable->schema[i].bytes);
- pSchema->colId = htons(pTable->schema[i].colId);
- pSchema++;
- }
-
- return (pTable->numOfColumns + pTable->numOfTags) * sizeof(SSchema);
-}
-
-static int32_t mnodeDoGetSuperTableMeta(SMnodeMsg *pMsg, STableMetaMsg* pMeta) {
- SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
-
- pMeta->uid = htobe64(pTable->uid);
- pMeta->sversion = htons(pTable->sversion);
- pMeta->tversion = htons(pTable->tversion);
- pMeta->precision = pMsg->pDb->cfg.precision;
- pMeta->numOfTags = (uint8_t)pTable->numOfTags;
- pMeta->numOfColumns = htons((int16_t)pTable->numOfColumns);
- pMeta->tableType = pTable->info.type;
- pMeta->contLen = sizeof(STableMetaMsg) + mnodeSetSchemaFromSuperTable(pMeta->schema, pTable);
- tstrncpy(pMeta->tableFname, pTable->info.tableId, sizeof(pMeta->tableFname));
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) {
- SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
- STableMetaMsg *pMeta = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16));
- if (pMeta == NULL) {
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- mnodeDoGetSuperTableMeta(pMsg, pMeta);
-
- pMsg->rpcRsp.len = pMeta->contLen;
- pMeta->contLen = htons(pMeta->contLen);
-
- pMsg->rpcRsp.rsp = pMeta;
-
- mDebug("msg:%p, app:%p stable:%s, uid:%" PRIu64 " table meta is retrieved, sizeOfVgList:%d numOfTables:%d", pMsg,
- pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->uid, taosHashGetSize(pTable->vgHash), pTable->numOfTables);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t doGetVgroupInfoLength(char* name) {
- SSTableObj *pTable = mnodeGetSuperTable(name);
- int32_t len = 0;
- if (pTable != NULL && pTable->vgHash != NULL) {
- len = (taosHashGetSize(pTable->vgHash) * sizeof(SVgroupMsg) + sizeof(SVgroupsMsg));
- }
-
- mnodeDecTableRef(pTable);
- return len;
-}
-
-static int32_t getVgroupInfoLength(SSTableVgroupMsg* pInfo, int32_t numOfTable) {
- int32_t contLen = sizeof(SSTableVgroupRspMsg) + 32 * sizeof(SVgroupMsg) + sizeof(SVgroupsMsg);
- for (int32_t i = 0; i < numOfTable; ++i) {
- char *stableName = (char *)pInfo + sizeof(SSTableVgroupMsg) + (TSDB_TABLE_FNAME_LEN)*i;
- contLen += doGetVgroupInfoLength(stableName);
- }
-
- return contLen;
-}
-
-static char* serializeVgroupInfo(SSTableObj *pTable, char* name, char* msg, SMnodeMsg* pMsgBody, void* handle) {
- strncpy(msg, name, TSDB_TABLE_FNAME_LEN);
- msg += TSDB_TABLE_FNAME_LEN;
-
- if (pTable->vgHash == NULL) {
- mDebug("msg:%p, app:%p stable:%s, no vgroup exist while get stable vgroup info", pMsgBody, handle, name);
- mnodeDecTableRef(pTable);
-
- // even this super table has no corresponding table, still return
- SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
- pVgroupMsg->numOfVgroups = 0;
-
- msg += sizeof(SVgroupsMsg);
- } else {
- SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
- mDebug("msg:%p, app:%p stable:%s, hash:%p sizeOfVgList:%d will be returned", pMsgBody, handle,
- pTable->info.tableId, pTable->vgHash, taosHashGetSize(pTable->vgHash));
-
- int32_t *pVgId = taosHashIterate(pTable->vgHash, NULL);
- int32_t vgSize = 0;
- while (pVgId) {
- SVgObj *pVgroup = mnodeGetVgroup(*pVgId);
- pVgId = taosHashIterate(pTable->vgHash, pVgId);
- if (pVgroup == NULL) {
- continue;
- }
-
- pVgroupMsg->vgroups[vgSize].vgId = htonl(pVgroup->vgId);
- pVgroupMsg->vgroups[vgSize].numOfEps = 0;
-
- for (int32_t vn = 0; vn < pVgroup->numOfVnodes; ++vn) {
- SDnodeObj *pDnode = pVgroup->vnodeGid[vn].pDnode;
- if (pDnode == NULL) break;
-
- tstrncpy(pVgroupMsg->vgroups[vgSize].epAddr[vn].fqdn, pDnode->dnodeFqdn, TSDB_FQDN_LEN);
- pVgroupMsg->vgroups[vgSize].epAddr[vn].port = htons(pDnode->dnodePort);
-
- pVgroupMsg->vgroups[vgSize].numOfEps++;
- }
-
- vgSize++;
- mnodeDecVgroupRef(pVgroup);
- }
-
- taosHashCancelIterate(pTable->vgHash, pVgId);
- mnodeDecTableRef(pTable);
-
- pVgroupMsg->numOfVgroups = htonl(vgSize);
-
- // one table is done, try the next table
- msg += sizeof(SVgroupsMsg) + vgSize * sizeof(SVgroupMsg);
- }
-
- return msg;
-}
-
-static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
- SSTableVgroupMsg *pInfo = pMsg->rpcMsg.pCont;
- int32_t numOfTable = htonl(pInfo->numOfTables);
-
- // calculate the required space.
- int32_t contLen = getVgroupInfoLength(pInfo, numOfTable);
- SSTableVgroupRspMsg *pRsp = rpcMallocCont(contLen);
- if (pRsp == NULL) {
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- pRsp->numOfTables = 0;
- char *msg = (char *)pRsp + sizeof(SSTableVgroupRspMsg);
-
- for (int32_t i = 0; i < numOfTable; ++i) {
- char *stableName = (char *)pInfo + sizeof(SSTableVgroupMsg) + (TSDB_TABLE_FNAME_LEN)*i;
-
- SSTableObj *pTable = mnodeGetSuperTable(stableName);
- if (pTable == NULL) {
- mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, stableName);
- mnodeDecTableRef(pTable);
- continue;
- }
-
- msg = serializeVgroupInfo(pTable, stableName, msg, pMsg, pMsg->rpcMsg.ahandle);
- pRsp->numOfTables++;
- }
-
- if (pRsp->numOfTables != numOfTable) {
- rpcFreeCont(pRsp);
- return TSDB_CODE_MND_INVALID_TABLE_NAME;
- } else {
- pRsp->numOfTables = (int32_t)htonl(pRsp->numOfTables);
- pMsg->rpcRsp.rsp = pRsp;
- pMsg->rpcRsp.len = (int32_t)((char *)msg - (char *)pRsp);
-
- return TSDB_CODE_SUCCESS;
- }
-}
-
-static void mnodeProcessDropSuperTableRsp(SRpcMsg *rpcMsg) {
- mInfo("drop stable rsp received, result:%s", tstrerror(rpcMsg->code));
-}
-
-static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pCreateMsg, SCTableObj *pTable) {
- SCreateTableMsg* pMsg = (SCreateTableMsg*) ((char*)pCreateMsg + sizeof(SCMCreateTableMsg));
-
- char* tagData = NULL;
-
- int32_t tagDataLen = 0;
- int32_t totalCols = 0;
- int32_t contLen = 0;
- if (pTable->info.type == TSDB_CHILD_TABLE) {
- totalCols = pTable->superTable->numOfColumns + pTable->superTable->numOfTags;
- contLen = sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema) + pTable->sqlLen;
- if (pMsg != NULL) {
- int32_t nameLen = htonl(*(int32_t*)pMsg->schema);
- char* p = pMsg->schema + nameLen + sizeof(int32_t);
-
- tagDataLen = htonl(*(int32_t*) p);
- contLen += tagDataLen;
-
- tagData = p + sizeof(int32_t);
- }
- } else {
- totalCols = pTable->numOfColumns;
- contLen = sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema) + pTable->sqlLen;
- }
-
- SMDCreateTableMsg *pCreate = rpcMallocCont(contLen);
- if (pCreate == NULL) {
- terrno = TSDB_CODE_MND_OUT_OF_MEMORY;
- return NULL;
- }
-
- mnodeExtractTableName(pTable->info.tableId, pCreate->tableFname);
- pCreate->contLen = htonl(contLen);
- pCreate->vgId = htonl(pTable->vgId);
- pCreate->tableType = pTable->info.type;
- pCreate->createdTime = htobe64(pTable->createdTime);
- pCreate->tid = htonl(pTable->tid);
- pCreate->sqlDataLen = htonl(pTable->sqlLen);
- pCreate->uid = htobe64(pTable->uid);
-
- if (pTable->info.type == TSDB_CHILD_TABLE) {
- mnodeExtractTableName(pTable->superTable->info.tableId, pCreate->stableFname);
- pCreate->numOfColumns = htons(pTable->superTable->numOfColumns);
- pCreate->numOfTags = htons(pTable->superTable->numOfTags);
- pCreate->sversion = htonl(pTable->superTable->sversion);
- pCreate->tversion = htonl(pTable->superTable->tversion);
- pCreate->tagDataLen = htonl(tagDataLen);
- pCreate->superTableUid = htobe64(pTable->superTable->uid);
- } else {
- pCreate->numOfColumns = htons(pTable->numOfColumns);
- pCreate->numOfTags = 0;
- pCreate->sversion = htonl(pTable->sversion);
- pCreate->tversion = 0;
- pCreate->tagDataLen = 0;
- pCreate->superTableUid = 0;
- }
-
- SSchema *pSchema = (SSchema *) pCreate->data;
- if (pTable->info.type == TSDB_CHILD_TABLE) {
- memcpy(pSchema, pTable->superTable->schema, totalCols * sizeof(SSchema));
- } else {
- memcpy(pSchema, pTable->schema, totalCols * sizeof(SSchema));
- }
- for (int32_t col = 0; col < totalCols; ++col) {
- pSchema->bytes = htons(pSchema->bytes);
- pSchema->colId = htons(pSchema->colId);
- pSchema++;
- }
-
- if (pTable->info.type == TSDB_CHILD_TABLE && pMsg != NULL) {
- memcpy(pCreate->data + totalCols * sizeof(SSchema), tagData, tagDataLen);
- }
-
- if (pTable->info.type == TSDB_STREAM_TABLE) {
- memcpy(pCreate->data + totalCols * sizeof(SSchema), pTable->sql, pTable->sqlLen);
- }
-
- return pCreate;
-}
-
-static int32_t mnodeDoCreateChildTableFp(SMnodeMsg *pMsg) {
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
- assert(pTable);
-
- mDebug("msg:%p, app:%p table:%s, created in mnode, vgId:%d sid:%d, uid:%" PRIu64, pMsg, pMsg->rpcMsg.ahandle,
- pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid);
-
- SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
- SMDCreateTableMsg *pMDCreate = mnodeBuildCreateChildTableMsg(pCreate, pTable);
- if (pMDCreate == NULL) {
- return terrno;
- }
-
- SRpcEpSet epSet = mnodeGetEpSetFromVgroup(pMsg->pVgroup);
- SRpcMsg rpcMsg = {
- .ahandle = pMsg,
- .pCont = pMDCreate,
- .contLen = htonl(pMDCreate->contLen),
- .code = 0,
- .msgType = TSDB_MSG_TYPE_MD_CREATE_TABLE
- };
-
- dnodeSendMsgToDnode(&epSet, &rpcMsg);
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-static int32_t mnodeDoCreateChildTableCb(SMnodeMsg *pMsg, int32_t code) {
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-
- SCreateTableMsg *pCreate = (SCreateTableMsg*) ((char*)pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
- assert(pTable);
-
- if (code == TSDB_CODE_SUCCESS) {
- if (pCreate->getMeta) {
- mDebug("msg:%p, app:%p table:%s, created in dnode and continue to get meta, thandle:%p", pMsg,
- pMsg->rpcMsg.ahandle, pTable->info.tableId, pMsg->rpcMsg.handle);
-
- pMsg->retry = 0;
- dnodeReprocessMWriteMsg(pMsg);
- } else {
- mDebug("msg:%p, app:%p table:%s, created in dnode, thandle:%p", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
- pMsg->rpcMsg.handle);
-
- if (pMsg->pBatchMasterMsg) {
- ++pMsg->pBatchMasterMsg->successed;
- if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received >= pMsg->pBatchMasterMsg->expected) {
- dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, code);
- }
-
- mnodeDestroySubMsg(pMsg);
-
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
- }
-
- dnodeSendRpcMWriteRsp(pMsg, TSDB_CODE_SUCCESS);
- }
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
- } else {
- mError("msg:%p, app:%p table:%s, failed to create table sid:%d, uid:%" PRIu64 ", reason:%s", pMsg,
- pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->tid, pTable->uid, tstrerror(code));
- SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pTable, .pTable = tsChildTableSdb};
- sdbDeleteRow(&desc);
-
- if (pMsg->pBatchMasterMsg) {
- ++pMsg->pBatchMasterMsg->received;
- pMsg->pBatchMasterMsg->code = code;
- if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received >= pMsg->pBatchMasterMsg->expected) {
- dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, code);
- }
-
- mnodeDestroySubMsg(pMsg);
-
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
- }
-
- return code;
- }
-}
-
-static int32_t mnodeDoCreateChildTable(SMnodeMsg *pMsg, int32_t tid) {
- SVgObj *pVgroup = pMsg->pVgroup;
-
- SCMCreateTableMsg *p1 = pMsg->rpcMsg.pCont;
- SCreateTableMsg *pCreate = (SCreateTableMsg*)((char*)p1 + sizeof(SCMCreateTableMsg));
-
- SCTableObj *pTable = calloc(1, sizeof(SCTableObj));
- if (pTable == NULL) {
- mError("msg:%p, app:%p table:%s, failed to alloc memory", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- pTable->info.type = (pCreate->numOfColumns == 0)? TSDB_CHILD_TABLE:TSDB_NORMAL_TABLE;
- pTable->info.tableId = strdup(pCreate->tableName);
- pTable->createdTime = taosGetTimestampMs();
- pTable->tid = tid;
- pTable->vgId = pVgroup->vgId;
-
- if (pTable->info.type == TSDB_CHILD_TABLE) {
- int32_t nameLen = htonl(*(int32_t*) pCreate->schema);
- char* name = (char*)pCreate->schema + sizeof(int32_t);
-
- char stableName[TSDB_TABLE_FNAME_LEN] = {0};
- memcpy(stableName, name, nameLen);
-
- char prefix[64] = {0};
- size_t prefixLen = tableIdPrefix(pMsg->pDb->name, prefix, 64);
- if (0 != strncasecmp(prefix, stableName, prefixLen)) {
- mError("msg:%p, app:%p table:%s, corresponding super table:%s not in this db", pMsg, pMsg->rpcMsg.ahandle,
- pCreate->tableName, stableName);
- mnodeDestroyChildTable(pTable);
- return TSDB_CODE_TDB_INVALID_CREATE_TB_MSG;
- }
-
- if (pMsg->pSTable == NULL) pMsg->pSTable = mnodeGetSuperTable(stableName);
- if (pMsg->pSTable == NULL) {
- mError("msg:%p, app:%p table:%s, corresponding super table:%s does not exist", pMsg, pMsg->rpcMsg.ahandle,
- pCreate->tableName, stableName);
- mnodeDestroyChildTable(pTable);
- return TSDB_CODE_MND_INVALID_TABLE_NAME;
- }
-
- pTable->suid = pMsg->pSTable->uid;
- pTable->uid = mnodeCreateTableUid(pTable->vgId, pTable->tid);
- pTable->superTable = pMsg->pSTable;
- } else {
- if (pTable->info.type == TSDB_SUPER_TABLE) {
- pTable->uid = mnodeCreateSuperTableUid();
- } else {
- pTable->uid = mnodeCreateTableUid(pTable->vgId, pTable->tid);
- }
-
- pTable->sversion = 0;
- pTable->numOfColumns = htons(pCreate->numOfColumns);
- pTable->sqlLen = htons(pCreate->sqlLen);
-
- int32_t numOfCols = pTable->numOfColumns;
- int32_t schemaSize = numOfCols * sizeof(SSchema);
- pTable->schema = (SSchema *) calloc(1, schemaSize);
- if (pTable->schema == NULL) {
- free(pTable);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
- memcpy(pTable->schema, pCreate->schema, numOfCols * sizeof(SSchema));
-
- pTable->nextColId = 0;
- for (int32_t col = 0; col < numOfCols; col++) {
- SSchema *tschema = pTable->schema;
- tschema[col].colId = pTable->nextColId++;
- tschema[col].bytes = htons(tschema[col].bytes);
- }
-
- if (pTable->sqlLen != 0) {
- pTable->info.type = TSDB_STREAM_TABLE;
- pTable->sql = calloc(1, pTable->sqlLen);
- if (pTable->sql == NULL) {
- free(pTable);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
- memcpy(pTable->sql, (char *) (pCreate->schema) + numOfCols * sizeof(SSchema), pTable->sqlLen);
- pTable->sql[pTable->sqlLen - 1] = 0;
- mDebug("msg:%p, app:%p table:%s, stream sql len:%d sql:%s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
- pTable->sqlLen, pTable->sql);
- }
- }
-
- pMsg->pTable = (STableObj *)pTable;
- mnodeIncTableRef(pMsg->pTable);
-
- SSdbRow desc = {
- .type = SDB_OPER_GLOBAL,
- .pObj = pTable,
- .pTable = tsChildTableSdb,
- .pMsg = pMsg,
- .fpReq = mnodeDoCreateChildTableFp
- };
-
- int32_t code = sdbInsertRow(&desc);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mnodeDestroyChildTable(pTable);
- pMsg->pTable = NULL;
- mError("msg:%p, app:%p table:%s, failed to create, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName,
- tstrerror(code));
- } else {
- mDebug("msg:%p, app:%p table:%s, allocated in vgroup, vgId:%d sid:%d uid:%" PRIu64, pMsg, pMsg->rpcMsg.ahandle,
- pTable->info.tableId, pVgroup->vgId, pTable->tid, pTable->uid);
- }
-
- return code;
-}
-
-static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) {
- //SCMCreateTableMsg* p1 = pMsg->rpcMsg.pCont; // there are several tables here.
- SCreateTableMsg* pCreate = (SCreateTableMsg*)((char *)pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
-
- int32_t code = grantCheck(TSDB_GRANT_TIMESERIES);
- if (code != TSDB_CODE_SUCCESS) {
- mError("msg:%p, app:%p table:%s, failed to create, grant timeseries failed", pMsg, pMsg->rpcMsg.ahandle,
- pCreate->tableName);
- return code;
- }
-
- if (pMsg->retry == 0) {
- if (pMsg->pTable == NULL) {
- SVgObj *pVgroup = NULL;
- int32_t tid = 0;
- code = mnodeGetAvailableVgroup(pMsg, &pVgroup, &tid);
- if (code != TSDB_CODE_SUCCESS) {
- mDebug("msg:%p, app:%p table:%s, failed to get available vgroup, reason:%s", pMsg, pMsg->rpcMsg.ahandle,
- pCreate->tableName, tstrerror(code));
- return code;
- }
-
- if (pMsg->pVgroup != NULL) {
- mnodeDecVgroupRef(pMsg->pVgroup);
- }
-
- pMsg->pVgroup = pVgroup;
- mnodeIncVgroupRef(pVgroup);
-
- return mnodeDoCreateChildTable(pMsg, tid);
- }
- } else {
- if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pCreate->tableName);
- }
-
- if (pMsg->pTable == NULL) {
- mError("msg:%p, app:%p table:%s, object not found, retry:%d reason:%s", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName, pMsg->retry,
- tstrerror(terrno));
- return terrno;
- } else {
- mDebug("msg:%p, app:%p table:%s, send create msg to vnode again", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableName);
- return mnodeDoCreateChildTableFp(pMsg);
- }
-}
-
-static int32_t mnodeSendDropChildTableMsg(SMnodeMsg *pMsg, bool needReturn) {
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
- mLInfo("msg:%p, app:%p ctable:%s, is dropped from sdb", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
-
- SMDDropTableMsg *pDrop = rpcMallocCont(sizeof(SMDDropTableMsg));
- if (pDrop == NULL) {
- mError("msg:%p, app:%p ctable:%s, failed to drop ctable, no enough memory", pMsg, pMsg->rpcMsg.ahandle,
- pTable->info.tableId);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- tstrncpy(pDrop->tableFname, pTable->info.tableId, TSDB_TABLE_FNAME_LEN);
- pDrop->vgId = htonl(pTable->vgId);
- pDrop->contLen = htonl(sizeof(SMDDropTableMsg));
- pDrop->tid = htonl(pTable->tid);
- pDrop->uid = htobe64(pTable->uid);
-
- SRpcEpSet epSet = mnodeGetEpSetFromVgroup(pMsg->pVgroup);
-
- mInfo("msg:%p, app:%p ctable:%s, send drop ctable msg, vgId:%d sid:%d uid:%" PRIu64, pMsg, pMsg->rpcMsg.ahandle,
- pDrop->tableFname, pTable->vgId, pTable->tid, pTable->uid);
-
- SRpcMsg rpcMsg = {
- .ahandle = pMsg,
- .pCont = pDrop,
- .contLen = sizeof(SMDDropTableMsg),
- .code = 0,
- .msgType = TSDB_MSG_TYPE_MD_DROP_TABLE
- };
-
- if (!needReturn) rpcMsg.ahandle = NULL;
-
- dnodeSendMsgToDnode(&epSet, &rpcMsg);
-
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-static int32_t mnodeDropChildTableCb(SMnodeMsg *pMsg, int32_t code) {
- if (code != TSDB_CODE_SUCCESS) {
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
- mError("msg:%p, app:%p ctable:%s, failed to drop, sdb error", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
- return code;
- }
-
- return mnodeSendDropChildTableMsg(pMsg, true);
-}
-
-static int32_t mnodeProcessDropChildTableMsg(SMnodeMsg *pMsg) {
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
- if (pMsg->pVgroup == NULL) pMsg->pVgroup = mnodeGetVgroup(pTable->vgId);
- if (pMsg->pVgroup == NULL) {
- mError("msg:%p, app:%p table:%s, failed to drop ctable, vgroup not exist", pMsg, pMsg->rpcMsg.ahandle,
- pTable->info.tableId);
- return TSDB_CODE_MND_APP_ERROR;
- }
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsChildTableSdb,
- .pObj = pTable,
- .pMsg = pMsg,
- .fpRsp = mnodeDropChildTableCb
- };
-
- int32_t code = sdbDeleteRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("msg:%p, app:%p ctable:%s, failed to drop, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
- tstrerror(code));
- }
-
- return code;
-}
-
-static int32_t mnodeFindNormalTableColumnIndex(SCTableObj *pTable, char *colName) {
- SSchema *schema = (SSchema *) pTable->schema;
- for (int32_t col = 0; col < pTable->numOfColumns; col++) {
- if (strcasecmp(schema[col].name, colName) == 0) {
- return col;
- }
- }
-
- return -1;
-}
-
-static int32_t mnodeAlterNormalTableColumnCb(SMnodeMsg *pMsg, int32_t code) {
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
- if (code != TSDB_CODE_SUCCESS) {
- mError("msg:%p, app:%p ctable %s, failed to alter column, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
- tstrerror(code));
- return code;
- }
-
- SMDCreateTableMsg *pMDCreate = mnodeBuildCreateChildTableMsg(NULL, pTable);
- if (pMDCreate == NULL) {
- return terrno;
- }
-
- if (pMsg->pVgroup == NULL) {
- pMsg->pVgroup = mnodeGetVgroup(pTable->vgId);
- if (pMsg->pVgroup == NULL) {
- rpcFreeCont(pMDCreate);
- mError("msg:%p, app:%p ctable %s, vgId:%d not exist in mnode", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
- pTable->vgId);
- return TSDB_CODE_MND_VGROUP_NOT_EXIST;
- }
- }
-
- SRpcEpSet epSet = mnodeGetEpSetFromVgroup(pMsg->pVgroup);
- SRpcMsg rpcMsg = {
- .ahandle = pMsg,
- .pCont = pMDCreate,
- .contLen = htonl(pMDCreate->contLen),
- .code = 0,
- .msgType = TSDB_MSG_TYPE_MD_ALTER_TABLE
- };
-
- mDebug("msg:%p, app:%p ctable %s, send alter column msg to vgId:%d", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
- pMsg->pVgroup->vgId);
-
- dnodeSendMsgToDnode(&epSet, &rpcMsg);
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-static int32_t mnodeAddNormalTableColumn(SMnodeMsg *pMsg, SSchema schema[], int32_t ncols) {
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
- SDbObj *pDb = pMsg->pDb;
- if (ncols <= 0) {
- mError("msg:%p, app:%p ctable:%s, add column, ncols:%d <= 0", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId, ncols);
- return TSDB_CODE_MND_APP_ERROR;
- }
-
- for (int32_t i = 0; i < ncols; i++) {
- if (mnodeFindNormalTableColumnIndex(pTable, schema[i].name) > 0) {
- mError("msg:%p, app:%p ctable:%s, add column, column:%s already exist", pMsg, pMsg->rpcMsg.ahandle,
- pTable->info.tableId, schema[i].name);
- return TSDB_CODE_MND_FIELD_ALREAY_EXIST;
- }
- }
-
- int32_t schemaSize = pTable->numOfColumns * sizeof(SSchema);
- pTable->schema = realloc(pTable->schema, schemaSize + sizeof(SSchema) * ncols);
-
- memcpy(pTable->schema + pTable->numOfColumns, schema, sizeof(SSchema) * ncols);
-
- SSchema *tschema = (SSchema *) (pTable->schema + pTable->numOfColumns);
- for (int32_t i = 0; i < ncols; i++) {
- tschema[i].colId = pTable->nextColId++;
- }
-
- pTable->numOfColumns += ncols;
- pTable->sversion++;
-
- SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
- if (pAcct != NULL) {
- pAcct->acctInfo.numOfTimeSeries += ncols;
- mnodeDecAcctRef(pAcct);
- }
-
- mInfo("msg:%p, app:%p ctable %s, start to add column", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsChildTableSdb,
- .pObj = pTable,
- .pMsg = pMsg,
- .fpRsp = mnodeAlterNormalTableColumnCb
- };
-
- return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeDropNormalTableColumn(SMnodeMsg *pMsg, char *colName) {
- SDbObj *pDb = pMsg->pDb;
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
- int32_t col = mnodeFindNormalTableColumnIndex(pTable, colName);
- if (col <= 0) {
- mError("msg:%p, app:%p ctable:%s, drop column, column:%s not exist", pMsg, pMsg->rpcMsg.ahandle,
- pTable->info.tableId, colName);
- return TSDB_CODE_MND_FIELD_NOT_EXIST;
- }
-
- memmove(pTable->schema + col, pTable->schema + col + 1, sizeof(SSchema) * (pTable->numOfColumns - col - 1));
- pTable->numOfColumns--;
- pTable->sversion++;
-
- SAcctObj *pAcct = mnodeGetAcct(pDb->acct);
- if (pAcct != NULL) {
- pAcct->acctInfo.numOfTimeSeries--;
- mnodeDecAcctRef(pAcct);
- }
-
- mInfo("msg:%p, app:%p ctable %s, start to drop column %s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId, colName);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsChildTableSdb,
- .pObj = pTable,
- .pMsg = pMsg,
- .fpRsp = mnodeAlterNormalTableColumnCb
- };
-
- return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeChangeNormalTableColumn(SMnodeMsg *pMsg) {
- SAlterTableMsg *pAlter = pMsg->rpcMsg.pCont;
- char* name = pAlter->schema[0].name;
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
- int32_t col = mnodeFindNormalTableColumnIndex(pTable, name);
- if (col < 0) {
- mError("msg:%p, app:%p ctable:%s, change column, name: %s", pMsg, pMsg->rpcMsg.ahandle,
- pTable->info.tableId, name);
- return TSDB_CODE_MND_FIELD_NOT_EXIST;
- }
-
- SSchema *schema = (SSchema *) (pTable->schema + col);
- ASSERT(schema->type == TSDB_DATA_TYPE_BINARY || schema->type == TSDB_DATA_TYPE_NCHAR);
- schema->bytes = pAlter->schema[0].bytes;
-
- mInfo("msg:%p, app:%p ctable %s, start to modify column %s len to %d", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
- name, schema->bytes);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsChildTableSdb,
- .pObj = pTable,
- .pMsg = pMsg,
- .fpRsp = mnodeAlterNormalTableColumnCb
- };
-
- return sdbUpdateRow(&row);
-}
-
-static int32_t mnodeSetSchemaFromNormalTable(SSchema *pSchema, SCTableObj *pTable) {
- int32_t numOfCols = pTable->numOfColumns;
- for (int32_t i = 0; i < numOfCols; ++i) {
- strcpy(pSchema->name, pTable->schema[i].name);
- pSchema->type = pTable->schema[i].type;
- pSchema->bytes = htons(pTable->schema[i].bytes);
- pSchema->colId = htons(pTable->schema[i].colId);
- pSchema++;
- }
-
- return numOfCols * sizeof(SSchema);
-}
-
-static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) {
- SDbObj *pDb = pMsg->pDb;
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-
- pMeta->uid = htobe64(pTable->uid);
- pMeta->tid = htonl(pTable->tid);
- pMeta->precision = pDb->cfg.precision;
- pMeta->tableType = pTable->info.type;
- tstrncpy(pMeta->tableFname, pTable->info.tableId, TSDB_TABLE_FNAME_LEN);
-
- if (pTable->info.type == TSDB_CHILD_TABLE) {
- assert(pTable->superTable != NULL);
- tstrncpy(pMeta->sTableName, pTable->superTable->info.tableId, TSDB_TABLE_FNAME_LEN);
-
- pMeta->suid = pTable->superTable->uid;
- pMeta->sversion = htons(pTable->superTable->sversion);
- pMeta->tversion = htons(pTable->superTable->tversion);
- pMeta->numOfTags = (int8_t)pTable->superTable->numOfTags;
- pMeta->numOfColumns = htons((int16_t)pTable->superTable->numOfColumns);
- pMeta->contLen = sizeof(STableMetaMsg) + mnodeSetSchemaFromSuperTable(pMeta->schema, pTable->superTable);
- } else {
- pMeta->sversion = htons(pTable->sversion);
- pMeta->tversion = 0;
- pMeta->numOfTags = 0;
- pMeta->numOfColumns = htons((int16_t)pTable->numOfColumns);
- pMeta->contLen = sizeof(STableMetaMsg) + mnodeSetSchemaFromNormalTable(pMeta->schema, pTable);
- }
-
- if (pMsg->pVgroup == NULL) pMsg->pVgroup = mnodeGetVgroup(pTable->vgId);
- if (pMsg->pVgroup == NULL) {
- mError("msg:%p, app:%p table:%s, failed to get table meta, vgroup not exist", pMsg, pMsg->rpcMsg.ahandle,
- pTable->info.tableId);
- return TSDB_CODE_MND_VGROUP_NOT_EXIST;
- }
-
- for (int32_t i = 0; i < pMsg->pVgroup->numOfVnodes; ++i) {
- SDnodeObj *pDnode = mnodeGetDnode(pMsg->pVgroup->vnodeGid[i].dnodeId);
- if (pDnode == NULL) break;
- strcpy(pMeta->vgroup.epAddr[i].fqdn, pDnode->dnodeFqdn);
- pMeta->vgroup.epAddr[i].port = htons(pDnode->dnodePort + TSDB_PORT_DNODESHELL);
- pMeta->vgroup.numOfEps++;
- mnodeDecDnodeRef(pDnode);
- }
-
- pMeta->vgroup.vgId = htonl(pMsg->pVgroup->vgId);
- mDebug("msg:%p, app:%p table:%s, uid:%" PRIu64 " table meta is retrieved, vgId:%d tid:%d", pMsg, pMsg->rpcMsg.ahandle,
- pTable->info.tableId, pTable->uid, pTable->vgId, pTable->tid);
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg) {
- STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
-
- if (pMsg->rpcMsg.contLen <= sizeof(*pInfo)) {
- mError("msg:%p, app:%p table:%s, failed to auto create child table, tags not exist", pMsg, pMsg->rpcMsg.ahandle,
- pInfo->tableFname);
- return TSDB_CODE_MND_TAG_NOT_EXIST;
- }
-
- char* p = pInfo->tags;
- int32_t nameLen = htonl(*(int32_t*) p);
- p += sizeof(int32_t);
- p += nameLen;
-
- int32_t tagLen = htonl(*(int32_t*) p);
- p += sizeof(int32_t);
-
- int32_t totalLen = nameLen + tagLen + sizeof(int32_t)*2;
- if (tagLen == 0 || nameLen == 0) {
- mError("msg:%p, app:%p table:%s, failed to create table on demand for super table is empty, tagLen:%d", pMsg,
- pMsg->rpcMsg.ahandle, pInfo->tableFname, tagLen);
- return TSDB_CODE_MND_INVALID_STABLE_NAME;
- }
-
- int32_t contLen = sizeof(SCMCreateTableMsg) + sizeof(SCreateTableMsg) + totalLen;
- SCMCreateTableMsg *pCreateMsg = calloc(1, contLen);
- if (pCreateMsg == NULL) {
- mError("msg:%p, app:%p table:%s, failed to create table while get meta info, no enough memory", pMsg,
- pMsg->rpcMsg.ahandle, pInfo->tableFname);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- SCreateTableMsg* pCreate = (SCreateTableMsg*) ((char*) pCreateMsg + sizeof(SCMCreateTableMsg));
-
- size_t size = tListLen(pInfo->tableFname);
- tstrncpy(pCreate->tableName, pInfo->tableFname, size);
- pCreate->igExists = 1;
- pCreate->getMeta = 1;
-
- pCreateMsg->numOfTables = htonl(1);
- pCreateMsg->contLen = htonl(contLen);
-
- memcpy(pCreate->schema, pInfo->tags, totalLen);
-
- char name[TSDB_TABLE_FNAME_LEN] = {0};
- memcpy(name, pInfo->tags + sizeof(int32_t), nameLen);
-
- mDebug("msg:%p, app:%p table:%s, start to create on demand, tagLen:%d stable:%s", pMsg, pMsg->rpcMsg.ahandle,
- pInfo->tableFname, tagLen, name);
-
- if (pMsg->rpcMsg.pCont != pMsg->pCont) {
- tfree(pMsg->rpcMsg.pCont);
- }
- pMsg->rpcMsg.msgType = TSDB_MSG_TYPE_CM_CREATE_TABLE;
- pMsg->rpcMsg.pCont = pCreateMsg;
- pMsg->rpcMsg.contLen = contLen;
-
- return TSDB_CODE_MND_ACTION_NEED_REPROCESSED;
-}
-
-static int32_t mnodeGetChildTableMeta(SMnodeMsg *pMsg) {
- STableMetaMsg *pMeta =
- rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16));
- if (pMeta == NULL) {
- mError("msg:%p, app:%p table:%s, failed to get table meta, no enough memory", pMsg, pMsg->rpcMsg.ahandle,
- pMsg->pTable->tableId);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- }
-
- mnodeDoGetChildTableMeta(pMsg, pMeta);
-
- pMsg->rpcRsp.len = pMeta->contLen;
- pMsg->rpcRsp.rsp = pMeta;
- pMeta->contLen = htons(pMeta->contLen);
-
- return TSDB_CODE_SUCCESS;
-}
-
-void mnodeDropAllChildTablesInVgroups(SVgObj *pVgroup) {
- void * pIter = NULL;
- int32_t numOfTables = 0;
- SCTableObj *pTable = NULL;
-
- mInfo("vgId:%d, all child tables will be dropped from sdb", pVgroup->vgId);
-
- while (1) {
- pIter = mnodeGetNextChildTable(pIter, &pTable);
- if (pTable == NULL) break;
-
- if (pTable->vgId == pVgroup->vgId) {
- SSdbRow row = {
- .type = SDB_OPER_LOCAL,
- .pTable = tsChildTableSdb,
- .pObj = pTable,
- };
- sdbDeleteRow(&row);
- numOfTables++;
- }
- mnodeDecTableRef(pTable);
- }
-
- mInfo("vgId:%d, all child tables is dropped from sdb", pVgroup->vgId);
-}
-
-void mnodeDropAllChildTables(SDbObj *pDropDb) {
- void * pIter = NULL;
- int32_t numOfTables = 0;
- SCTableObj *pTable = NULL;
-
- char prefix[64] = {0};
- tstrncpy(prefix, pDropDb->name, 64);
- strcat(prefix, TS_PATH_DELIMITER);
- int32_t prefixLen = (int32_t)strlen(prefix);
-
- mInfo("db:%s, all child tables will be dropped from sdb", pDropDb->name);
-
- while (1) {
- pIter = mnodeGetNextChildTable(pIter, &pTable);
- if (pTable == NULL) break;
-
- if (strncmp(prefix, pTable->info.tableId, prefixLen) == 0) {
- SSdbRow row = {
- .type = SDB_OPER_LOCAL,
- .pTable = tsChildTableSdb,
- .pObj = pTable,
- };
- sdbDeleteRow(&row);
- numOfTables++;
- }
- mnodeDecTableRef(pTable);
- }
-
- mInfo("db:%s, all child tables:%d is dropped from sdb", pDropDb->name, numOfTables);
-}
-
-static void mnodeDropAllChildTablesInStable(SSTableObj *pStable) {
- void * pIter = NULL;
- int32_t numOfTables = 0;
- SCTableObj *pTable = NULL;
-
- mInfo("stable:%s uid:%" PRIu64 ", all child tables:%d will be dropped from sdb", pStable->info.tableId, pStable->uid,
- pStable->numOfTables);
-
- while (1) {
- pIter = mnodeGetNextChildTable(pIter, &pTable);
- if (pTable == NULL) break;
-
- if (pTable->superTable == pStable) {
- SSdbRow row = {
- .type = SDB_OPER_LOCAL,
- .pTable = tsChildTableSdb,
- .pObj = pTable,
- };
- sdbDeleteRow(&row);
- numOfTables++;
- }
-
- mnodeDecTableRef(pTable);
- }
-
- mInfo("stable:%s, all child tables:%d is dropped from sdb", pStable->info.tableId, numOfTables);
-}
-
-#if 0
-static SCTableObj* mnodeGetTableByPos(int32_t vnode, int32_t tid) {
- SVgObj *pVgroup = mnodeGetVgroup(vnode);
- if (pVgroup == NULL) return NULL;
-
- SCTableObj *pTable = pVgroup->tableList[tid - 1];
- mnodeIncTableRef((STableObj *)pTable);
-
- mnodeDecVgroupRef(pVgroup);
- return pTable;
-}
-#endif
-
-static int32_t mnodeProcessTableCfgMsg(SMnodeMsg *pMsg) {
- return TSDB_CODE_COM_OPS_NOT_SUPPORT;
-#if 0
- SConfigTableMsg *pCfg = pMsg->rpcMsg.pCont;
- pCfg->dnodeId = htonl(pCfg->dnodeId);
- pCfg->vgId = htonl(pCfg->vgId);
- pCfg->sid = htonl(pCfg->sid);
- mDebug("msg:%p, app:%p dnode:%d, vgId:%d sid:%d, receive table config msg", pMsg, pMsg->rpcMsg.ahandle, pCfg->dnodeId,
- pCfg->vgId, pCfg->sid);
-
- SCTableObj *pTable = mnodeGetTableByPos(pCfg->vgId, pCfg->sid);
- if (pTable == NULL) {
- mError("msg:%p, app:%p dnode:%d, vgId:%d sid:%d, table not found", pMsg, pMsg->rpcMsg.ahandle, pCfg->dnodeId,
- pCfg->vgId, pCfg->sid);
- return TSDB_CODE_MND_INVALID_TABLE_ID;
- }
-
- SMDCreateTableMsg *pCreate = NULL;
- pCreate = mnodeBuildCreateChildTableMsg(NULL, (SCTableObj *)pTable);
- mnodeDecTableRef(pTable);
-
- if (pCreate == NULL) return terrno;
-
- pMsg->rpcRsp.rsp = pCreate;
- pMsg->rpcRsp.len = htonl(pCreate->contLen);
- return TSDB_CODE_SUCCESS;
-#endif
-}
-
-// handle drop child response
-static void mnodeProcessDropChildTableRsp(SRpcMsg *rpcMsg) {
- if (rpcMsg->ahandle == NULL) return;
-
- SMnodeMsg *pMsg = rpcMsg->ahandle;
- pMsg->received++;
-
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
- assert(pTable);
-
- mInfo("msg:%p, app:%p table:%s, drop table rsp received, vgId:%d sid:%d uid:%" PRIu64 ", thandle:%p result:%s", pMsg,
- pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid, pMsg->rpcMsg.handle,
- tstrerror(rpcMsg->code));
-
- if (rpcMsg->code != TSDB_CODE_SUCCESS) {
- mError("msg:%p, app:%p table:%s, failed to drop in dnode, vgId:%d sid:%d uid:%" PRIu64 ", reason:%s", pMsg,
- pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid, tstrerror(rpcMsg->code));
- dnodeSendRpcMWriteRsp(pMsg, rpcMsg->code);
- return;
- }
-
- if (pMsg->pVgroup == NULL) pMsg->pVgroup = mnodeGetVgroup(pTable->vgId);
- if (pMsg->pVgroup == NULL) {
- mError("msg:%p, app:%p table:%s, failed to get vgroup", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId);
- dnodeSendRpcMWriteRsp(pMsg, TSDB_CODE_MND_VGROUP_NOT_EXIST);
- return;
- }
-
- if (pMsg->pVgroup->numOfTables <= 0) {
- mInfo("msg:%p, app:%p vgId:%d, all tables is dropped, drop vgroup", pMsg, pMsg->rpcMsg.ahandle,
- pMsg->pVgroup->vgId);
- mnodeDropVgroup(pMsg->pVgroup, NULL);
- }
-
- dnodeSendRpcMWriteRsp(pMsg, TSDB_CODE_SUCCESS);
-}
-
-/*
- * handle create table response from dnode
- * if failed, drop the table cached
- */
-static void mnodeProcessCreateChildTableRsp(SRpcMsg *rpcMsg) {
- if (rpcMsg->ahandle == NULL) return;
-
- SMnodeMsg *pMsg = rpcMsg->ahandle;
- pMsg->received++;
-
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
- assert(pTable);
-
- // If the table is deleted by another thread during creation, stop creating and send drop msg to vnode
- if (sdbCheckRowDeleted(tsChildTableSdb, pTable)) {
- mDebug("msg:%p, app:%p table:%s, create table rsp received, but a deleting opertion incoming, vgId:%d sid:%d uid:%" PRIu64,
- pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid);
-
- // if the vgroup is already dropped from hash, it can't be accquired by pTable->vgId
- // so the refCount of vgroup can not be decreased
- // SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId);
- // if (pVgroup == NULL) {
- // mnodeRemoveTableFromVgroup(pMsg->pVgroup, pTable);
- // }
- // mnodeDecVgroupRef(pVgroup);
-
- mnodeSendDropChildTableMsg(pMsg, false);
- rpcMsg->code = TSDB_CODE_SUCCESS;
-
- if (pMsg->pBatchMasterMsg) {
- ++pMsg->pBatchMasterMsg->successed;
- if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received >= pMsg->pBatchMasterMsg->expected) {
- dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, rpcMsg->code);
- }
-
- mnodeDestroySubMsg(pMsg);
-
- return;
- }
-
- dnodeSendRpcMWriteRsp(pMsg, rpcMsg->code);
- return;
- }
-
- if (rpcMsg->code == TSDB_CODE_SUCCESS || rpcMsg->code == TSDB_CODE_TDB_TABLE_ALREADY_EXIST) {
- SSdbRow desc = {
- .type = SDB_OPER_GLOBAL,
- .pObj = pTable,
- .pTable = tsChildTableSdb,
- .pMsg = pMsg,
- .fpRsp = mnodeDoCreateChildTableCb
- };
-
- int32_t code = sdbInsertRowToQueue(&desc);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- pMsg->pTable = NULL;
- mnodeDestroyChildTable(pTable);
-
- if (pMsg->pBatchMasterMsg) {
- ++pMsg->pBatchMasterMsg->received;
- pMsg->pBatchMasterMsg->code = code;
- if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received
- >= pMsg->pBatchMasterMsg->expected) {
- dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, code);
- }
-
- mnodeDestroySubMsg(pMsg);
-
- return;
- }
-
- dnodeSendRpcMWriteRsp(pMsg, code);
- }
- } else {
- pMsg->retry++;
- int32_t sec = taosGetTimestampSec();
- if (pMsg->retry < CREATE_CTABLE_RETRY_TIMES && ABS(sec - pMsg->incomingTs) < CREATE_CTABLE_RETRY_SEC) {
- mDebug("msg:%p, app:%p table:%s, create table rsp received, need retry, times:%d vgId:%d sid:%d uid:%" PRIu64
- " result:%s thandle:%p",
- pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId, pMsg->retry, pTable->vgId, pTable->tid, pTable->uid,
- tstrerror(rpcMsg->code), pMsg->rpcMsg.handle);
-
- dnodeDelayReprocessMWriteMsg(pMsg);
- } else {
- mError("msg:%p, app:%p table:%s, failed to create in dnode, vgId:%d sid:%d uid:%" PRIu64
- ", result:%s thandle:%p incomingTs:%d curTs:%d retryTimes:%d",
- pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->vgId, pTable->tid, pTable->uid,
- tstrerror(rpcMsg->code), pMsg->rpcMsg.handle, pMsg->incomingTs, sec, pMsg->retry);
-
- SSdbRow row = {.type = SDB_OPER_GLOBAL, .pTable = tsChildTableSdb, .pObj = pTable};
- sdbDeleteRow(&row);
-
- if (rpcMsg->code == TSDB_CODE_APP_NOT_READY) {
- //Avoid retry again in client
- rpcMsg->code = TSDB_CODE_MND_VGROUP_NOT_READY;
- }
-
- if (pMsg->pBatchMasterMsg) {
- ++pMsg->pBatchMasterMsg->received;
- pMsg->pBatchMasterMsg->code = rpcMsg->code;
- if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received
- >= pMsg->pBatchMasterMsg->expected) {
- dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, rpcMsg->code);
- }
-
- mnodeDestroySubMsg(pMsg);
-
- return;
- }
-
- dnodeSendRpcMWriteRsp(pMsg, rpcMsg->code);
- }
- }
-}
-
-static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg) {
- if (rpcMsg->ahandle == NULL) return;
-
- SMnodeMsg *pMsg = rpcMsg->ahandle;
- pMsg->received++;
-
- SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
- assert(pTable);
-
- if (rpcMsg->code == TSDB_CODE_SUCCESS || rpcMsg->code == TSDB_CODE_TDB_TABLE_ALREADY_EXIST) {
- mDebug("msg:%p, app:%p ctable:%s, altered in dnode, thandle:%p result:%s", pMsg, pMsg->rpcMsg.ahandle,
- pTable->info.tableId, pMsg->rpcMsg.handle, tstrerror(rpcMsg->code));
-
- dnodeSendRpcMWriteRsp(pMsg, TSDB_CODE_SUCCESS);
- } else {
- if (pMsg->retry++ < ALTER_CTABLE_RETRY_TIMES) {
- mDebug("msg:%p, app:%p table:%s, alter table rsp received, need retry, times:%d result:%s thandle:%p",
- pMsg->rpcMsg.ahandle, pMsg, pTable->info.tableId, pMsg->retry, tstrerror(rpcMsg->code),
- pMsg->rpcMsg.handle);
-
- dnodeDelayReprocessMWriteMsg(pMsg);
- } else {
- mError("msg:%p, app:%p table:%s, failed to alter in dnode, result:%s thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
- pTable->info.tableId, tstrerror(rpcMsg->code), pMsg->rpcMsg.handle);
- dnodeSendRpcMWriteRsp(pMsg, rpcMsg->code);
- }
- }
-}
-
-static SMultiTableMeta* ensureMsgBufferSpace(SMultiTableMeta *pMultiMeta, SArray* pList, int32_t* totalMallocLen, int32_t numOfVgroupList) {
- int32_t len = 0;
- for (int32_t i = 0; i < numOfVgroupList; ++i) {
- char *name = taosArrayGetP(pList, i);
- len += doGetVgroupInfoLength(name);
- }
-
- if (len + pMultiMeta->contLen > (*totalMallocLen)) {
- while (len + pMultiMeta->contLen > (*totalMallocLen)) {
- (*totalMallocLen) *= 2;
- }
-
- SMultiTableMeta* pMultiMeta1 = realloc(pMultiMeta, *totalMallocLen);
- if (pMultiMeta1 == NULL) {
- return NULL;
- }
- pMultiMeta = pMultiMeta1;
- }
-
- return pMultiMeta;
-}
-
-static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
- SMultiTableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
-
- pInfo->numOfTables = htonl(pInfo->numOfTables);
- pInfo->numOfVgroups = htonl(pInfo->numOfVgroups);
- pInfo->numOfUdfs = htonl(pInfo->numOfUdfs);
-
- int32_t contLen = pMsg->rpcMsg.contLen - sizeof(SMultiTableInfoMsg);
-
- int32_t num = 0;
- int32_t code = TSDB_CODE_SUCCESS;
- char* str = strndup(pInfo->tableNames, contLen);
- char** nameList = strsplit(str, ",", &num);
- SArray* pList = taosArrayInit(4, POINTER_BYTES);
-
- SMultiTableMeta *pMultiMeta = NULL;
- if (num != pInfo->numOfTables + pInfo->numOfVgroups + pInfo->numOfUdfs) {
- mError("msg:%p, app:%p, failed to get multi-tableMeta, msg inconsistent", pMsg, pMsg->rpcMsg.ahandle);
- code = TSDB_CODE_MND_INVALID_TABLE_NAME;
- goto _end;
- }
-
- // first malloc 80KB, subsequent reallocation will expand the size as twice of the original size
- int32_t totalMallocLen = sizeof(SMultiTableMeta) + sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16);
- pMultiMeta = calloc(1, totalMallocLen);
- if (pMultiMeta == NULL) {
- code = TSDB_CODE_MND_OUT_OF_MEMORY;
- goto _end;
- }
-
- pMultiMeta->contLen = sizeof(SMultiTableMeta);
- pMultiMeta->numOfTables = 0;
-
- int32_t t = 0;
- for (; t < pInfo->numOfTables; ++t) {
- char *fullName = nameList[t];
-
- pMsg->pTable = mnodeGetTable(fullName);
- if (pMsg->pTable == NULL) {
- mError("msg:%p, app:%p table:%s, failed to get table meta, table not exist", pMsg, pMsg->rpcMsg.ahandle, fullName);
- code = TSDB_CODE_MND_INVALID_TABLE_NAME;
- goto _end;
- }
-
- if (pMsg->pDb == NULL) {
- pMsg->pDb = mnodeGetDbByTableName(fullName);
- }
-
- if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) {
- mnodeDecTableRef(pMsg->pTable);
- code = TSDB_CODE_APP_NOT_READY;
- goto _end;
- }
-
- int remain = totalMallocLen - pMultiMeta->contLen;
- if (remain <= sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16)) {
- totalMallocLen *= 2;
- pMultiMeta = realloc(pMultiMeta, totalMallocLen);
- if (pMultiMeta == NULL) {
- mnodeDecTableRef(pMsg->pTable);
- code = TSDB_CODE_MND_OUT_OF_MEMORY;
- goto _end;
- }
- }
-
- STableMetaMsg *pMeta = (STableMetaMsg *)((char*) pMultiMeta + pMultiMeta->contLen);
-
- if (pMsg->pTable->type == TSDB_SUPER_TABLE) {
- code = mnodeDoGetSuperTableMeta(pMsg, pMeta);
- taosArrayPush(pList, &fullName); // keep the full name for each super table for retrieve vgroup list
- } else {
- code = mnodeDoGetChildTableMeta(pMsg, pMeta);
- if (pMsg->pVgroup != NULL) {
- mnodeDecVgroupRef(pMsg->pVgroup);
- pMsg->pVgroup = NULL;
- }
- }
-
- mnodeDecTableRef(pMsg->pTable);
- pMsg->pTable = NULL;
-
- if (code == TSDB_CODE_SUCCESS) {
- pMultiMeta->numOfTables++;
- pMultiMeta->contLen += pMeta->contLen;
- } else {
- // ignore error and continue.
- // Otherwise the client may found that the responding message is inconsistent.
-// goto _end;
- }
- }
-
- int32_t tableNum = pInfo->numOfTables + pInfo->numOfVgroups;
-
- // add the additional super table names that needs the vgroup info
- for(;t < tableNum; ++t) {
- taosArrayPush(pList, &nameList[t]);
- }
-
- // add the pVgroupList into the pList
- int32_t numOfVgroupList = (int32_t) taosArrayGetSize(pList);
- pMultiMeta->numOfVgroup = htonl(numOfVgroupList);
-
- pMultiMeta = ensureMsgBufferSpace(pMultiMeta, pList, &totalMallocLen, numOfVgroupList);
- if (pMultiMeta == NULL) {
- code = TSDB_CODE_MND_OUT_OF_MEMORY;
- goto _end;
- }
-
- char* msg = (char*) pMultiMeta + pMultiMeta->contLen;
- for(int32_t i = 0; i < numOfVgroupList; ++i) {
- char* name = taosArrayGetP(pList, i);
-
- SSTableObj *pTable = mnodeGetSuperTable(name);
- if (pTable == NULL) {
- mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, name);
- code = TSDB_CODE_MND_INVALID_TABLE_NAME;
- goto _end;
- }
-
- msg = serializeVgroupInfo(pTable, name, msg, pMsg, pMsg->rpcMsg.ahandle);
- }
-
- pMultiMeta->contLen = (int32_t) (msg - (char*) pMultiMeta);
-
- pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
-
- // add the user-defined-function information
- for(int32_t i = 0; i < pInfo->numOfUdfs; ++i, ++t) {
- char buf[TSDB_FUNC_NAME_LEN] = {0};
- strcpy(buf, nameList[t]);
-
- SFuncObj* pFuncObj = mnodeGetFunc(buf);
- if (pFuncObj == NULL) {
- mError("function %s does not exist", buf);
- code = TSDB_CODE_MND_INVALID_FUNC;
- goto _end;
- }
-
- SFunctionInfoMsg* pFuncInfo = (SFunctionInfoMsg*) msg;
-
- strcpy(pFuncInfo->name, buf);
- pFuncInfo->len = htonl(pFuncObj->contLen);
- memcpy(pFuncInfo->content, pFuncObj->cont, pFuncObj->contLen);
-
- pFuncInfo->funcType = htonl(pFuncObj->funcType);
- pFuncInfo->resType = pFuncObj->resType;
- pFuncInfo->resBytes = htons(pFuncObj->resBytes);
- pFuncInfo->bufSize = htonl(pFuncObj->bufSize);
-
- msg += sizeof(SFunctionInfoMsg) + pFuncObj->contLen;
- }
-
- pMultiMeta->contLen = (int32_t) (msg - (char*) pMultiMeta);
- pMultiMeta->numOfUdf = htonl(pInfo->numOfUdfs);
-
- pMsg->rpcRsp.rsp = pMultiMeta;
- pMsg->rpcRsp.len = pMultiMeta->contLen;
- code = TSDB_CODE_SUCCESS;
-
- char* tmp = rpcMallocCont(pMultiMeta->contLen + 2);
- if (tmp == NULL) {
- code = TSDB_CODE_MND_OUT_OF_MEMORY;
- goto _end;
- }
-
- int32_t dataLen = (int32_t)pMultiMeta->contLen - sizeof(SMultiTableMeta);
- int32_t len = tsCompressString(pMultiMeta->meta, dataLen, 1, tmp + sizeof(SMultiTableMeta), (int32_t)dataLen + 2,
- ONE_STAGE_COMP, NULL, 0);
-
- pMultiMeta->metaClone = pInfo->metaClone;
- pMultiMeta->rawLen = pMultiMeta->contLen;
- if (len == -1 || len >= dataLen + 2) { // compress failed, do not compress this binary data
- pMultiMeta->compressed = 0;
- memcpy(tmp, pMultiMeta, sizeof(SMultiTableMeta) + pMultiMeta->contLen);
- } else {
- pMultiMeta->compressed = 1;
- pMultiMeta->contLen = sizeof(SMultiTableMeta) + len;
-
- // copy the header and the compressed payload
- memcpy(tmp, pMultiMeta, sizeof(SMultiTableMeta));
- }
-
- pMsg->rpcRsp.rsp = tmp;
- pMsg->rpcRsp.len = pMultiMeta->contLen;
-
- SMultiTableMeta* p = (SMultiTableMeta*) tmp;
-
- mDebug("multiTable info build completed, original:%d, compressed:%d, comp:%d", p->rawLen, p->contLen, p->compressed);
-
- _end:
- tfree(str);
- tfree(nameList);
- taosArrayDestroy(pList);
- pMsg->pTable = NULL;
- pMsg->pVgroup = NULL;
- tfree(pMultiMeta);
-
- return code;
-}
-
-static int32_t mnodeGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- SDbObj *pDb = mnodeGetDb(pShow->db);
- if (pDb == NULL) return TSDB_CODE_MND_DB_NOT_SELECTED;
-
- if (pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
- mnodeDecDbRef(pDb);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- SSchema* s = tGetTbnameColumnSchema();
- pShow->bytes[cols] = s->bytes;
- pSchema[cols].type = s->type;
- strcpy(pSchema[cols].name, "table_name");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "created_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "columns");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- SSchema* tbCol = tGetTbnameColumnSchema();
- pShow->bytes[cols] = tbCol->bytes + VARSTR_HEADER_SIZE;
- pSchema[cols].type = tbCol->type;
- strcpy(pSchema[cols].name, "stable_name");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8; // table uid
- pSchema[cols].type = TSDB_DATA_TYPE_BIGINT;
- strcpy(pSchema[cols].name, "uid");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "tid");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "vgId");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = pDb->numOfTables;
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
- mnodeDecDbRef(pDb);
- return 0;
-}
-
-static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- SDbObj *pDb = mnodeGetDb(pShow->db);
- if (pDb == NULL) return 0;
-
- if (pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
- mnodeDecDbRef(pDb);
- return 0;
- }
-
- int32_t cols = 0;
- int32_t numOfRows = 0;
- SCTableObj *pTable = NULL;
- SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
-
- char prefix[64] = {0};
- int32_t prefixLen = (int32_t)tableIdPrefix(pDb->name, prefix, 64);
-
- char* pattern = mnodeGetTableShowPattern(pShow);
- if (pShow->payloadLen > 0 && pattern == NULL) {
- return 0;
- }
-
- while (numOfRows < rows) {
- pShow->pIter = mnodeGetNextChildTable(pShow->pIter, &pTable);
- if (pTable == NULL) break;
-
- // not belong to current db
- if (strncmp(pTable->info.tableId, prefix, prefixLen)) {
- mnodeDecTableRef(pTable);
- continue;
- }
-
- char tableName[TSDB_TABLE_NAME_LEN] = {0};
-
- // pattern compare for table name
- mnodeExtractTableName(pTable->info.tableId, tableName);
-
- if (pattern != NULL && patternMatch(pattern, tableName, sizeof(tableName) - 1, &info) != TSDB_PATTERN_MATCH) {
- mnodeDecTableRef(pTable);
- continue;
- }
-
- cols = 0;
- char *pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, tableName, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *) pWrite = pTable->createdTime;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- if (pTable->info.type == TSDB_CHILD_TABLE) {
- *(int16_t *)pWrite = pTable->superTable->numOfColumns;
- } else {
- *(int16_t *)pWrite = pTable->numOfColumns;
- }
-
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
- memset(tableName, 0, sizeof(tableName));
- if (pTable->info.type == TSDB_CHILD_TABLE) {
- mnodeExtractTableName(pTable->superTable->info.tableId, tableName);
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, tableName, pShow->bytes[cols]);
- }
-
- cols++;
-
- // uid
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t*) pWrite = pTable->uid;
- cols++;
-
-
- // tid
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t*) pWrite = pTable->tid;
- cols++;
-
- //vgid
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t*) pWrite = pTable->vgId;
- cols++;
-
- numOfRows++;
- mnodeDecTableRef(pTable);
- }
-
- pShow->numOfReads += numOfRows;
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- mnodeDecDbRef(pDb);
- free(pattern);
-
- return numOfRows;
-}
-
-static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg) {
- SAlterTableMsg *pAlter = pMsg->rpcMsg.pCont;
- mDebug("msg:%p, app:%p table:%s, alter table msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
- pAlter->tableFname, pMsg->rpcMsg.handle);
-
- if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableName(pAlter->tableFname);
- if (pMsg->pDb == NULL) {
- mError("msg:%p, app:%p table:%s, failed to alter table, db not selected", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname);
- return TSDB_CODE_MND_DB_NOT_SELECTED;
- }
-
- if (pMsg->pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pMsg->pDb->name, pMsg->pDb->status);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
-#if 0
- if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) {
- mError("msg:%p, app:%p table:%s, failed to alter table, its log db", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname);
- return TSDB_CODE_MND_MONITOR_DB_FORBIDDEN;
- }
-#endif
-
- if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pAlter->tableFname);
- if (pMsg->pTable == NULL) {
- mError("msg:%p, app:%p table:%s, failed to alter table, table not exist", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname);
- return TSDB_CODE_MND_INVALID_TABLE_NAME;
- }
-
- pAlter->type = htons(pAlter->type);
- pAlter->numOfCols = htons(pAlter->numOfCols);
- pAlter->tagValLen = htonl(pAlter->tagValLen);
-
- if (pAlter->numOfCols > 2) {
- mError("msg:%p, app:%p table:%s, error numOfCols:%d in alter table", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname,
- pAlter->numOfCols);
- return TSDB_CODE_MND_APP_ERROR;
- }
-
- for (int32_t i = 0; i < pAlter->numOfCols; ++i) {
- pAlter->schema[i].bytes = htons(pAlter->schema[i].bytes);
- }
-
- int32_t code = TSDB_CODE_COM_OPS_NOT_SUPPORT;
- if (pMsg->pTable->type == TSDB_SUPER_TABLE) {
- mDebug("msg:%p, app:%p table:%s, start to alter stable", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname);
- if (pAlter->type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN) {
- code = mnodeAddSuperTableTag(pMsg, pAlter->schema, 1);
- } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_TAG_COLUMN) {
- code = mnodeDropSuperTableTag(pMsg, pAlter->schema[0].name);
- } else if (pAlter->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN) {
- code = mnodeModifySuperTableTagName(pMsg, pAlter->schema[0].name, pAlter->schema[1].name);
- } else if (pAlter->type == TSDB_ALTER_TABLE_ADD_COLUMN) {
- code = mnodeAddSuperTableColumn(pMsg, pAlter->schema, 1);
- } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_COLUMN) {
- code = mnodeDropSuperTableColumn(pMsg, pAlter->schema[0].name);
- } else if (pAlter->type == TSDB_ALTER_TABLE_CHANGE_COLUMN) {
- code = mnodeChangeSuperTableColumn(pMsg);
- } else if (pAlter->type == TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN) {
- code = mnodeChangeSuperTableTag(pMsg);
- } else {
- }
- } else {
- mDebug("msg:%p, app:%p table:%s, start to alter ctable", pMsg, pMsg->rpcMsg.ahandle, pAlter->tableFname);
- if (pAlter->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) {
- return TSDB_CODE_COM_OPS_NOT_SUPPORT;
- } else if (pAlter->type == TSDB_ALTER_TABLE_ADD_COLUMN) {
- code = mnodeAddNormalTableColumn(pMsg, pAlter->schema, 1);
- } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_COLUMN) {
- code = mnodeDropNormalTableColumn(pMsg, pAlter->schema[0].name);
- } else if (pAlter->type == TSDB_ALTER_TABLE_CHANGE_COLUMN) {
- code = mnodeChangeNormalTableColumn(pMsg);
- } else {
- }
- }
-
- return code;
-}
-
-static int32_t mnodeGetStreamTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- SDbObj *pDb = mnodeGetDb(pShow->db);
- if (pDb == NULL) return TSDB_CODE_MND_DB_NOT_SELECTED;
-
- if (pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
- mnodeDecDbRef(pDb);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- SSchema* tbnameColSchema = tGetTbnameColumnSchema();
- pShow->bytes[cols] = tbnameColSchema->bytes;
- pSchema[cols].type = tbnameColSchema->type;
- strcpy(pSchema[cols].name, "table_name");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "created_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "columns");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_MAX_SQL_SHOW_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "sql");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = pDb->numOfTables;
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
- mnodeDecDbRef(pDb);
- return 0;
-}
-
-static int32_t mnodeRetrieveStreamTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- SDbObj *pDb = mnodeGetDb(pShow->db);
- if (pDb == NULL) return 0;
-
- if (pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
- mnodeDecDbRef(pDb);
- return 0;
- }
-
- int32_t numOfRows = 0;
- SCTableObj *pTable = NULL;
- SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
-
- char prefix[64] = {0};
- tstrncpy(prefix, pDb->name, 64);
- strcat(prefix, TS_PATH_DELIMITER);
- int32_t prefixLen = (int32_t)strlen(prefix);
-
- char* pattern = mnodeGetTableShowPattern(pShow);
- if (pShow->payloadLen > 0 && pattern == NULL) {
- return 0;
- }
-
- while (numOfRows < rows) {
- pShow->pIter = mnodeGetNextChildTable(pShow->pIter, &pTable);
- if (pTable == NULL) break;
-
- // not belong to current db
- if (strncmp(pTable->info.tableId, prefix, prefixLen) || pTable->info.type != TSDB_STREAM_TABLE) {
- mnodeDecTableRef(pTable);
- continue;
- }
-
- char tableName[TSDB_TABLE_NAME_LEN] = {0};
-
- // pattern compare for table name
- mnodeExtractTableName(pTable->info.tableId, tableName);
-
- if (pShow->payloadLen > 0 && patternMatch(pattern, tableName, sizeof(tableName) - 1, &info) != TSDB_PATTERN_MATCH) {
- mnodeDecTableRef(pTable);
- continue;
- }
-
- int32_t cols = 0;
-
- char *pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, tableName, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *) pWrite = pTable->createdTime;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *)pWrite = pTable->numOfColumns;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pTable->sql, pShow->bytes[cols]);
- cols++;
-
- numOfRows++;
- mnodeDecTableRef(pTable);
- }
-
- pShow->numOfReads += numOfRows;
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- mnodeDecDbRef(pDb);
- free(pattern);
-
- return numOfRows;
-}
-
-static int32_t mnodeCompactSuperTables() {
- void *pIter = NULL;
- SSTableObj *pTable = NULL;
-
- mInfo("start to compact super table...");
-
- while (1) {
- pIter = mnodeGetNextSuperTable(pIter, &pTable);
- if (pTable == NULL) break;
-
- int32_t schemaSize = (pTable->numOfColumns + pTable->numOfTags) * sizeof(SSchema);
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsSuperTableSdb,
- .pObj = pTable,
- .rowSize = sizeof(SSTableObj) + schemaSize,
- };
-
- //mInfo("compact super %" PRIu64, pTable->uid);
-
- sdbInsertCompactRow(&row);
- }
-
- mInfo("end to compact super table...");
-
- return 0;
-}
-
-static int32_t mnodeCompactChildTables() {
- void *pIter = NULL;
- SCTableObj *pTable = NULL;
-
- mInfo("start to compact child table...");
-
- while (1) {
- pIter = mnodeGetNextChildTable(pIter, &pTable);
- if (pTable == NULL) break;
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pObj = pTable,
- .pTable = tsChildTableSdb,
- };
-
- //mInfo("compact child %" PRIu64 ":%d", pTable->uid, pTable->tid);
-
- sdbInsertCompactRow(&row);
- }
-
- mInfo("end to compact child table...");
-
- return 0;
-}
-
-int32_t mnodeCompactTables() {
- mnodeCompactSuperTables();
-
- mnodeCompactChildTables();
-
- return 0;
-}
diff --git a/src/mnode/src/mnodeUser.c b/src/mnode/src/mnodeUser.c
deleted file mode 100644
index c5c54791cf828661e146b121765806a630ea8baa..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeUser.c
+++ /dev/null
@@ -1,646 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "trpc.h"
-#include "tutil.h"
-#include "tglobal.h"
-#include "tgrant.h"
-#include "tdataformat.h"
-#include "tkey.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeMnode.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeUser.h"
-#include "mnodeWrite.h"
-#include "mnodePeer.h"
-
-int64_t tsUserRid = -1;
-static void * tsUserSdb = NULL;
-static int32_t tsUserUpdateSize = 0;
-static int32_t mnodeGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mnodeProcessCreateUserMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessAlterUserMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg);
-static int32_t mnodeProcessAuthMsg(SMnodeMsg *pMsg);
-
-static int32_t mnodeUserActionDestroy(SSdbRow *pRow) {
- tfree(pRow->pObj);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeUserActionInsert(SSdbRow *pRow) {
- SUserObj *pUser = pRow->pObj;
- SAcctObj *pAcct = mnodeGetAcct(pUser->acct);
-
- if (pAcct != NULL) {
- mnodeAddUserToAcct(pAcct, pUser);
- mnodeDecAcctRef(pAcct);
- } else {
- mError("user:%s, acct:%s info not exist in sdb", pUser->user, pUser->acct);
- return TSDB_CODE_MND_INVALID_ACCT;
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeUserActionDelete(SSdbRow *pRow) {
- SUserObj *pUser = pRow->pObj;
- SAcctObj *pAcct = mnodeGetAcct(pUser->acct);
-
- if (pAcct != NULL) {
- mnodeDropUserFromAcct(pAcct, pUser);
- mnodeDecAcctRef(pAcct);
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeUserActionUpdate(SSdbRow *pRow) {
- SUserObj *pUser = pRow->pObj;
- SUserObj *pSaved = mnodeGetUser(pUser->user);
- if (pUser != pSaved) {
- memcpy(pSaved, pUser, tsUserUpdateSize);
- free(pUser);
- }
- mnodeDecUserRef(pSaved);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeUserActionEncode(SSdbRow *pRow) {
- SUserObj *pUser = pRow->pObj;
- memcpy(pRow->rowData, pUser, tsUserUpdateSize);
- pRow->rowSize = tsUserUpdateSize;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeUserActionDecode(SSdbRow *pRow) {
- SUserObj *pUser = (SUserObj *)calloc(1, sizeof(SUserObj));
- if (pUser == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
- memcpy(pUser, pRow->rowData, tsUserUpdateSize);
- pRow->pObj = pUser;
- return TSDB_CODE_SUCCESS;
-}
-
-static void mnodePrintUserAuth() {
- FILE *fp = fopen("auth.txt", "w");
- if (!fp) {
- mDebug("failed to auth.txt for write");
- return;
- }
-
- void * pIter = NULL;
- SUserObj *pUser = NULL;
-
- while (1) {
- pIter = mnodeGetNextUser(pIter, &pUser);
- if (pUser == NULL) break;
-
- char *base64 = base64_encode((const unsigned char *)pUser->pass, TSDB_KEY_LEN * 2);
- fprintf(fp, "user:%24s auth:%s\n", pUser->user, base64);
- free(base64);
-
- mnodeDecUserRef(pUser);
- }
-
- taosFsync(fileno(fp));
- fclose(fp);
-}
-
-static int32_t mnodeUserActionRestored() {
- int64_t numOfRows = sdbGetNumOfRows(tsUserSdb);
- if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
- mInfo("dnode first deploy, create root user");
- SAcctObj *pAcct = mnodeGetAcct(TSDB_DEFAULT_USER);
- mnodeCreateUser(pAcct, TSDB_DEFAULT_USER, TSDB_DEFAULT_PASS, NULL);
- mnodeCreateUser(pAcct, "monitor", tsInternalPass, NULL);
- mnodeCreateUser(pAcct, "_"TSDB_DEFAULT_USER, tsInternalPass, NULL);
- mnodeDecAcctRef(pAcct);
- }
-
- if (tsPrintAuth != 0) {
- mInfo("print user auth, for -A parameter is set");
- mnodePrintUserAuth();
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeInitUsers() {
- SUserObj tObj;
- tsUserUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
- SSdbTableDesc desc = {
- .id = SDB_TABLE_USER,
- .name = "users",
- .hashSessions = TSDB_DEFAULT_USERS_HASH_SIZE,
- .maxRowSize = tsUserUpdateSize,
- .refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
- .keyType = SDB_KEY_STRING,
- .fpInsert = mnodeUserActionInsert,
- .fpDelete = mnodeUserActionDelete,
- .fpUpdate = mnodeUserActionUpdate,
- .fpEncode = mnodeUserActionEncode,
- .fpDecode = mnodeUserActionDecode,
- .fpDestroy = mnodeUserActionDestroy,
- .fpRestored = mnodeUserActionRestored
- };
-
- tsUserRid = sdbOpenTable(&desc);
- tsUserSdb = sdbGetTableByRid(tsUserRid);
- if (tsUserSdb == NULL) {
- mError("table:%s, failed to create hash", desc.name);
- return -1;
- }
-
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_USER, mnodeProcessCreateUserMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_ALTER_USER, mnodeProcessAlterUserMsg);
- mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_USER, mnodeProcessDropUserMsg);
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_USER, mnodeGetUserMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_USER, mnodeRetrieveUsers);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_USER, mnodeCancelGetNextUser);
-
- mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_AUTH, mnodeProcessAuthMsg);
-
- mDebug("table:%s, hash is created", desc.name);
- return 0;
-}
-
-void mnodeCleanupUsers() {
- sdbCloseTable(tsUserRid);
- tsUserSdb = NULL;
-}
-
-SUserObj *mnodeGetUser(char *name) {
- return (SUserObj *)sdbGetRow(tsUserSdb, name);
-}
-
-void *mnodeGetNextUser(void *pIter, SUserObj **pUser) {
- return sdbFetchRow(tsUserSdb, pIter, (void **)pUser);
-}
-
-void mnodeCancelGetNextUser(void *pIter) {
- sdbFreeIter(tsUserSdb, pIter);
-}
-
-void mnodeIncUserRef(SUserObj *pUser) {
- sdbIncRef(tsUserSdb, pUser);
-}
-
-void mnodeDecUserRef(SUserObj *pUser) {
- sdbDecRef(tsUserSdb, pUser);
-}
-
-static int32_t mnodeUpdateUser(SUserObj *pUser, void *pMsg) {
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsUserSdb,
- .pObj = pUser,
- .pMsg = pMsg
- };
-
- int32_t code = sdbUpdateRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("user:%s, failed to alter by %s, reason:%s", pUser->user, mnodeGetUserFromMsg(pMsg), tstrerror(code));
- } else {
- mLInfo("user:%s, is altered by %s", pUser->user, mnodeGetUserFromMsg(pMsg));
- }
-
- return code;
-}
-
-int32_t mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass, void *pMsg) {
- int32_t code = acctCheck(pAcct, ACCT_GRANT_USER);
- if (code != TSDB_CODE_SUCCESS) {
- return code;
- }
-
- if (name[0] == 0) {
- return TSDB_CODE_MND_INVALID_USER_FORMAT;
- }
-
- if (pass[0] == 0) {
- return TSDB_CODE_MND_INVALID_PASS_FORMAT;
- }
-
- SUserObj *pUser = mnodeGetUser(name);
- if (pUser != NULL) {
- mDebug("user:%s, is already there", name);
- mnodeDecUserRef(pUser);
- return TSDB_CODE_MND_USER_ALREADY_EXIST;
- }
-
- code = grantCheck(TSDB_GRANT_USER);
- if (code != TSDB_CODE_SUCCESS) {
- return code;
- }
-
- pUser = calloc(1, sizeof(SUserObj));
- tstrncpy(pUser->user, name, TSDB_USER_LEN);
- taosEncryptPass((uint8_t*) pass, strlen(pass), pUser->pass);
- strcpy(pUser->acct, pAcct->user);
- pUser->createdTime = taosGetTimestampMs();
- pUser->superAuth = 0;
- pUser->writeAuth = 1;
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0 || strcmp(pUser->user, pUser->acct) == 0) {
- pUser->superAuth = 1;
- }
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsUserSdb,
- .pObj = pUser,
- .rowSize = sizeof(SUserObj),
- .pMsg = pMsg
- };
-
- code = sdbInsertRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("user:%s, failed to create by %s, reason:%s", pUser->user, mnodeGetUserFromMsg(pMsg), tstrerror(code));
- tfree(pUser);
- } else {
- mLInfo("user:%s, is created by %s", pUser->user, mnodeGetUserFromMsg(pMsg));
- }
-
- return code;
-}
-
-static int32_t mnodeDropUser(SUserObj *pUser, void *pMsg) {
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsUserSdb,
- .pObj = pUser,
- .pMsg = pMsg
- };
-
- int32_t code = sdbDeleteRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("user:%s, failed to drop by %s, reason:%s", pUser->user, mnodeGetUserFromMsg(pMsg), tstrerror(code));
- } else {
- mLInfo("user:%s, is dropped by %s", pUser->user, mnodeGetUserFromMsg(pMsg));
- }
-
- return code;
-}
-
-static int32_t mnodeGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- SUserObj *pUser = mnodeGetUserFromConn(pConn);
- if (pUser == NULL) {
- return TSDB_CODE_MND_NO_USER_FROM_CONN;
- }
-
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "name");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "privilege");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8;
- pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
- strcpy(pSchema[cols].name, "create_time");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "account");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pMeta->numOfColumns = htons(cols);
- strcpy(pMeta->tableFname, "show users");
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = pUser->pAcct->acctInfo.numOfUsers;
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
- mnodeDecUserRef(pUser);
- return 0;
-}
-
-static int32_t mnodeRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- SUserObj *pUser = NULL;
- int32_t cols = 0;
- char *pWrite;
-
- while (numOfRows < rows) {
- pShow->pIter = mnodeGetNextUser(pShow->pIter, &pUser);
- if (pUser == NULL) break;
-
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pUser->user, pShow->bytes[cols]);
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- if (pUser->superAuth) {
- const char *src = "super";
- STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
- } else if (pUser->writeAuth) {
- const char *src = "writable";
- STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
- } else {
- const char *src = "readable";
- STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
- }
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int64_t *)pWrite = pUser->createdTime;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pUser->acct, pShow->bytes[cols]);
- cols++;
-
- numOfRows++;
- mnodeDecUserRef(pUser);
- }
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
- pShow->numOfReads += numOfRows;
- return numOfRows;
-}
-
-SUserObj *mnodeGetUserFromConn(void *pConn) {
- SRpcConnInfo connInfo = {0};
- if (rpcGetConnInfo(pConn, &connInfo) == 0) {
- return mnodeGetUser(connInfo.user);
- } else {
- mError("can not get user from conn:%p", pConn);
- return NULL;
- }
-}
-
-char *mnodeGetUserFromMsg(void *pMsg) {
- SMnodeMsg *pMnodeMsg = pMsg;
- if (pMnodeMsg != NULL && pMnodeMsg->pUser != NULL) {
- return pMnodeMsg->pUser->user;
- } else {
- return "system";
- }
-}
-
-static int32_t mnodeProcessCreateUserMsg(SMnodeMsg *pMsg) {
- SUserObj *pOperUser = pMsg->pUser;
-
- if (pOperUser->superAuth) {
- SCreateUserMsg *pCreate = pMsg->rpcMsg.pCont;
- return mnodeCreateUser(pOperUser->pAcct, pCreate->user, pCreate->pass, pMsg);
- } else {
- mError("user:%s, no rights to create user", pOperUser->user);
- return TSDB_CODE_MND_NO_RIGHTS;
- }
-}
-
-static int32_t mnodeProcessAlterUserMsg(SMnodeMsg *pMsg) {
- int32_t code;
- SUserObj *pOperUser = pMsg->pUser;
-
- SAlterUserMsg *pAlter = pMsg->rpcMsg.pCont;
- SUserObj *pUser = mnodeGetUser(pAlter->user);
- if (pUser == NULL) {
- return TSDB_CODE_MND_INVALID_USER;
- }
-
- if (strcmp(pUser->user, "monitor") == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) {
- mnodeDecUserRef(pUser);
- return TSDB_CODE_MND_NO_RIGHTS;
- }
-
- if ((pAlter->flag & TSDB_ALTER_USER_PASSWD) != 0) {
- bool hasRight = false;
- if (strcmp(pOperUser->user, TSDB_DEFAULT_USER) == 0) {
- hasRight = true;
- } else if (strcmp(pUser->user, pOperUser->user) == 0) {
- hasRight = true;
- } else if (pOperUser->superAuth) {
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
- hasRight = false;
- } else if (strcmp(pOperUser->acct, pUser->acct) != 0) {
- hasRight = false;
- } else {
- hasRight = true;
- }
- }
-
- if (hasRight) {
- memset(pUser->pass, 0, sizeof(pUser->pass));
- taosEncryptPass((uint8_t*)pAlter->pass, strlen(pAlter->pass), pUser->pass);
- code = mnodeUpdateUser(pUser, pMsg);
- } else {
- mError("user:%s, no rights to alter user", pOperUser->user);
- code = TSDB_CODE_MND_NO_RIGHTS;
- }
- } else if ((pAlter->flag & TSDB_ALTER_USER_PRIVILEGES) != 0) {
- bool hasRight = false;
-
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
- hasRight = false;
- } else if (strcmp(pUser->user, pUser->acct) == 0) {
- hasRight = false;
- } else if (strcmp(pOperUser->user, TSDB_DEFAULT_USER) == 0) {
- hasRight = true;
- } else if (strcmp(pUser->user, pOperUser->user) == 0) {
- hasRight = false;
- } else if (pOperUser->superAuth) {
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
- hasRight = false;
- } else if (strcmp(pOperUser->acct, pUser->acct) != 0) {
- hasRight = false;
- } else {
- hasRight = true;
- }
- }
-
- if (pAlter->privilege == 1) { // super
- hasRight = false;
- }
-
- if (hasRight) {
- if (pAlter->privilege == 2) { // read
- pUser->superAuth = 0;
- pUser->writeAuth = 0;
- }
- if (pAlter->privilege == 3) { // write
- pUser->superAuth = 0;
- pUser->writeAuth = 1;
- }
-
- code = mnodeUpdateUser(pUser, pMsg);
- } else {
- mError("user:%s, no rights to alter user", pOperUser->user);
- code = TSDB_CODE_MND_NO_RIGHTS;
- }
- } else {
- mError("user:%s, no rights to alter user", pOperUser->user);
- code = TSDB_CODE_MND_NO_RIGHTS;
- }
-
- mnodeDecUserRef(pUser);
- return code;
-}
-
-static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg) {
- int32_t code;
- SUserObj *pOperUser = pMsg->pUser;
-
- SDropUserMsg *pDrop = pMsg->rpcMsg.pCont;
- SUserObj *pUser = mnodeGetUser(pDrop->user);
- if (pUser == NULL) {
- return TSDB_CODE_MND_INVALID_USER;
- }
-
- if (strcmp(pUser->user, "monitor") == 0 || strcmp(pUser->user, pUser->acct) == 0 ||
- (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) {
- mnodeDecUserRef(pUser);
- return TSDB_CODE_MND_NO_RIGHTS;
- }
-
- bool hasRight = false;
- if (strcmp(pUser->user, TSDB_DEFAULT_USER) == 0) {
- hasRight = false;
- } else if (strcmp(pOperUser->user, TSDB_DEFAULT_USER) == 0) {
- hasRight = true;
- } else if (strcmp(pUser->user, pOperUser->user) == 0) {
- hasRight = false;
- } else if (pOperUser->superAuth) {
- if (strcmp(pOperUser->acct, pUser->acct) != 0) {
- hasRight = false;
- } else {
- hasRight = true;
- }
- }
-
- if (hasRight) {
- code = mnodeDropUser(pUser, pMsg);
- } else {
- code = TSDB_CODE_MND_NO_RIGHTS;
- }
-
- mnodeDecUserRef(pUser);
- return code;
-}
-
-void mnodeDropAllUsers(SAcctObj *pAcct) {
- void * pIter = NULL;
- int32_t numOfUsers = 0;
- int32_t acctNameLen = (int32_t)strlen(pAcct->user);
- SUserObj *pUser = NULL;
-
- while (1) {
- pIter = mnodeGetNextUser(pIter, &pUser);
- if (pUser == NULL) break;
-
- if (strncmp(pUser->acct, pAcct->user, acctNameLen) == 0) {
- SSdbRow row = {
- .type = SDB_OPER_LOCAL,
- .pTable = tsUserSdb,
- .pObj = pUser,
- };
- sdbDeleteRow(&row);
- numOfUsers++;
- }
-
- mnodeDecUserRef(pUser);
- }
-
- mDebug("acct:%s, all users:%d is dropped from sdb", pAcct->user, numOfUsers);
-}
-
-int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey) {
- if (!sdbIsMaster()) {
- *secret = 0;
- mDebug("user:%s, failed to auth user, mnode is not master", user);
- return TSDB_CODE_APP_NOT_READY;
- }
-
- SUserObj *pUser = mnodeGetUser(user);
- if (pUser == NULL) {
- *secret = 0;
- mError("user:%s, failed to auth user, reason:%s", user, tstrerror(TSDB_CODE_MND_INVALID_USER));
- return TSDB_CODE_MND_INVALID_USER;
- } else {
- *spi = 1;
- *encrypt = 0;
- *ckey = 0;
-
- memcpy(secret, pUser->pass, TSDB_KEY_LEN);
- mnodeDecUserRef(pUser);
- mDebug("user:%s, auth info is returned", user);
- return TSDB_CODE_SUCCESS;
- }
-}
-
-static int32_t mnodeProcessAuthMsg(SMnodeMsg *pMsg) {
- SAuthMsg *pAuthMsg = pMsg->rpcMsg.pCont;
- SAuthRsp *pAuthRsp = rpcMallocCont(sizeof(SAuthRsp));
-
- pMsg->rpcRsp.rsp = pAuthRsp;
- pMsg->rpcRsp.len = sizeof(SAuthRsp);
-
- return mnodeRetriveAuth(pAuthMsg->user, &pAuthRsp->spi, &pAuthRsp->encrypt, pAuthRsp->secret, pAuthRsp->ckey);
-}
-
-int32_t mnodeCompactUsers() {
- void *pIter = NULL;
- SUserObj *pUser = NULL;
-
- mInfo("start to compact users table...");
-
- while (1) {
- pIter = mnodeGetNextUser(pIter, &pUser);
- if (pUser == NULL) break;
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsUserSdb,
- .pObj = pUser,
- .rowSize = sizeof(SUserObj),
- };
-
- mInfo("compact users %s", pUser->user);
-
- sdbInsertCompactRow(&row);
- }
-
- mInfo("end to compact users table...");
-
- return 0;
-}
\ No newline at end of file
diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c
deleted file mode 100644
index a32da29124016424ce5fe1436f29cca91da3e546..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeVgroup.c
+++ /dev/null
@@ -1,1390 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "tutil.h"
-#include "tsocket.h"
-#include "tidpool.h"
-#include "tsync.h"
-#include "tbn.h"
-#include "tglobal.h"
-#include "tdataformat.h"
-#include "dnode.h"
-#include "mnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeDb.h"
-#include "mnodeDnode.h"
-#include "mnodeMnode.h"
-#include "mnodeProfile.h"
-#include "mnodeSdb.h"
-#include "mnodeShow.h"
-#include "mnodeTable.h"
-#include "mnodeVgroup.h"
-#include "mnodePeer.h"
-
-typedef enum {
- TAOS_VG_STATUS_READY,
- TAOS_VG_STATUS_DROPPING,
- TAOS_VG_STATUS_CREATING,
- TAOS_VG_STATUS_UPDATING,
-} EVgroupStatus;
-
-char* vgroupStatus[] = {
- "ready",
- "dropping",
- "creating",
- "updating"
-};
-
-int64_t tsVgroupRid = -1;
-static void *tsVgroupSdb = NULL;
-static int32_t tsVgUpdateSize = 0;
-
-static int32_t mnodeAllocVgroupIdPool(SVgObj *pInputVgroup);
-static int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
-static int32_t mnodeRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static void mnodeProcessCreateVnodeRsp(SRpcMsg *rpcMsg);
-static void mnodeProcessAlterVnodeRsp(SRpcMsg *rpcMsg);
-static void mnodeProcessCompactVnodeRsp(SRpcMsg *rpcMsg);
-static void mnodeProcessDropVnodeRsp(SRpcMsg *rpcMsg);
-static int32_t mnodeProcessVnodeCfgMsg(SMnodeMsg *pMsg) ;
-static void mnodeSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle);
-
-static void mnodeDestroyVgroup(SVgObj *pVgroup) {
- if (pVgroup->idPool) {
- taosIdPoolCleanUp(pVgroup->idPool);
- pVgroup->idPool = NULL;
- }
-
- tfree(pVgroup);
-}
-
-static int32_t mnodeVgroupActionDestroy(SSdbRow *pRow) {
- mnodeDestroyVgroup(pRow->pObj);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionInsert(SSdbRow *pRow) {
- SVgObj *pVgroup = pRow->pObj;
-
- // refer to db
- SDbObj *pDb = mnodeGetDb(pVgroup->dbName);
- if (pDb == NULL) {
- mError("vgId:%d, db:%s is not exist while insert into hash", pVgroup->vgId, pVgroup->dbName);
- return TSDB_CODE_MND_INVALID_DB;
- }
-
- if (pDb->status != TSDB_DB_STATUS_READY) {
- mError("vgId:%d, db:%s status:%d, in dropping", pVgroup->vgId, pDb->name, pDb->status);
- mnodeDecDbRef(pDb);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- pVgroup->pDb = pDb;
- pVgroup->status = TAOS_VG_STATUS_CREATING;
- pVgroup->accessState = TSDB_VN_ALL_ACCCESS;
- if (mnodeAllocVgroupIdPool(pVgroup) < 0) {
- mError("vgId:%d, failed to init idpool for vgroups", pVgroup->vgId);
- return -1;
- }
-
- for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
- SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId);
- if (pDnode != NULL) {
- pVgroup->vnodeGid[i].pDnode = pDnode;
- atomic_add_fetch_32(&pDnode->openVnodes, 1);
- mnodeDecDnodeRef(pDnode);
- }
- }
-
- mnodeAddVgroupIntoDb(pVgroup);
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionDelete(SSdbRow *pRow) {
- SVgObj *pVgroup = pRow->pObj;
-
- if (pVgroup->pDb == NULL) {
- mError("vgId:%d, db:%s is not exist while delete from hash", pVgroup->vgId, pVgroup->dbName);
- return TSDB_CODE_MND_VGROUP_NOT_EXIST;
- }
-
- mnodeRemoveVgroupFromDb(pVgroup);
- mnodeDecDbRef(pVgroup->pDb);
-
- for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
- SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId);
- if (pDnode != NULL) {
- atomic_sub_fetch_32(&pDnode->openVnodes, 1);
- }
- mnodeDecDnodeRef(pDnode);
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionUpdate(SSdbRow *pRow) {
- SVgObj *pNew = pRow->pObj;
- SVgObj *pVgroup = mnodeGetVgroup(pNew->vgId);
-
- if (pVgroup != pNew) {
- for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
- SDnodeObj *pDnode = pVgroup->vnodeGid[i].pDnode;
- if (pDnode != NULL) {
- atomic_sub_fetch_32(&pDnode->openVnodes, 1);
- }
- }
-
- memcpy(pVgroup, pNew, tsVgUpdateSize);
-
- for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
- SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId);
- pVgroup->vnodeGid[i].pDnode = pDnode;
- if (pDnode != NULL) {
- atomic_add_fetch_32(&pDnode->openVnodes, 1);
- }
- mnodeDecDnodeRef(pDnode);
- }
-
- free(pNew);
- }
-
-
- // reset vgid status on vgroup changed
- mDebug("vgId:%d, reset sync status to offline", pVgroup->vgId);
- for (int32_t v = 0; v < pVgroup->numOfVnodes; ++v) {
- pVgroup->vnodeGid[v].role = TAOS_SYNC_ROLE_OFFLINE;
- }
-
- mnodeDecVgroupRef(pVgroup);
-
- mDebug("vgId:%d, is updated, numOfVnode:%d", pVgroup->vgId, pVgroup->numOfVnodes);
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionEncode(SSdbRow *pRow) {
- SVgObj *pVgroup = pRow->pObj;
- memcpy(pRow->rowData, pVgroup, tsVgUpdateSize);
- SVgObj *pTmpVgroup = pRow->rowData;
- for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
- pTmpVgroup->vnodeGid[i].pDnode = NULL;
- pTmpVgroup->vnodeGid[i].role = 0;
- memset(pTmpVgroup->vnodeGid[i].vver, 0, sizeof(pTmpVgroup->vnodeGid[i].vver));
- }
-
- pRow->rowSize = tsVgUpdateSize;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionDecode(SSdbRow *pRow) {
- SVgObj *pVgroup = (SVgObj *) calloc(1, sizeof(SVgObj));
- if (pVgroup == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
-
- memcpy(pVgroup, pRow->rowData, tsVgUpdateSize);
- pRow->pObj = pVgroup;
- return TSDB_CODE_SUCCESS;
-}
-
-static int32_t mnodeVgroupActionRestored() {
- return 0;
-}
-
-int32_t mnodeInitVgroups() {
- SVgObj tObj;
- tsVgUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
-
- SSdbTableDesc desc = {
- .id = SDB_TABLE_VGROUP,
- .name = "vgroups",
- .hashSessions = TSDB_DEFAULT_VGROUPS_HASH_SIZE,
- .maxRowSize = tsVgUpdateSize,
- .refCountPos = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
- .keyType = SDB_KEY_AUTO,
- .fpInsert = mnodeVgroupActionInsert,
- .fpDelete = mnodeVgroupActionDelete,
- .fpUpdate = mnodeVgroupActionUpdate,
- .fpEncode = mnodeVgroupActionEncode,
- .fpDecode = mnodeVgroupActionDecode,
- .fpDestroy = mnodeVgroupActionDestroy,
- .fpRestored = mnodeVgroupActionRestored,
- };
-
- tsVgroupRid = sdbOpenTable(&desc);
- tsVgroupSdb = sdbGetTableByRid(tsVgroupRid);
- if (tsVgroupSdb == NULL) {
- mError("failed to init vgroups data");
- return -1;
- }
-
- mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VGROUP, mnodeGetVgroupMeta);
- mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VGROUP, mnodeRetrieveVgroups);
- mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_VGROUP, mnodeCancelGetNextVgroup);
- mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP, mnodeProcessCreateVnodeRsp);
- mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_ALTER_VNODE_RSP, mnodeProcessAlterVnodeRsp);
- mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_COMPACT_VNODE_RSP, mnodeProcessCompactVnodeRsp);
- mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_DROP_VNODE_RSP, mnodeProcessDropVnodeRsp);
- mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_VNODE, mnodeProcessVnodeCfgMsg);
-
- mDebug("table:vgroups is created");
-
- return 0;
-}
-
-void mnodeIncVgroupRef(SVgObj *pVgroup) {
- sdbIncRef(tsVgroupSdb, pVgroup);
-}
-
-void mnodeDecVgroupRef(SVgObj *pVgroup) {
- sdbDecRef(tsVgroupSdb, pVgroup);
-}
-
-SVgObj *mnodeGetVgroup(int32_t vgId) {
- return (SVgObj *)sdbGetRow(tsVgroupSdb, &vgId);
-}
-
-void mnodeUpdateVgroup(SVgObj *pVgroup) {
- pVgroup->vgCfgVersion++;
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsVgroupSdb,
- .pObj = pVgroup
- };
-
- int32_t code = sdbUpdateRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mError("vgId:%d, failed to update vgroup", pVgroup->vgId);
- }
- mnodeSendAlterVgroupMsg(pVgroup,NULL);
-}
-
-/*
- Traverse all vgroups on mnode, if there no such vgId on a dnode, so send msg to this dnode for re-creating this vgId/vnode
-*/
-void mnodeCheckUnCreatedVgroup(SDnodeObj *pDnode, SVnodeLoad *pVloads, int32_t openVnodes) {
- void *pIter = NULL;
- while (1) {
- SVgObj *pVgroup;
- pIter = mnodeGetNextVgroup(pIter, &pVgroup);
- if (pVgroup == NULL) break;
-
- for (int v = 0; v < pVgroup->numOfVnodes; ++v) {
- if (pVgroup->vnodeGid[v].dnodeId == pDnode->dnodeId) {
- // vgroup should have a vnode on this dnode
- bool have = false;
- for (int32_t i = 0; i < openVnodes; ++i) {
- SVnodeLoad *pVload = pVloads + i;
- if (pVgroup->vgId == pVload->vgId) {
- have = true;
- break;
- }
- }
-
- if (have) continue;
-
- if (pVgroup->status == TAOS_VG_STATUS_CREATING || pVgroup->status == TAOS_VG_STATUS_DROPPING) {
- mDebug("vgId:%d, not exist in dnode:%d and status is %s, do nothing", pVgroup->vgId, pDnode->dnodeId,
- vgroupStatus[pVgroup->status]);
- } else {
- mDebug("vgId:%d, not exist in dnode:%d and status is %s, send create msg", pVgroup->vgId, pDnode->dnodeId,
- vgroupStatus[pVgroup->status]);
- mnodeSendCreateVgroupMsg(pVgroup, NULL);
- }
- }
- }
-
- mnodeDecVgroupRef(pVgroup);
- }
-
- mnodeCancelGetNextVgroup(pIter);
-}
-
-void mnodeUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVload) {
- bool dnodeExist = false;
- for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
- SVnodeGid *pVgid = &pVgroup->vnodeGid[i];
- if (pVgid->pDnode == pDnode) {
- mTrace("vgId:%d, receive vnode status from dnode:%d, status:%s last:%s vver:%" PRIu64, pVgroup->vgId,
- pDnode->dnodeId, syncRole[pVload->role], syncRole[pVgid->role], pVload->vnodeVersion);
- pVgid->role = pVload->role;
- mnodeSetVgidVer(pVgid->vver, pVload->vnodeVersion);
- if (pVload->role == TAOS_SYNC_ROLE_MASTER) {
- pVgroup->inUse = i;
- }
- dnodeExist = true;
- break;
- }
- }
-
- if (!dnodeExist) {
- SRpcEpSet epSet = mnodeGetEpSetFromIp(pDnode->dnodeEp);
- mError("vgId:%d, dnode:%d not exist in mnode, drop it", pVload->vgId, pDnode->dnodeId);
- mnodeSendDropVnodeMsg(pVload->vgId, &epSet, NULL);
- return;
- }
-
- if (pVload->role == TAOS_SYNC_ROLE_MASTER) {
- pVgroup->totalStorage = htobe64(pVload->totalStorage);
- pVgroup->compStorage = htobe64(pVload->compStorage);
- pVgroup->pointsWritten = htobe64(pVload->pointsWritten);
- }
-
- if (pVload->dbCfgVersion != pVgroup->pDb->dbCfgVersion || pVload->replica != pVgroup->numOfVnodes ||
- pVload->vgCfgVersion != pVgroup->vgCfgVersion) {
- mError("dnode:%d, vgId:%d, vnode cfgVersion:%d:%d repica:%d not match with mnode cfgVersion:%d:%d replica:%d",
- pDnode->dnodeId, pVload->vgId, pVload->dbCfgVersion, pVload->vgCfgVersion, pVload->replica,
- pVgroup->pDb->dbCfgVersion, pVgroup->vgCfgVersion, pVgroup->numOfVnodes);
- mnodeSendAlterVgroupMsg(pVgroup,NULL);
- }
- pVgroup->compact = pVload->compact;
-}
-
-static int32_t mnodeAllocVgroupIdPool(SVgObj *pInputVgroup) {
- SDbObj *pDb = pInputVgroup->pDb;
- if (pDb == NULL) return TSDB_CODE_MND_APP_ERROR;
-
- int32_t minIdPoolSize = TSDB_MAX_TABLES;
- int32_t maxIdPoolSize = tsMinTablePerVnode;
- for (int32_t v = 0; v < pDb->numOfVgroups; ++v) {
- SVgObj *pVgroup = pDb->vgList[v];
- if (pVgroup == NULL) continue;
-
- int32_t idPoolSize = taosIdPoolMaxSize(pVgroup->idPool);
- minIdPoolSize = MIN(minIdPoolSize, idPoolSize);
- maxIdPoolSize = MAX(maxIdPoolSize, idPoolSize);
- }
-
- // create one table each vnode
- if (pDb->cfg.dbType == TSDB_DB_TYPE_TOPIC) {
- maxIdPoolSize = 1;
- }
-
- // new vgroup
- if (pInputVgroup->idPool == NULL) {
- pInputVgroup->idPool = taosInitIdPool(maxIdPoolSize);
- if (pInputVgroup->idPool == NULL) {
- mError("vgId:%d, failed to init idPool for vgroup, size:%d", pInputVgroup->vgId, maxIdPoolSize);
- return TSDB_CODE_MND_OUT_OF_MEMORY;
- } else {
- mDebug("vgId:%d, init idPool for vgroup, size:%d", pInputVgroup->vgId, maxIdPoolSize);
- return TSDB_CODE_SUCCESS;
- }
- }
-
- // create one table each vnode
- if (pDb->cfg.dbType == TSDB_DB_TYPE_TOPIC) {
- return TSDB_CODE_SUCCESS;
- }
-
- // realloc all vgroups in db
- int32_t newIdPoolSize;
- if (minIdPoolSize * 4 < tsTableIncStepPerVnode) {
- newIdPoolSize = minIdPoolSize * 4;
- } else {
- newIdPoolSize = ((minIdPoolSize / tsTableIncStepPerVnode) + 1) * tsTableIncStepPerVnode;
- }
-
- if (newIdPoolSize > tsMaxTablePerVnode) {
- if (minIdPoolSize >= tsMaxTablePerVnode) {
- mError("db:%s, minIdPoolSize:%d newIdPoolSize:%d larger than maxTablesPerVnode:%d", pDb->name, minIdPoolSize, newIdPoolSize,
- tsMaxTablePerVnode);
- return TSDB_CODE_MND_NO_ENOUGH_DNODES;
- } else {
- newIdPoolSize = tsMaxTablePerVnode;
- }
- }
-
- for (int32_t v = 0; v < pDb->numOfVgroups; ++v) {
- SVgObj *pVgroup = pDb->vgList[v];
- if (pVgroup == NULL) continue;
-
- int32_t oldIdPoolSize = taosIdPoolMaxSize(pVgroup->idPool);
- if (newIdPoolSize == oldIdPoolSize) continue;
-
- if (taosUpdateIdPool(pVgroup->idPool, newIdPoolSize) < 0) {
- mError("vgId:%d, failed to update idPoolSize from %d to %d", pVgroup->vgId, oldIdPoolSize, newIdPoolSize);
- return TSDB_CODE_MND_NO_ENOUGH_DNODES;
- } else {
- mDebug("vgId:%d, idPoolSize update from %d to %d", pVgroup->vgId, oldIdPoolSize, newIdPoolSize);
- }
- }
-
- return TSDB_CODE_SUCCESS;
-}
-
-int32_t mnodeGetAvailableVgroup(SMnodeMsg *pMsg, SVgObj **ppVgroup, int32_t *pSid) {
- SDbObj *pDb = pMsg->pDb;
- pthread_mutex_lock(&pDb->mutex);
-
- for (int32_t v = 0; v < pDb->numOfVgroups; ++v) {
- int vgIndex = (v + pDb->vgListIndex) % pDb->numOfVgroups;
- SVgObj *pVgroup = pDb->vgList[vgIndex];
- if (pVgroup == NULL) {
- mError("db:%s, index:%d vgroup is null", pDb->name, vgIndex);
- pthread_mutex_unlock(&pDb->mutex);
- return TSDB_CODE_MND_APP_ERROR;
- }
-
- int32_t sid = taosAllocateId(pVgroup->idPool);
- if (sid <= 0) {
- mDebug("msg:%p, app:%p db:%s, no enough sid in vgId:%d", pMsg, pMsg->rpcMsg.ahandle, pDb->name, pVgroup->vgId);
- continue;
- }
- mTrace("vgId:%d, alloc tid:%d", pVgroup->vgId, sid);
-
- *pSid = sid;
- *ppVgroup = pVgroup;
- pDb->vgListIndex = vgIndex;
-
- pthread_mutex_unlock(&pDb->mutex);
- return TSDB_CODE_SUCCESS;
- }
-
- int maxVgroupsPerDb = tsMaxVgroupsPerDb;
- if (maxVgroupsPerDb <= 0) {
- maxVgroupsPerDb = mnodeGetOnlinDnodesCpuCoreNum();
- maxVgroupsPerDb = MAX(maxVgroupsPerDb, TSDB_MIN_VNODES_PER_DB);
- maxVgroupsPerDb = MIN(maxVgroupsPerDb, TSDB_MAX_VNODES_PER_DB);
- }
-
- if (pDb->cfg.dbType == TSDB_DB_TYPE_TOPIC) {
- maxVgroupsPerDb = TSDB_MAX_DB_PARTITON_OPTION;
- }
-
- int32_t code = TSDB_CODE_MND_NO_ENOUGH_DNODES;
- if (pDb->numOfVgroups < maxVgroupsPerDb) {
- mDebug("msg:%p, app:%p db:%s, try to create a new vgroup, numOfVgroups:%d maxVgroupsPerDb:%d", pMsg,
- pMsg->rpcMsg.ahandle, pDb->name, pDb->numOfVgroups, maxVgroupsPerDb);
- pthread_mutex_unlock(&pDb->mutex);
- code = mnodeCreateVgroup(pMsg);
- if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- return code;
- } else {
- pthread_mutex_lock(&pDb->mutex);
- }
- }
-
- if (pDb->numOfVgroups < 1) {
- pthread_mutex_unlock(&pDb->mutex);
- mDebug("msg:%p, app:%p db:%s, failed create new vgroup since:%s, numOfVgroups:%d maxVgroupsPerDb:%d ", pMsg,
- pMsg->rpcMsg.ahandle, pDb->name, tstrerror(code), pDb->numOfVgroups, maxVgroupsPerDb);
- return code;
- }
-
- SVgObj *pVgroup = pDb->vgList[0];
- if (pVgroup == NULL) {
- pthread_mutex_unlock(&pDb->mutex);
- return code;
- }
-
- code = mnodeAllocVgroupIdPool(pVgroup);
- if (code != TSDB_CODE_SUCCESS) {
- pthread_mutex_unlock(&pDb->mutex);
- return code;
- }
-
- int32_t sid = taosAllocateId(pVgroup->idPool);
- if (sid <= 0) {
- mError("msg:%p, app:%p db:%s, no enough sid in vgId:%d", pMsg, pMsg->rpcMsg.ahandle, pDb->name, pVgroup->vgId);
- pthread_mutex_unlock(&pDb->mutex);
- return TSDB_CODE_MND_NO_ENOUGH_DNODES;
- }
-
- *pSid = sid;
- *ppVgroup = pVgroup;
- pDb->vgListIndex = 0;
- pthread_mutex_unlock(&pDb->mutex);
-
- mTrace("vgId:%d, alloc tid:%d", pVgroup->vgId, sid);
- return TSDB_CODE_SUCCESS;
-}
-
-void *mnodeGetNextVgroup(void *pIter, SVgObj **pVgroup) {
- return sdbFetchRow(tsVgroupSdb, pIter, (void **)pVgroup);
-}
-
-void mnodeCancelGetNextVgroup(void *pIter) {
- sdbFreeIter(tsVgroupSdb, pIter);
-}
-
-static int32_t mnodeCreateVgroupFp(SMnodeMsg *pMsg) {
- SVgObj *pVgroup = pMsg->pVgroup;
- SDbObj *pDb = pMsg->pDb;
- assert(pVgroup);
-
- mInfo("msg:%p, app:%p vgId:%d, is created in mnode, db:%s replica:%d", pMsg, pMsg->rpcMsg.ahandle, pVgroup->vgId,
- pDb->name, pVgroup->numOfVnodes);
- for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
- mInfo("msg:%p, app:%p vgId:%d, index:%d, dnode:%d", pMsg, pMsg->rpcMsg.ahandle, pVgroup->vgId, i,
- pVgroup->vnodeGid[i].dnodeId);
- }
-
- pMsg->expected = pVgroup->numOfVnodes;
- pMsg->successed = 0;
- pMsg->received = 0;
- mnodeSendCreateVgroupMsg(pVgroup, pMsg);
-
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
-}
-
-static int32_t mnodeCreateVgroupCb(SMnodeMsg *pMsg, int32_t code) {
- SVgObj *pVgroup = pMsg->pVgroup;
- SDbObj *pDb = pMsg->pDb;
- assert(pVgroup);
-
- if (code != TSDB_CODE_SUCCESS) {
- mError("msg:%p, app:%p vgId:%d, failed to create in sdb, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pVgroup->vgId,
- tstrerror(code));
- SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pVgroup, .pTable = tsVgroupSdb};
- sdbDeleteRow(&desc);
-
- if (pMsg->pBatchMasterMsg) {
- ++pMsg->pBatchMasterMsg->received;
- pMsg->pBatchMasterMsg->code = pMsg->code;
- if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received
- >= pMsg->pBatchMasterMsg->expected) {
- dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, pMsg->code);
- }
-
- mnodeDestroySubMsg(pMsg);
-
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
- }
-
- return code;
- } else {
- mInfo("msg:%p, app:%p vgId:%d, is created in sdb, db:%s replica:%d", pMsg, pMsg->rpcMsg.ahandle, pVgroup->vgId,
- pDb->name, pVgroup->numOfVnodes);
- pVgroup->status = TAOS_VG_STATUS_READY;
- SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pVgroup, .pTable = tsVgroupSdb};
- (void)sdbUpdateRow(&desc);
-
- dnodeReprocessMWriteMsg(pMsg);
- return TSDB_CODE_MND_ACTION_IN_PROGRESS;
- // if (pVgroup->status == TAOS_VG_STATUS_CREATING || pVgroup->status == TAOS_VG_STATUS_READY) {
- // mInfo("msg:%p, app:%p vgId:%d, is created in sdb, db:%s replica:%d", pMsg, pMsg->rpcMsg.ahandle, pVgroup->vgId,
- // pDb->name, pVgroup->numOfVnodes);
- // pVgroup->status = TAOS_VG_STATUS_READY;
- // SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pVgroup, .pTable = tsVgroupSdb};
- // (void)sdbUpdateRow(&desc);
- // dnodeReprocessMWriteMsg(pMsg);
- // return TSDB_CODE_MND_ACTION_IN_PROGRESS;
- // } else {
- // mError("msg:%p, app:%p vgId:%d, is created in sdb, db:%s replica:%d, but vgroup is dropping", pMsg->rpcMsg.ahandle,
- // pMsg, pVgroup->vgId, pDb->name, pVgroup->numOfVnodes);
- // return TSDB_CODE_MND_VGROUP_NOT_EXIST;
- // }
- }
-}
-
-int32_t mnodeCreateVgroup(SMnodeMsg *pMsg) {
- if (pMsg == NULL) return TSDB_CODE_MND_APP_ERROR;
- SDbObj *pDb = pMsg->pDb;
-
- SVgObj *pVgroup = (SVgObj *)calloc(1, sizeof(SVgObj));
- tstrncpy(pVgroup->dbName, pDb->name, TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN);
- pVgroup->numOfVnodes = pDb->cfg.replications;
- pVgroup->createdTime = taosGetTimestampMs();
- pVgroup->accessState = TSDB_VN_ALL_ACCCESS;
- int32_t code = bnAllocVnodes(pVgroup);
- if (code != TSDB_CODE_SUCCESS) {
- mError("db:%s, no enough dnode to alloc %d vnodes to vgroup, reason:%s", pDb->name, pVgroup->numOfVnodes,
- tstrerror(code));
- free(pVgroup);
- return code;
- }
-
- if (pMsg->pVgroup != NULL) {
- mnodeDecVgroupRef(pMsg->pVgroup);
- }
-
- pMsg->pVgroup = pVgroup;
- mnodeIncVgroupRef(pVgroup);
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsVgroupSdb,
- .pObj = pVgroup,
- .rowSize = sizeof(SVgObj),
- .pMsg = pMsg,
- .fpReq = mnodeCreateVgroupFp
- };
-
- code = sdbInsertRow(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- pMsg->pVgroup = NULL;
- mnodeDestroyVgroup(pVgroup);
- }
-
- return code;
-}
-
-void mnodeDropVgroup(SVgObj *pVgroup, void *ahandle) {
- if (ahandle != NULL) {
- mnodeSendDropVgroupMsg(pVgroup, ahandle);
- } else {
- mDebug("vgId:%d, replica:%d is deleting from sdb", pVgroup->vgId, pVgroup->numOfVnodes);
- mnodeSendDropVgroupMsg(pVgroup, NULL);
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsVgroupSdb,
- .pObj = pVgroup
- };
- sdbDeleteRow(&row);
- }
-}
-
-void mnodeCleanupVgroups() {
- sdbCloseTable(tsVgroupRid);
- tsVgroupSdb = NULL;
-}
-
-int64_t mnodeGetVgroupNum() {
- return sdbGetNumOfRows(tsVgroupSdb);
-}
-
-static int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
- SDbObj *pDb = mnodeGetDb(pShow->db);
- if (pDb == NULL) {
- return TSDB_CODE_MND_DB_NOT_SELECTED;
- }
-
- if (pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
- mnodeDecDbRef(pDb);
- return TSDB_CODE_MND_DB_IN_DROPPING;
- }
-
- int32_t cols = 0;
- SSchema *pSchema = pMeta->schema;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "vgId");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "tables");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 8 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "status");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "onlines");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->maxReplica = 1;
- for (int32_t v = 0; v < pDb->numOfVgroups; ++v) {
- SVgObj *pVgroup = pDb->vgList[v];
- if (pVgroup != NULL) {
- pShow->maxReplica = pVgroup->numOfVnodes > pShow->maxReplica ? pVgroup->numOfVnodes : pShow->maxReplica;
- }
- }
-
- for (int32_t i = 0; i < pShow->maxReplica; ++i) {
- pShow->bytes[cols] = 2;
- pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- snprintf(pSchema[cols].name, TSDB_COL_NAME_LEN, "v%d_dnode", i + 1);
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
- pShow->bytes[cols] = 9 + VARSTR_HEADER_SIZE;
- pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- snprintf(pSchema[cols].name, TSDB_COL_NAME_LEN, "v%d_status", i + 1);
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
- }
-
- pShow->bytes[cols] = 4;
- pSchema[cols].type = TSDB_DATA_TYPE_INT;
- strcpy(pSchema[cols].name, "compacting");
- pSchema[cols].bytes = htons(pShow->bytes[cols]);
- cols++;
-
-
- pMeta->numOfColumns = htons(cols);
- pShow->numOfColumns = cols;
-
- pShow->offset[0] = 0;
- for (int32_t i = 1; i < cols; ++i) {
- pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
- }
-
- pShow->numOfRows = pDb->numOfVgroups;
- pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-
- mnodeDecDbRef(pDb);
- return 0;
-}
-
-static bool mnodeFilterVgroups(SVgObj *pVgroup, STableObj *pTable) {
- if (NULL == pTable || pTable->type == TSDB_SUPER_TABLE) {
- return true;
- }
-
- SCTableObj *pCTable = (SCTableObj *)pTable;
- if (pVgroup->vgId == pCTable->vgId) {
- return true;
- } else {
- return false;
- }
-}
-
-static int32_t mnodeRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
- int32_t numOfRows = 0;
- SVgObj *pVgroup = NULL;
- int32_t cols = 0;
- char * pWrite;
-
- SDbObj *pDb = mnodeGetDb(pShow->db);
- if (pDb == NULL) return 0;
-
- if (pDb->status != TSDB_DB_STATUS_READY) {
- mError("db:%s, status:%d, in dropping", pDb->name, pDb->status);
- mnodeDecDbRef(pDb);
- return 0;
- }
-
- STableObj *pTable = NULL;
- if (pShow->payloadLen > 0 ) {
- pTable = mnodeGetTable(pShow->payload);
- }
-
- while (numOfRows < rows) {
- pShow->pIter = mnodeGetNextVgroup(pShow->pIter, &pVgroup);
- if (pVgroup == NULL) break;
-
- if (pVgroup->pDb != pDb) {
- mnodeDecVgroupRef(pVgroup);
- continue;
- }
-
- if (!mnodeFilterVgroups(pVgroup, pTable)) {
- mnodeDecVgroupRef(pVgroup);
- continue;
- }
-
- cols = 0;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *) pWrite = pVgroup->vgId;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *) pWrite = pVgroup->numOfTables;
- cols++;
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- char* status = vgroupStatus[pVgroup->status];
- STR_TO_VARSTR(pWrite, status);
- cols++;
-
- int32_t onlineVnodes = 0;
- for (int32_t i = 0; i < pShow->maxReplica; ++i) {
- if (pVgroup->vnodeGid[i].role == TAOS_SYNC_ROLE_SLAVE || pVgroup->vnodeGid[i].role == TAOS_SYNC_ROLE_MASTER) {
- onlineVnodes++;
- }
- }
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int32_t *)pWrite = onlineVnodes;
- cols++;
-
- for (int32_t i = 0; i < pShow->maxReplica; ++i) {
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int16_t *) pWrite = pVgroup->vnodeGid[i].dnodeId;
- cols++;
-
- SDnodeObj * pDnode = pVgroup->vnodeGid[i].pDnode;
- const char *role = "NULL";
- if (pDnode != NULL) {
- role = syncRole[pVgroup->vnodeGid[i].role];
- }
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- STR_WITH_MAXSIZE_TO_VARSTR(pWrite, role, pShow->bytes[cols]);
- cols++;
- }
-
- pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
- *(int8_t *)pWrite = pVgroup->compact;
- cols++;
-
- mnodeDecVgroupRef(pVgroup);
- numOfRows++;
- }
-
- mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
-
- pShow->numOfReads += numOfRows;
- mnodeDecTableRef(pTable);
- mnodeDecDbRef(pDb);
-
- return numOfRows;
-}
-
-int32_t mnodeAddTableIntoVgroup(SVgObj *pVgroup, SCTableObj *pTable, bool needCheck) {
- int32_t idPoolSize = taosIdPoolMaxSize(pVgroup->idPool);
- if (pTable->tid > idPoolSize) {
- mnodeAllocVgroupIdPool(pVgroup);
- }
-
- if (pTable->tid >= 1) {
- if (taosIdPoolMarkStatus(pVgroup->idPool, pTable->tid) || !needCheck) {
- pVgroup->numOfTables++;
- mTrace("table:%s, vgId:%d tid:%d, mark tid used, uid:%" PRIu64, pTable->info.tableId, pTable->vgId, pTable->tid,
- pTable->uid);
- // The create vgroup message may be received later than the create table message
- // and the writing order in sdb is therefore uncertain
- // which will cause the reference count of the vgroup to be incorrect when restarting
- // mnodeIncVgroupRef(pVgroup);
- } else {
- mError("table:%s, vgId:%d tid:%d, failed to mark tid, uid:%" PRIu64, pTable->info.tableId, pTable->vgId,
- pTable->tid, pTable->uid);
- return -1;
- }
- }
-
- return 0;
-}
-
-void mnodeRemoveTableFromVgroup(SVgObj *pVgroup, SCTableObj *pTable) {
- if (pTable->tid >= 1) {
- taosFreeId(pVgroup->idPool, pTable->tid);
- pVgroup->numOfTables--;
- mTrace("table:%s, vgId:%d tid:%d, put tid back uid:%" PRIu64, pTable->info.tableId, pTable->vgId, pTable->tid,
- pTable->uid);
- // The create vgroup message may be received later than the create table message
- // and the writing order in sdb is therefore uncertain
- // which will cause the reference count of the vgroup to be incorrect when restarting
- // mnodeDecVgroupRef(pVgroup);
- }
-}
-
-static SCreateVnodeMsg *mnodeBuildVnodeMsg(SVgObj *pVgroup) {
- SDbObj *pDb = pVgroup->pDb;
- if (pDb == NULL) return NULL;
-
- SCreateVnodeMsg *pVnode = rpcMallocCont(sizeof(SCreateVnodeMsg));
- if (pVnode == NULL) return NULL;
-
- strcpy(pVnode->db, pVgroup->dbName);
- int32_t maxTables = taosIdPoolMaxSize(pVgroup->idPool);
- //TODO: dynamic alloc tables in tsdb
- maxTables = MAX(10000, tsMaxTablePerVnode);
-
- SVnodeCfg *pCfg = &pVnode->cfg;
- pCfg->vgId = htonl(pVgroup->vgId);
- pCfg->dbCfgVersion = htonl(pDb->dbCfgVersion);
- pCfg->vgCfgVersion = htonl(pVgroup->vgCfgVersion);
- pCfg->cacheBlockSize = htonl(pDb->cfg.cacheBlockSize);
- pCfg->totalBlocks = htonl(pDb->cfg.totalBlocks);
- pCfg->maxTables = htonl(maxTables + 1);
- pCfg->daysPerFile = htonl(pDb->cfg.daysPerFile);
- pCfg->daysToKeep = htonl(pDb->cfg.daysToKeep2); //FROM DB TO VNODE MAP:
- pCfg->daysToKeep1 = htonl(pDb->cfg.daysToKeep0); //keep0,keep1,keep2 in SQL is mapped to keep1,keep2,keep in vnode
- pCfg->daysToKeep2 = htonl(pDb->cfg.daysToKeep1); //user,client,mnode use keep0,keep1,keep2; vnode use keep1,keep2,keep
- pCfg->minRowsPerFileBlock = htonl(pDb->cfg.minRowsPerFileBlock);
- pCfg->maxRowsPerFileBlock = htonl(pDb->cfg.maxRowsPerFileBlock);
- pCfg->fsyncPeriod = htonl(pDb->cfg.fsyncPeriod);
- pCfg->commitTime = htonl(pDb->cfg.commitTime);
- pCfg->precision = pDb->cfg.precision;
- pCfg->compression = pDb->cfg.compression;
- pCfg->walLevel = pDb->cfg.walLevel;
- pCfg->vgReplica = (int8_t) pVgroup->numOfVnodes;
- pCfg->wals = 3;
- pCfg->quorum = pDb->cfg.quorum;
- pCfg->update = pDb->cfg.update;
- pCfg->cacheLastRow = pDb->cfg.cacheLastRow;
- pCfg->dbReplica = pDb->cfg.replications;
- pCfg->dbType = pDb->cfg.dbType;
-
- SVnodeDesc *pNodes = pVnode->nodes;
- for (int32_t j = 0; j < pVgroup->numOfVnodes; ++j) {
- SDnodeObj *pDnode = pVgroup->vnodeGid[j].pDnode;
- if (pDnode != NULL) {
- pNodes[j].nodeId = htonl(pDnode->dnodeId);
- strcpy(pNodes[j].nodeEp, pDnode->dnodeEp);
- }
- }
-
- return pVnode;
-}
-
-SRpcEpSet mnodeGetEpSetFromVgroup(SVgObj *pVgroup) {
- SRpcEpSet epSet = {
- .numOfEps = pVgroup->numOfVnodes,
- .inUse = pVgroup->inUse,
- };
- for (int i = 0; i < pVgroup->numOfVnodes; ++i) {
- strcpy(epSet.fqdn[i], pVgroup->vnodeGid[i].pDnode->dnodeFqdn);
- epSet.port[i] = pVgroup->vnodeGid[i].pDnode->dnodePort + TSDB_PORT_DNODEDNODE;
- }
- return epSet;
-}
-
-SRpcEpSet mnodeGetEpSetFromIp(char *ep) {
- SRpcEpSet epSet;
-
- epSet.numOfEps = 1;
- epSet.inUse = 0;
- taosGetFqdnPortFromEp(ep, epSet.fqdn[0], &epSet.port[0]);
- epSet.port[0] += TSDB_PORT_DNODEDNODE;
- return epSet;
-}
-
-static void mnodeSendAlterVnodeMsg(SVgObj *pVgroup, SRpcEpSet *epSet, SMnodeMsg *pMsg) {
- SAlterVnodeMsg *pAlter = mnodeBuildVnodeMsg(pVgroup);
- SRpcMsg rpcMsg = {
- .ahandle = pMsg,
- .pCont = pAlter,
- .contLen = pAlter ? sizeof(SAlterVnodeMsg) : 0,
- .code = 0,
- .msgType = TSDB_MSG_TYPE_MD_ALTER_VNODE
- };
- dnodeSendMsgToDnode(epSet, &rpcMsg);
-}
-
-void mnodeSendAlterVgroupMsg(SVgObj *pVgroup,SMnodeMsg *pMsg) {
- mDebug("vgId:%d, send alter all vnodes msg, numOfVnodes:%d db:%s", pVgroup->vgId, pVgroup->numOfVnodes,
- pVgroup->dbName);
- if (pMsg) {
- pMsg->pVgroup = pVgroup;
- mnodeIncVgroupRef(pVgroup);
- }
- for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
- SRpcEpSet epSet = mnodeGetEpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
- mDebug("vgId:%d, index:%d, send alter vnode msg to dnode %s", pVgroup->vgId, i,
- pVgroup->vnodeGid[i].pDnode->dnodeEp);
- mnodeSendAlterVnodeMsg(pVgroup, &epSet,pMsg);
- }
-}
-
-static SSyncVnodeMsg *mnodeBuildSyncVnodeMsg(int32_t vgId) {
- SSyncVnodeMsg *pSyncVnode = rpcMallocCont(sizeof(SSyncVnodeMsg));
- if (pSyncVnode == NULL) return NULL;
-
- pSyncVnode->vgId = htonl(vgId);
- return pSyncVnode;
-}
-
-
-static void mnodeSendSyncVnodeMsg(SVgObj *pVgroup, SRpcEpSet *epSet) {
- SSyncVnodeMsg *pSyncVnode = mnodeBuildSyncVnodeMsg(pVgroup->vgId);
- SRpcMsg rpcMsg = {
- .ahandle = NULL,
- .pCont = pSyncVnode,
- .contLen = pSyncVnode ? sizeof(SSyncVnodeMsg) : 0,
- .code = 0,
- .msgType = TSDB_MSG_TYPE_MD_SYNC_VNODE
- };
-
- dnodeSendMsgToDnode(epSet, &rpcMsg);
-}
-static void mnodeSendCompactVnodeMsg(SVgObj *pVgroup, SRpcEpSet *epSet) {
- SCompactVnodeMsg *pCompactVnode = mnodeBuildSyncVnodeMsg(pVgroup->vgId);
- SRpcMsg rpcMsg = {
- .ahandle = NULL,
- .pCont = pCompactVnode,
- .contLen = pCompactVnode ? sizeof(SCompactVnodeMsg) : 0,
- .code = 0,
- .msgType = TSDB_MSG_TYPE_MD_COMPACT_VNODE
- };
-
- dnodeSendMsgToDnode(epSet, &rpcMsg);
-}
-
-void mnodeSendSyncVgroupMsg(SVgObj *pVgroup) {
- mDebug("vgId:%d, send sync all vnodes msg, numOfVnodes:%d db:%s", pVgroup->vgId, pVgroup->numOfVnodes,
- pVgroup->dbName);
- for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
- if (pVgroup->vnodeGid[i].role != TAOS_SYNC_ROLE_SLAVE) continue;
- SRpcEpSet epSet = mnodeGetEpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
- mDebug("vgId:%d, index:%d, send sync vnode msg to dnode %s", pVgroup->vgId, i,
- pVgroup->vnodeGid[i].pDnode->dnodeEp);
- mnodeSendSyncVnodeMsg(pVgroup, &epSet);
- }
-}
-
-void mnodeSendCompactVgroupMsg(SVgObj *pVgroup) {
- mDebug("vgId:%d, send compact all vnodes msg, numOfVnodes:%d db:%s", pVgroup->vgId, pVgroup->numOfVnodes, pVgroup->dbName);
- for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
- //if (pVgroup->vnodeGid[i].role != TAOS_SYNC_ROLE_SLAVE) continue; //TODO(yihaoDeng): compact slave or not ?
- SRpcEpSet epSet = mnodeGetEpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
- mDebug("vgId:%d, index:%d, send compact vnode msg to dnode %s", pVgroup->vgId, i,
- pVgroup->vnodeGid[i].pDnode->dnodeEp);
- mnodeSendCompactVnodeMsg(pVgroup, &epSet);
- }
-
-}
-static void mnodeSendCreateVnodeMsg(SVgObj *pVgroup, SRpcEpSet *epSet, void *ahandle) {
- SCreateVnodeMsg *pCreate = mnodeBuildVnodeMsg(pVgroup);
- SRpcMsg rpcMsg = {
- .ahandle = ahandle,
- .pCont = pCreate,
- .contLen = pCreate ? sizeof(SCreateVnodeMsg) : 0,
- .code = 0,
- .msgType = TSDB_MSG_TYPE_MD_CREATE_VNODE
- };
- dnodeSendMsgToDnode(epSet, &rpcMsg);
-}
-
-void mnodeSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle) {
- mDebug("vgId:%d, send create all vnodes msg, numOfVnodes:%d db:%s", pVgroup->vgId, pVgroup->numOfVnodes,
- pVgroup->dbName);
- for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
- SRpcEpSet epSet = mnodeGetEpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
- mDebug("vgId:%d, index:%d, send create vnode msg to dnode %s, ahandle:%p", pVgroup->vgId,
- i, pVgroup->vnodeGid[i].pDnode->dnodeEp, ahandle);
- mnodeSendCreateVnodeMsg(pVgroup, &epSet, ahandle);
- }
-}
-
-static void mnodeProcessAlterVnodeRsp(SRpcMsg *rpcMsg) {
- mDebug("alter vnode rsp is received, handle:%p", rpcMsg->ahandle);
- if (rpcMsg->ahandle == NULL) return;
-
- SMnodeMsg *mnodeMsg = rpcMsg->ahandle;
- mnodeMsg->received++;
- if (rpcMsg->code == TSDB_CODE_SUCCESS) {
- mnodeMsg->code = rpcMsg->code;
- mnodeMsg->successed++;
- }
-
- SVgObj *pVgroup = mnodeMsg->pVgroup;
- mDebug("vgId:%d, alter vnode rsp received, result:%s received:%d successed:%d expected:%d, thandle:%p ahandle:%p",
- pVgroup->vgId, tstrerror(rpcMsg->code), mnodeMsg->received, mnodeMsg->successed, mnodeMsg->expected,
- mnodeMsg->rpcMsg.handle, rpcMsg->ahandle);
-
- if (mnodeMsg->received != mnodeMsg->expected) return;
-
- int32_t code = mnodeInsertAlterDbRow(pVgroup->pDb, mnodeMsg);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- dnodeSendRpcMWriteRsp(mnodeMsg, code);
- }
-}
-static void mnodeProcessCompactVnodeRsp(SRpcMsg *rpcMsg) {
- mDebug("compact vnode rsp received");
-}
-
-static void mnodeProcessCreateVnodeRsp(SRpcMsg *rpcMsg) {
- if (rpcMsg->ahandle == NULL) return;
-
- SMnodeMsg *mnodeMsg = rpcMsg->ahandle;
- atomic_add_fetch_8(&mnodeMsg->received, 1);
- if (rpcMsg->code == TSDB_CODE_SUCCESS) {
- atomic_add_fetch_8(&mnodeMsg->successed, 1);
- } else {
- mnodeMsg->code = rpcMsg->code;
- }
-
- SVgObj *pVgroup = mnodeMsg->pVgroup;
- mDebug("vgId:%d, create vnode rsp received, result:%s received:%d successed:%d expected:%d, thandle:%p ahandle:%p",
- pVgroup->vgId, tstrerror(rpcMsg->code), mnodeMsg->received, mnodeMsg->successed, mnodeMsg->expected,
- mnodeMsg->rpcMsg.handle, rpcMsg->ahandle);
-
- assert(mnodeMsg->received <= mnodeMsg->expected);
-
- if (mnodeMsg->received != mnodeMsg->expected) return;
-
- if (mnodeMsg->received == mnodeMsg->successed) {
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsVgroupSdb,
- .pObj = pVgroup,
- .rowSize = sizeof(SVgObj),
- .pMsg = mnodeMsg,
- .fpRsp = mnodeCreateVgroupCb
- };
-
- int32_t code = sdbInsertRowToQueue(&row);
- if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
- mnodeMsg->pVgroup = NULL;
- mnodeDestroyVgroup(pVgroup);
-
- if (mnodeMsg->pBatchMasterMsg) {
- ++mnodeMsg->pBatchMasterMsg->received;
- mnodeMsg->pBatchMasterMsg->code = code;
- if (mnodeMsg->pBatchMasterMsg->successed + mnodeMsg->pBatchMasterMsg->received
- >= mnodeMsg->pBatchMasterMsg->expected) {
- dnodeSendRpcMWriteRsp(mnodeMsg->pBatchMasterMsg, code);
- }
-
- mnodeDestroySubMsg(mnodeMsg);
-
- return;
- }
-
- dnodeSendRpcMWriteRsp(mnodeMsg, code);
- }
- } else {
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsVgroupSdb,
- .pObj = pVgroup
- };
- sdbDeleteRow(&row);
-
- if (mnodeMsg->pBatchMasterMsg) {
- ++mnodeMsg->pBatchMasterMsg->received;
- mnodeMsg->pBatchMasterMsg->code = mnodeMsg->code;
- if (mnodeMsg->pBatchMasterMsg->successed + mnodeMsg->pBatchMasterMsg->received
- >= mnodeMsg->pBatchMasterMsg->expected) {
- dnodeSendRpcMWriteRsp(mnodeMsg->pBatchMasterMsg, mnodeMsg->code);
- }
-
- mnodeDestroySubMsg(mnodeMsg);
-
- return;
- }
-
- dnodeSendRpcMWriteRsp(mnodeMsg, mnodeMsg->code);
- }
-}
-
-static SDropVnodeMsg *mnodeBuildDropVnodeMsg(int32_t vgId) {
- SDropVnodeMsg *pDrop = rpcMallocCont(sizeof(SDropVnodeMsg));
- if (pDrop == NULL) return NULL;
-
- pDrop->vgId = htonl(vgId);
- return pDrop;
-}
-
-void mnodeSendDropVnodeMsg(int32_t vgId, SRpcEpSet *epSet, void *ahandle) {
- SDropVnodeMsg *pDrop = mnodeBuildDropVnodeMsg(vgId);
- SRpcMsg rpcMsg = {
- .ahandle = ahandle,
- .pCont = pDrop,
- .contLen = pDrop ? sizeof(SDropVnodeMsg) : 0,
- .code = 0,
- .msgType = TSDB_MSG_TYPE_MD_DROP_VNODE
- };
- dnodeSendMsgToDnode(epSet, &rpcMsg);
-}
-
-static void mnodeSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle) {
- pVgroup->status = TAOS_VG_STATUS_DROPPING; // deleting
- mDebug("vgId:%d, send drop all vnodes msg, ahandle:%p db:%s", pVgroup->vgId, ahandle, pVgroup->dbName);
- for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
- SRpcEpSet epSet = mnodeGetEpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp);
- mDebug("vgId:%d, send drop vnode msg to dnode:%d, ahandle:%p", pVgroup->vgId, pVgroup->vnodeGid[i].dnodeId, ahandle);
- mnodeSendDropVnodeMsg(pVgroup->vgId, &epSet, ahandle);
- }
-}
-
-static void mnodeProcessDropVnodeRsp(SRpcMsg *rpcMsg) {
- mDebug("drop vnode rsp is received, handle:%p", rpcMsg->ahandle);
- if (rpcMsg->ahandle == NULL) return;
-
- SMnodeMsg *mnodeMsg = rpcMsg->ahandle;
- mnodeMsg->received++;
- if (rpcMsg->code == TSDB_CODE_SUCCESS) {
- mnodeMsg->code = rpcMsg->code;
- mnodeMsg->successed++;
- }
-
- SVgObj *pVgroup = mnodeMsg->pVgroup;
- mDebug("vgId:%d, drop vnode rsp received, result:%s received:%d successed:%d expected:%d, thandle:%p ahandle:%p",
- pVgroup->vgId, tstrerror(rpcMsg->code), mnodeMsg->received, mnodeMsg->successed, mnodeMsg->expected,
- mnodeMsg->rpcMsg.handle, rpcMsg->ahandle);
-
- if (mnodeMsg->received != mnodeMsg->expected) return;
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsVgroupSdb,
- .pObj = pVgroup
- };
- int32_t code = sdbDeleteRow(&row);
- if (code != 0) {
- code = TSDB_CODE_MND_SDB_ERROR;
- }
-
- dnodeReprocessMWriteMsg(mnodeMsg);
-}
-
-static int32_t mnodeProcessVnodeCfgMsg(SMnodeMsg *pMsg) {
- SConfigVnodeMsg *pCfg = pMsg->rpcMsg.pCont;
- pCfg->dnodeId = htonl(pCfg->dnodeId);
- pCfg->vgId = htonl(pCfg->vgId);
-
- SDnodeObj *pDnode = mnodeGetDnode(pCfg->dnodeId);
- if (pDnode == NULL) {
- mDebug("dnode:%s, vgId:%d, invalid dnode", taosIpStr(pCfg->dnodeId), pCfg->vgId);
- return TSDB_CODE_MND_VGROUP_NOT_EXIST;
- }
-
- SVgObj *pVgroup = mnodeGetVgroup(pCfg->vgId);
- if (pVgroup == NULL) {
- mDebug("dnode:%s, vgId:%d, no vgroup info", taosIpStr(pCfg->dnodeId), pCfg->vgId);
- mnodeDecDnodeRef(pDnode);
- return TSDB_CODE_MND_VGROUP_NOT_EXIST;
- }
-
- mDebug("vgId:%d, send create vnode msg to dnode %s for vnode cfg msg", pVgroup->vgId, pDnode->dnodeEp);
- SRpcEpSet epSet = mnodeGetEpSetFromIp(pDnode->dnodeEp);
- mnodeSendCreateVnodeMsg(pVgroup, &epSet, NULL);
-
- mnodeDecDnodeRef(pDnode);
- mnodeDecVgroupRef(pVgroup);
- return TSDB_CODE_SUCCESS;
-}
-
-void mnodeDropAllDnodeVgroups(SDnodeObj *pDropDnode) {
- void * pIter = NULL;
- SVgObj *pVgroup = NULL;
- int32_t numOfVgroups = 0;
-
- mInfo("dnode:%d, all vgroups will be dropped from sdb", pDropDnode->dnodeId);
-
- while (1) {
- pIter = mnodeGetNextVgroup(pIter, &pVgroup);
- if (pVgroup == NULL) break;
-
- if (pVgroup->vnodeGid[0].dnodeId == pDropDnode->dnodeId) {
- mnodeDropAllChildTablesInVgroups(pVgroup);
- SSdbRow row = {
- .type = SDB_OPER_LOCAL,
- .pTable = tsVgroupSdb,
- .pObj = pVgroup,
- };
- sdbDeleteRow(&row);
- numOfVgroups++;
- }
- mnodeDecVgroupRef(pVgroup);
- }
-
- mInfo("dnode:%d, all vgroups:%d is dropped from sdb", pDropDnode->dnodeId, numOfVgroups);
-}
-
-#if 0
-void mnodeUpdateAllDbVgroups(SDbObj *pAlterDb) {
- void * pIter = NULL;
- SVgObj *pVgroup = NULL;
-
- mInfo("db:%s, all vgroups will be update in sdb", pAlterDb->name);
-
- while (1) {
- pIter = mnodeGetNextVgroup(pIter, &pVgroup);
- if (pVgroup == NULL) break;
-
- if (pVgroup->pDb == pAlterDb) {
- mnodeVgroupUpdateIdPool(pVgroup);
- }
-
- mnodeDecVgroupRef(pVgroup);
- }
-
- mInfo("db:%s, all vgroups is updated in sdb", pAlterDb->name);
-}
-#endif
-
-void mnodeDropAllDbVgroups(SDbObj *pDropDb) {
- void * pIter = NULL;
- int32_t numOfVgroups = 0;
- SVgObj *pVgroup = NULL;
-
- mInfo("db:%s, all vgroups will be dropped from sdb", pDropDb->name);
- while (1) {
- pIter = mnodeGetNextVgroup(pIter, &pVgroup);
- if (pVgroup == NULL) break;
-
- if (pVgroup->pDb == pDropDb) {
- SSdbRow row = {
- .type = SDB_OPER_LOCAL,
- .pTable = tsVgroupSdb,
- .pObj = pVgroup,
- };
- sdbDeleteRow(&row);
- numOfVgroups++;
- }
-
- mnodeDecVgroupRef(pVgroup);
- }
-
- mInfo("db:%s, all vgroups:%d is dropped from sdb", pDropDb->name, numOfVgroups);
-}
-
-void mnodeSendDropAllDbVgroupsMsg(SDbObj *pDropDb) {
- void * pIter = NULL;
- int32_t numOfVgroups = 0;
- SVgObj *pVgroup = NULL;
-
- mInfo("db:%s, all vgroups will be dropped in dnode", pDropDb->name);
- while (1) {
- pIter = mnodeGetNextVgroup(pIter, &pVgroup);
- if (pVgroup == NULL) break;
-
- if (pVgroup->pDb == pDropDb) {
- mnodeSendDropVgroupMsg(pVgroup, NULL);
- }
-
- mnodeDecVgroupRef(pVgroup);
- numOfVgroups++;
- }
-
- mInfo("db:%s, all vgroups:%d drop msg is sent to dnode", pDropDb->name, numOfVgroups);
-}
-
-int32_t mnodeGetVgidVer(int8_t *cver) {
- int32_t iver = ((int32_t)cver[0]) * 10000 + ((int32_t)cver[1]) * 100 + (int32_t)cver[2];
- return iver;
-}
-
-void mnodeSetVgidVer(int8_t *cver, uint64_t iver) {
- cver[0] = (int8_t)((int32_t)(iver % 1000000) / 10000);
- cver[1] = (int8_t)((int32_t)(iver % 100000) / 100);
- cver[2] = (int8_t)(iver % 100);
-}
-
-int32_t mnodeCompactVgroups() {
- void *pIter = NULL;
- SVgObj *pVgroup = NULL;
-
- mInfo("start to compact vgroups table...");
-
- while (1) {
- pIter = mnodeGetNextVgroup(pIter, &pVgroup);
- if (pVgroup == NULL) break;
-
- SSdbRow row = {
- .type = SDB_OPER_GLOBAL,
- .pTable = tsVgroupSdb,
- .pObj = pVgroup,
- .rowSize = sizeof(SVgObj),
- };
-
- mInfo("compact vgroups %d", pVgroup->vgId);
-
- sdbInsertCompactRow(&row);
- }
-
- mInfo("end to compact vgroups table...");
-
- return 0;
-}
diff --git a/src/mnode/src/mnodeWrite.c b/src/mnode/src/mnodeWrite.c
deleted file mode 100644
index 9a993dfaafab725847a43097497287fbe5642511..0000000000000000000000000000000000000000
--- a/src/mnode/src/mnodeWrite.c
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * 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 .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taosdef.h"
-#include "tsched.h"
-#include "tbn.h"
-#include "tgrant.h"
-#include "tglobal.h"
-#include "trpc.h"
-#include "mnode.h"
-#include "dnode.h"
-#include "mnodeDef.h"
-#include "mnodeInt.h"
-#include "mnodeAcct.h"
-#include "mnodeDnode.h"
-#include "mnodeMnode.h"
-#include "mnodeDb.h"
-#include "mnodeSdb.h"
-#include "mnodeVgroup.h"
-#include "mnodeUser.h"
-#include "mnodeTable.h"
-#include "mnodeShow.h"
-
-static int32_t (*tsMnodeProcessWriteMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *);
-
-void mnodeAddWriteMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg)) {
- tsMnodeProcessWriteMsgFp[msgType] = fp;
-}
-
-int32_t mnodeProcessWrite(SMnodeMsg *pMsg) {
- if (pMsg->rpcMsg.pCont == NULL) {
- mError("msg:%p, app:%p type:%s content is null", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
- return TSDB_CODE_MND_INVALID_MSG_LEN;
- }
-
- if (!sdbIsMaster()) {
- SMnodeRsp *rpcRsp = &pMsg->rpcRsp;
- SRpcEpSet *epSet = rpcMallocCont(sizeof(SRpcEpSet));
- mnodeGetMnodeEpSetForShell(epSet, true);
- rpcRsp->rsp = epSet;
- rpcRsp->len = sizeof(SRpcEpSet);
-
- mDebug("msg:%p, app:%p type:%s in write queue, is redirected, numOfEps:%d inUse:%d", pMsg,
- pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], epSet->numOfEps, epSet->inUse);
-
- return TSDB_CODE_RPC_REDIRECT;
- }
-
- if (tsMnodeProcessWriteMsgFp[pMsg->rpcMsg.msgType] == NULL) {
- mError("msg:%p, app:%p type:%s not processed", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]);
- return TSDB_CODE_MND_MSG_NOT_PROCESSED;
- }
-
- int32_t code = grantCheck(TSDB_GRANT_TIME);
- if (code != TSDB_CODE_SUCCESS) {
- mError("msg:%p, app:%p type:%s not processed, reason:%s", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType],
- tstrerror(code));
- return code;
- }
-
- code = mnodeInitMsg(pMsg);
- if (code != TSDB_CODE_SUCCESS) {
- mError("msg:%p, app:%p type:%s not processed, reason:%s", pMsg, pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType],
- tstrerror(code));
- return code;
- }
-
- if (!pMsg->pUser->writeAuth) {
- mError("msg:%p, app:%p type:%s not processed, no write auth", pMsg, pMsg->rpcMsg.ahandle,
- taosMsg[pMsg->rpcMsg.msgType]);
- return TSDB_CODE_MND_NO_RIGHTS;
- }
-
- return (*tsMnodeProcessWriteMsgFp[pMsg->rpcMsg.msgType])(pMsg);
-}