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