From 406e170f59fb336406b173c7a7b9a3cb30d85577 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Mon, 25 May 2020 19:05:52 +0800 Subject: [PATCH 01/17] [TD-335] rename some function names --- src/dnode/inc/dnodeVRead.h | 8 ++++---- src/dnode/inc/dnodeVWrite.h | 9 ++++----- src/dnode/src/dnodeVRead.c | 4 ++-- src/dnode/src/dnodeVWrite.c | 4 ++-- 4 files changed, 12 insertions(+), 13 deletions(-) diff --git a/src/dnode/inc/dnodeVRead.h b/src/dnode/inc/dnodeVRead.h index 9e0c7b3120..a103520047 100644 --- a/src/dnode/inc/dnodeVRead.h +++ b/src/dnode/inc/dnodeVRead.h @@ -13,15 +13,15 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_DNODE_READ_H -#define TDENGINE_DNODE_READ_H +#ifndef TDENGINE_DNODE_VREAD_H +#define TDENGINE_DNODE_VREAD_H #ifdef __cplusplus extern "C" { #endif -int32_t dnodeInitRead(); -void dnodeCleanupRead(); +int32_t dnodeInitVnodeRead(); +void dnodeCleanupVnodeRead(); void dnodeDispatchToVnodeReadQueue(SRpcMsg *pMsg); #ifdef __cplusplus diff --git a/src/dnode/inc/dnodeVWrite.h b/src/dnode/inc/dnodeVWrite.h index 461e51983f..7da701a8e2 100644 --- a/src/dnode/inc/dnodeVWrite.h +++ b/src/dnode/inc/dnodeVWrite.h @@ -13,17 +13,16 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_DNODE_WRITE_H -#define TDENGINE_DNODE_WRITE_H +#ifndef TDENGINE_DNODE_VWRITE_H +#define TDENGINE_DNODE_VWRITE_H #ifdef __cplusplus extern "C" { #endif -int32_t dnodeInitWrite(); -void dnodeCleanupWrite(); +int32_t dnodeInitVnodeWrite(); +void dnodeCleanupVnodeWrite(); void dnodeDispatchToVnodeWriteQueue(SRpcMsg *pMsg); -void dnodeSendWriteResponse(void *pVnode, void *param, int32_t code); #ifdef __cplusplus } diff --git a/src/dnode/src/dnodeVRead.c b/src/dnode/src/dnodeVRead.c index 22505f2780..81d14702b1 100644 --- a/src/dnode/src/dnodeVRead.c +++ b/src/dnode/src/dnodeVRead.c @@ -53,7 +53,7 @@ static void dnodeHandleIdleReadWorker(SReadWorker *); static SReadWorkerPool readPool; static taos_qset readQset; -int32_t dnodeInitRead() { +int32_t dnodeInitVnodeRead() { readQset = taosOpenQset(); readPool.min = 2; @@ -71,7 +71,7 @@ int32_t dnodeInitRead() { return 0; } -void dnodeCleanupRead() { +void dnodeCleanupVnodeRead() { for (int i=0; i < readPool.max; ++i) { SReadWorker *pWorker = readPool.readWorker + i; if (pWorker->thread) { diff --git a/src/dnode/src/dnodeVWrite.c b/src/dnode/src/dnodeVWrite.c index a1531433ef..bf4e49e84d 100644 --- a/src/dnode/src/dnodeVWrite.c +++ b/src/dnode/src/dnodeVWrite.c @@ -54,7 +54,7 @@ static void dnodeHandleIdleWorker(SWriteWorker *pWorker); SWriteWorkerPool wWorkerPool; -int32_t dnodeInitWrite() { +int32_t dnodeInitVnodeWrite() { wWorkerPool.max = tsNumOfCores; wWorkerPool.writeWorker = (SWriteWorker *)calloc(sizeof(SWriteWorker), wWorkerPool.max); if (wWorkerPool.writeWorker == NULL) return -1; @@ -67,7 +67,7 @@ int32_t dnodeInitWrite() { return 0; } -void dnodeCleanupWrite() { +void dnodeCleanupVnodeWrite() { for (int32_t i = 0; i < wWorkerPool.max; ++i) { SWriteWorker *pWorker = wWorkerPool.writeWorker + i; if (pWorker->thread) { From 3b54b74554b278fa168a30543fc937f76c1007f5 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Tue, 26 May 2020 20:08:51 +0800 Subject: [PATCH 02/17] [TD-335] rename mgmt to mnode --- src/dnode/CMakeLists.txt | 2 +- src/dnode/inc/dnodeMRead.h | 31 +++ src/dnode/inc/dnodeMWrite.h | 31 +++ src/dnode/inc/dnodeMgmt.h | 2 + src/dnode/inc/dnodeMpeer.h | 31 +++ src/dnode/src/dnodeMRead.c | 160 +++++++++++++++ src/dnode/src/dnodeMWrite.c | 155 +++++++++++++++ src/dnode/src/dnodeMain.c | 21 +- src/dnode/src/dnodeMgmt.c | 24 ++- src/dnode/src/dnodeMpeer.c | 155 +++++++++++++++ src/dnode/src/dnodePeer.c | 16 +- src/dnode/src/dnodeShell.c | 56 +++--- src/dnode/src/dnodeVRead.c | 2 +- src/dnode/src/dnodeVWrite.c | 2 +- src/inc/dnode.h | 2 +- src/inc/mnode.h | 23 ++- src/mnode/inc/{mgmtAcct.h => mnodeAcct.h} | 0 .../inc/{mgmtDClient.h => mnodeDClient.h} | 0 src/mnode/inc/{mgmtDb.h => mnodeDb.h} | 0 src/mnode/inc/{mgmtDef.h => mnodeDef.h} | 2 +- src/mnode/inc/{mgmtDnode.h => mnodeDnode.h} | 0 src/mnode/inc/{mgmtInt.h => mnodeInt.h} | 0 src/mnode/inc/{mgmtMnode.h => mnodeMnode.h} | 4 +- .../inc/{mgmtProfile.h => mnodeProfile.h} | 0 src/mnode/inc/{mgmtSdb.h => mnodeSdb.h} | 0 src/mnode/inc/{mgmtServer.h => mnodeServer.h} | 4 +- src/mnode/inc/{mgmtShell.h => mnodeShell.h} | 14 +- src/mnode/inc/{mgmtTable.h => mnodeTable.h} | 0 src/mnode/inc/{mgmtUser.h => mnodeUser.h} | 0 src/mnode/inc/{mgmtVgroup.h => mnodeVgroup.h} | 2 +- src/mnode/src/mgmtServer.c | 106 ---------- src/mnode/src/{mgmtAcct.c => mnodeAcct.c} | 0 .../src/{mgmtBalance.c => mnodeBalance.c} | 0 src/mnode/src/{mgmtDb.c => mnodeDb.c} | 22 +-- src/mnode/src/{mgmtDnode.c => mnodeDnode.c} | 28 +-- src/mnode/src/{mgmtGrant.c => mnodeGrant.c} | 0 src/mnode/src/{mgmtMain.c => mnodeMain.c} | 63 ++++-- src/mnode/src/mnodeMgmt.c | 71 +++++++ src/mnode/src/{mgmtMnode.c => mnodeMnode.c} | 4 +- .../src/{mgmtProfile.c => mnodeProfile.c} | 18 +- src/mnode/src/mnodeRead.c | 83 ++++++++ src/mnode/src/{mgmtSdb.c => mnodeSdb.c} | 0 src/mnode/src/{mgmtShell.c => mnodeShow.c} | 183 +++++------------- src/mnode/src/{mgmtTable.c => mnodeTable.c} | 72 +++---- src/mnode/src/{mgmtUser.c => mnodeUser.c} | 16 +- src/mnode/src/{mgmtVgroup.c => mnodeVgroup.c} | 14 +- src/mnode/src/mnodeWrite.c | 96 +++++++++ 47 files changed, 1117 insertions(+), 398 deletions(-) create mode 100644 src/dnode/inc/dnodeMRead.h create mode 100644 src/dnode/inc/dnodeMWrite.h create mode 100644 src/dnode/inc/dnodeMpeer.h create mode 100644 src/dnode/src/dnodeMRead.c create mode 100644 src/dnode/src/dnodeMWrite.c create mode 100644 src/dnode/src/dnodeMpeer.c rename src/mnode/inc/{mgmtAcct.h => mnodeAcct.h} (100%) rename src/mnode/inc/{mgmtDClient.h => mnodeDClient.h} (100%) rename src/mnode/inc/{mgmtDb.h => mnodeDb.h} (100%) rename src/mnode/inc/{mgmtDef.h => mnodeDef.h} (99%) rename src/mnode/inc/{mgmtDnode.h => mnodeDnode.h} (100%) rename src/mnode/inc/{mgmtInt.h => mnodeInt.h} (100%) rename src/mnode/inc/{mgmtMnode.h => mnodeMnode.h} (93%) rename src/mnode/inc/{mgmtProfile.h => mnodeProfile.h} (100%) rename src/mnode/inc/{mgmtSdb.h => mnodeSdb.h} (100%) rename src/mnode/inc/{mgmtServer.h => mnodeServer.h} (93%) rename src/mnode/inc/{mgmtShell.h => mnodeShell.h} (75%) rename src/mnode/inc/{mgmtTable.h => mnodeTable.h} (100%) rename src/mnode/inc/{mgmtUser.h => mnodeUser.h} (100%) rename src/mnode/inc/{mgmtVgroup.h => mnodeVgroup.h} (97%) delete mode 100644 src/mnode/src/mgmtServer.c rename src/mnode/src/{mgmtAcct.c => mnodeAcct.c} (100%) rename src/mnode/src/{mgmtBalance.c => mnodeBalance.c} (100%) rename src/mnode/src/{mgmtDb.c => mnodeDb.c} (98%) rename src/mnode/src/{mgmtDnode.c => mnodeDnode.c} (96%) rename src/mnode/src/{mgmtGrant.c => mnodeGrant.c} (100%) rename src/mnode/src/{mgmtMain.c => mnodeMain.c} (80%) create mode 100644 src/mnode/src/mnodeMgmt.c rename src/mnode/src/{mgmtMnode.c => mnodeMnode.c} (98%) rename src/mnode/src/{mgmtProfile.c => mnodeProfile.c} (97%) create mode 100644 src/mnode/src/mnodeRead.c rename src/mnode/src/{mgmtSdb.c => mnodeSdb.c} (100%) rename src/mnode/src/{mgmtShell.c => mnodeShow.c} (72%) rename src/mnode/src/{mgmtTable.c => mnodeTable.c} (97%) rename src/mnode/src/{mgmtUser.c => mnodeUser.c} (96%) rename src/mnode/src/{mgmtVgroup.c => mnodeVgroup.c} (98%) create mode 100644 src/mnode/src/mnodeWrite.c diff --git a/src/dnode/CMakeLists.txt b/src/dnode/CMakeLists.txt index de6e15e6b9..2faea588a9 100644 --- a/src/dnode/CMakeLists.txt +++ b/src/dnode/CMakeLists.txt @@ -16,7 +16,7 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM)) AUX_SOURCE_DIRECTORY(src SRC) ADD_EXECUTABLE(taosd ${SRC}) - TARGET_LINK_LIBRARIES(taosd mnode taos_static monitor http mqtt tsdb twal vnode cJson lz4) + TARGET_LINK_LIBRARIES(taosd taos_static monitor http mqtt tsdb twal vnode cJson lz4) IF (TD_ACCOUNT) TARGET_LINK_LIBRARIES(taosd account) diff --git a/src/dnode/inc/dnodeMRead.h b/src/dnode/inc/dnodeMRead.h new file mode 100644 index 0000000000..0b340a865f --- /dev/null +++ b/src/dnode/inc/dnodeMRead.h @@ -0,0 +1,31 @@ +/* + * 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_DNODE_MREAD_H +#define TDENGINE_DNODE_MREAD_H + +#ifdef __cplusplus +extern "C" { +#endif + +int32_t dnodeInitMnodeRead(); +void dnodeCleanupMnodeRead(); +void dnodeDispatchToMnodeReadQueue(SRpcMsg *rpcMsg); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/dnode/inc/dnodeMWrite.h b/src/dnode/inc/dnodeMWrite.h new file mode 100644 index 0000000000..7a3ec93446 --- /dev/null +++ b/src/dnode/inc/dnodeMWrite.h @@ -0,0 +1,31 @@ +/* + * 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_DNODE_MWRITE_H +#define TDENGINE_DNODE_MWRITE_H + +#ifdef __cplusplus +extern "C" { +#endif + +int32_t dnodeInitMnodeWrite(); +void dnodeCleanupMnodeWrite(); +void dnodeDispatchToMnodeWriteQueue(SRpcMsg *pMsg); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/dnode/inc/dnodeMgmt.h b/src/dnode/inc/dnodeMgmt.h index 6f2af423bc..949a7c6eee 100644 --- a/src/dnode/inc/dnodeMgmt.h +++ b/src/dnode/inc/dnodeMgmt.h @@ -32,6 +32,8 @@ void* dnodeGetVnodeWal(void *pVnode); void* dnodeGetVnodeTsdb(void *pVnode); void dnodeReleaseVnode(void *pVnode); +void dnodeSendRediretMsg(SRpcMsg *pMsg); + #ifdef __cplusplus } #endif diff --git a/src/dnode/inc/dnodeMpeer.h b/src/dnode/inc/dnodeMpeer.h new file mode 100644 index 0000000000..93b31c1749 --- /dev/null +++ b/src/dnode/inc/dnodeMpeer.h @@ -0,0 +1,31 @@ +/* + * 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_DNODE_MMGMT_H +#define TDENGINE_DNODE_MMGMT_H + +#ifdef __cplusplus +extern "C" { +#endif + +int32_t dnodeInitMnodeMgmt(); +void dnodeCleanupMnodeMgmt(); +void dnodeDispatchToMnodeMgmtQueue(SRpcMsg *pMsg); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/dnode/src/dnodeMRead.c b/src/dnode/src/dnodeMRead.c new file mode 100644 index 0000000000..cd785a804e --- /dev/null +++ b/src/dnode/src/dnodeMRead.c @@ -0,0 +1,160 @@ +/* + * 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 "taosmsg.h" +#include "tutil.h" +#include "tqueue.h" +#include "trpc.h" +#include "twal.h" +#include "tglobal.h" +#include "mnode.h" +#include "dnode.h" +#include "dnodeInt.h" +#include "dnodeVMgmt.h" +#include "dnodeMRead.h" + +typedef struct { + pthread_t thread; + int32_t workerId; +} SMReadWorker; + +typedef struct { + int32_t num; + SMReadWorker *readWorker; +} SMReadWorkerPool; + +static SMReadWorkerPool tsMReadPool; +static taos_qset tsMReadQset; +static taos_queue tsMReadQueue; + +static void *dnodeProcessMnodeReadQueue(void *param); + +int32_t dnodeInitMnodeRead() { + tsMReadQset = taosOpenQset(); + + tsMReadPool.num = tsNumOfCores * tsNumOfThreadsPerCore / 2; + tsMReadPool.num = MAX(2, tsMReadPool.num); + tsMReadPool.num = MIN(4, tsMReadPool.num); + tsMReadPool.readWorker = (SMReadWorker *)calloc(sizeof(SMReadWorker), tsMReadPool.num); + + if (tsMReadPool.readWorker == NULL) return -1; + for (int32_t i = 0; i < tsMReadPool.num; ++i) { + SMReadWorker *pWorker = tsMReadPool.readWorker + i; + pWorker->workerId = i; + } + + dPrint("dnode mread is opened"); + return 0; +} + +void dnodeCleanupMnodeRead() { + for (int32_t i = 0; i < tsMReadPool.num; ++i) { + SMReadWorker *pWorker = tsMReadPool.readWorker + i; + if (pWorker->thread) { + taosQsetThreadResume(tsMReadQset); + } + } + + for (int32_t i = 0; i < tsMReadPool.num; ++i) { + SMReadWorker *pWorker = tsMReadPool.readWorker + i; + if (pWorker->thread) { + pthread_join(pWorker->thread, NULL); + } + } + + taosCloseQset(tsMReadQset); + free(tsMReadPool.readWorker); + + dPrint("dnode mread is closed"); +} + +int32_t dnodeAllocateMnodeRqueue() { + tsMReadQueue = taosOpenQueue(); + if (tsMReadQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + + taosAddIntoQset(tsMReadQset, tsMReadQueue, NULL); + + for (int32_t i = 0; i < tsMReadPool.num; ++i) { + SMReadWorker *pWorker = tsMReadPool.readWorker + 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, dnodeProcessMnodeReadQueue, pWorker) != 0) { + dError("failed to create thread to process mread queue, reason:%s", strerror(errno)); + } + + pthread_attr_destroy(&thAttr); + dTrace("dnode mread worker:%d is launched, total:%d", pWorker->workerId, tsMReadPool.num); + } + + dTrace("dnode mread queue:%p is allocated", tsMReadQueue); + return TSDB_CODE_SUCCESS; +} + +void dnodeFreeMnodeRqueue() { + taosCloseQueue(tsMReadQueue); + tsMReadQueue = NULL; +} + +void dnodeDispatchToMnodeReadQueue(SRpcMsg *pMsg) { + if (!mnodeIsRunning() || tsMReadQueue == NULL) { + dnodeSendRediretMsg(pMsg); + return; + } + + SMnodeMsg *pRead = (SMnodeMsg *)taosAllocateQitem(sizeof(SMnodeMsg)); + pRead->rpcMsg = *pMsg; + taosWriteQitem(tsMReadQueue, TAOS_QTYPE_RPC, pRead); +} + +static void dnodeSendRpcMnodeReadRsp(SMnodeMsg *pRead, int32_t code) { + if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + + SRpcMsg rpcRsp = { + .handle = pRead->rpcMsg.handle, + .pCont = pRead->rspRet.rsp, + .contLen = pRead->rspRet.len, + .code = pRead->rspRet.code, + }; + + rpcSendResponse(&rpcRsp); + rpcFreeCont(pRead->rpcMsg.pCont); +} + +static void *dnodeProcessMnodeReadQueue(void *param) { + SMnodeMsg *pReadMsg; + int32_t type; + void * unUsed; + + while (1) { + if (taosReadQitemFromQset(tsMReadQset, &type, (void **)&pReadMsg, &unUsed) == 0) { + dTrace("dnodeProcessMnodeReadQueue: got no message from qset, exiting..."); + break; + } + + dTrace("%p, msg:%s will be processed", pReadMsg->rpcMsg.ahandle, taosMsg[pReadMsg->rpcMsg.msgType]); + int32_t code = mnodeProcessRead(pReadMsg); + dnodeSendRpcMnodeReadRsp(pReadMsg, code); + taosFreeQitem(pReadMsg); + } + + return NULL; +} diff --git a/src/dnode/src/dnodeMWrite.c b/src/dnode/src/dnodeMWrite.c new file mode 100644 index 0000000000..b768b31b01 --- /dev/null +++ b/src/dnode/src/dnodeMWrite.c @@ -0,0 +1,155 @@ +/* + * 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 "taosmsg.h" +#include "tutil.h" +#include "tqueue.h" +#include "trpc.h" +#include "twal.h" +#include "tglobal.h" +#include "mnode.h" +#include "dnode.h" +#include "dnodeInt.h" +#include "dnodeVMgmt.h" +#include "dnodeMWrite.h" + +typedef struct { + pthread_t thread; + int32_t workerId; +} SMWriteWorker; + +typedef struct { + int32_t num; + SMWriteWorker *writeWorker; +} SMWriteWorkerPool; + +static SMWriteWorkerPool tsMWritePool; +static taos_qset tsMWriteQset; +static taos_queue tsMWriteQueue; + +static void *dnodeProcessMnodeWriteQueue(void *param); + +int32_t dnodeInitMnodeWrite() { + tsMWriteQset = taosOpenQset(); + + tsMWritePool.num = 1; + tsMWritePool.writeWorker = (SMWriteWorker *)calloc(sizeof(SMWriteWorker), tsMWritePool.num); + + if (tsMWritePool.writeWorker == NULL) return -1; + for (int32_t i = 0; i < tsMWritePool.num; ++i) { + SMWriteWorker *pWorker = tsMWritePool.writeWorker + i; + pWorker->workerId = i; + } + + dPrint("dnode mwrite is opened"); + return 0; +} + +void dnodeCleanupMnodeWrite() { + for (int32_t i = 0; i < tsMWritePool.num; ++i) { + SMWriteWorker *pWorker = tsMWritePool.writeWorker + i; + if (pWorker->thread) { + taosQsetThreadResume(tsMWriteQset); + } + } + + for (int32_t i = 0; i < tsMWritePool.num; ++i) { + SMWriteWorker *pWorker = tsMWritePool.writeWorker + i; + if (pWorker->thread) { + pthread_join(pWorker->thread, NULL); + } + } + + dPrint("dnode mwrite is closed"); +} + +int32_t dnodeAllocateMnodeRqueue() { + tsMWriteQueue = taosOpenQueue(); + if (tsMWriteQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + + taosAddIntoQset(tsMWriteQset, tsMWriteQueue, NULL); + + for (int32_t i = 0; i < tsMWritePool.num; ++i) { + SMWriteWorker *pWorker = tsMWritePool.writeWorker + 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, dnodeProcessMnodeWriteQueue, pWorker) != 0) { + dError("failed to create thread to process mwrite queue, reason:%s", strerror(errno)); + } + + pthread_attr_destroy(&thAttr); + dTrace("dnode mwrite worker:%d is launched, total:%d", pWorker->workerId, tsMWritePool.num); + } + + dTrace("dnode mwrite queue:%p is allocated", tsMWriteQueue); + return TSDB_CODE_SUCCESS; +} + +void dnodeFreeMnodeRqueue() { + taosCloseQueue(tsMWriteQueue); + tsMWriteQueue = NULL; +} + +void dnodeDispatchToMnodeWriteQueue(SRpcMsg *pMsg) { + if (!mnodeIsRunning() || tsMWriteQueue == NULL) { + dnodeSendRediretMsg(pMsg); + return; + } + + SMnodeMsg *pWrite = (SMnodeMsg *)taosAllocateQitem(sizeof(SMnodeMsg)); + pWrite->rpcMsg = *pMsg; + taosWriteQitem(tsMWriteQueue, TAOS_QTYPE_RPC, pWrite); +} + +static void dnodeSendRpcMnodeWriteRsp(SMnodeMsg *pWrite, int32_t code) { + if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + + SRpcMsg rpcRsp = { + .handle = pWrite->rpcMsg.handle, + .pCont = pWrite->rspRet.rsp, + .contLen = pWrite->rspRet.len, + .code = pWrite->rspRet.code, + }; + + rpcSendResponse(&rpcRsp); + rpcFreeCont(pWrite->rpcMsg.pCont); +} + +static void *dnodeProcessMnodeWriteQueue(void *param) { + SMnodeMsg *pWriteMsg; + int32_t type; + void * unUsed; + + while (1) { + if (taosReadQitemFromQset(tsMWriteQset, &type, (void **)&pWriteMsg, &unUsed) == 0) { + dTrace("dnodeProcessMnodeWriteQueue: got no message from qset, exiting..."); + break; + } + + dTrace("%p, msg:%s will be processed", pWriteMsg->rpcMsg.ahandle, taosMsg[pWriteMsg->rpcMsg.msgType]); + int32_t code = mnodeProcessWrite(pWriteMsg); + dnodeSendRpcMnodeWriteRsp(pWriteMsg, code); + taosFreeQitem(pWriteMsg); + } + + return NULL; +} diff --git a/src/dnode/src/dnodeMain.c b/src/dnode/src/dnodeMain.c index 68fe986989..e9e9480aef 100644 --- a/src/dnode/src/dnodeMain.c +++ b/src/dnode/src/dnodeMain.c @@ -21,12 +21,15 @@ #include "tglobal.h" #include "dnode.h" #include "dnodeInt.h" -#include "dnodeMgmt.h" +#include "dnodeVMgmt.h" #include "dnodePeer.h" #include "dnodeModule.h" #include "dnodeVRead.h" -#include "dnodeShell.h" #include "dnodeVWrite.h" +#include "dnodeMRead.h" +#include "dnodeMWrite.h" +#include "dnodeMMgmt.h" +#include "dnodeShell.h" static int32_t dnodeInitStorage(); static void dnodeCleanupStorage(); @@ -65,8 +68,11 @@ int32_t dnodeInitSystem() { dPrint("start to initialize TDengine on %s", tsLocalEp); if (dnodeInitStorage() != 0) return -1; - if (dnodeInitRead() != 0) return -1; - if (dnodeInitWrite() != 0) return -1; + if (dnodeInitVnodeRead() != 0) return -1; + if (dnodeInitVnodeWrite() != 0) return -1; + if (dnodeInitMnodeRead() != 0) return -1; + if (dnodeInitMnodeWrite() != 0) return -1; + if (dnodeInitMnodeMgmt() != 0) return -1; if (dnodeInitClient() != 0) return -1; if (dnodeInitServer() != 0) return -1; if (dnodeInitMgmt() != 0) return -1; @@ -89,8 +95,11 @@ void dnodeCleanUpSystem() { dnodeCleanupMgmt(); dnodeCleanupServer(); dnodeCleanupClient(); - dnodeCleanupWrite(); - dnodeCleanupRead(); + dnodeCleanupMnodeMgmt(); + dnodeCleanupMnodeWrite(); + dnodeCleanupMnodeRead(); + dnodeCleanupVnodeWrite(); + dnodeCleanupVnodeRead(); dnodeCleanupStorage(); taos_cleanup(); taosCloseLog(); diff --git a/src/dnode/src/dnodeMgmt.c b/src/dnode/src/dnodeMgmt.c index 4b28992aa4..442b517846 100644 --- a/src/dnode/src/dnodeMgmt.c +++ b/src/dnode/src/dnodeMgmt.c @@ -32,7 +32,7 @@ #include "vnode.h" #include "mnode.h" #include "dnodeInt.h" -#include "dnodeMgmt.h" +#include "dnodeVMgmt.h" #include "dnodeVRead.h" #include "dnodeVWrite.h" #include "dnodeModule.h" @@ -274,13 +274,16 @@ void dnodeUpdateIpSet(SRpcIpSet *pIpSet) { tsMnodeIpSet = *pIpSet; } -void dnodeGetMnodeDnodeIpSet(void *ipSetRaw) { +void dnodeGetMnodeDnodeIpSet(void *ipSetRaw, bool encode) { SRpcIpSet *ipSet = ipSetRaw; ipSet->numOfIps = tsMnodeInfos.nodeNum; ipSet->inUse = tsMnodeInfos.inUse; for (int32_t i = 0; i < tsMnodeInfos.nodeNum; ++i) { taosGetFqdnPortFromEp(tsMnodeInfos.nodeInfos[i].nodeEp, ipSet->fqdn[i], &ipSet->port[i]); ipSet->port[i] += TSDB_PORT_DNODEDNODE; + if (encode) { + ipSet->port[i] = htons(ipSet->port[i]); + } } } @@ -590,3 +593,20 @@ int32_t dnodeGetDnodeId() { return tsDnodeCfg.dnodeId; } +void dnodeSendRediretMsg(SRpcMsg *rpcMsg) { + SRpcConnInfo connInfo; + rpcGetConnInfo(rpcMsg->handle, &connInfo); + + SRpcIpSet ipSet = {0}; + dnodeGetMnodeDnodeIpSet(&ipSet); + + dTrace("msg:%s will be redirected, dnodeIp:%s user:%s, numOfIps:%d inUse:%d", taosMsg[rpcMsg->msgType], + taosIpStr(connInfo.clientIp), connInfo.user, ipSet.numOfIps, ipSet.inUse); + + for (int i = 0; i < ipSet.numOfIps; ++i) { + dTrace("mnode index:%d %s:%d", i, ipSet.fqdn[i], ipSet.port[i]); + ipSet.port[i] = htons(ipSet.port[i]); + } + + rpcSendRedirectRsp(rpcMsg->handle, &ipSet); +} \ No newline at end of file diff --git a/src/dnode/src/dnodeMpeer.c b/src/dnode/src/dnodeMpeer.c new file mode 100644 index 0000000000..d1bfa3a048 --- /dev/null +++ b/src/dnode/src/dnodeMpeer.c @@ -0,0 +1,155 @@ +/* + * 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 "taosmsg.h" +#include "tutil.h" +#include "tqueue.h" +#include "trpc.h" +#include "twal.h" +#include "tglobal.h" +#include "mnode.h" +#include "dnode.h" +#include "dnodeInt.h" +#include "dnodeVMgmt.h" +#include "dnodeMWrite.h" + +typedef struct { + pthread_t thread; + int32_t workerId; +} SMMgmtWorker; + +typedef struct { + int32_t num; + SMMgmtWorker *mgmtWorker; +} SMMgmtWorkerPool; + +static SMMgmtWorkerPool tsMMgmtPool; +static taos_qset tsMMgmtQset; +static taos_queue tsMMgmtQueue; + +static void *dnodeProcessMnodeMgmtQueue(void *param); + +int32_t dnodeInitMnodeMgmt() { + tsMMgmtQset = taosOpenQset(); + + tsMMgmtPool.num = 1; + tsMMgmtPool.mgmtWorker = (SMMgmtWorker *)calloc(sizeof(SMMgmtWorker), tsMMgmtPool.num); + + if (tsMMgmtPool.mgmtWorker == NULL) return -1; + for (int32_t i = 0; i < tsMMgmtPool.num; ++i) { + SMMgmtWorker *pWorker = tsMMgmtPool.mgmtWorker + i; + pWorker->workerId = i; + } + + dPrint("dnode mmgmt is opened"); + return 0; +} + +void dnodeCleanupMnodeMgmt() { + for (int32_t i = 0; i < tsMMgmtPool.num; ++i) { + SMMgmtWorker *pWorker = tsMMgmtPool.mgmtWorker + i; + if (pWorker->thread) { + taosQsetThreadResume(tsMMgmtQset); + } + } + + for (int32_t i = 0; i < tsMMgmtPool.num; ++i) { + SMMgmtWorker *pWorker = tsMMgmtPool.mgmtWorker + i; + if (pWorker->thread) { + pthread_join(pWorker->thread, NULL); + } + } + + dPrint("dnode mmgmt is closed"); +} + +int32_t dnodeAllocateMnodeMqueue() { + tsMMgmtQueue = taosOpenQueue(); + if (tsMMgmtQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + + taosAddIntoQset(tsMMgmtQset, tsMMgmtQueue, NULL); + + for (int32_t i = 0; i < tsMMgmtPool.num; ++i) { + SMMgmtWorker *pWorker = tsMMgmtPool.mgmtWorker + 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, dnodeProcessMnodeMgmtQueue, pWorker) != 0) { + dError("failed to create thread to process mmgmt queue, reason:%s", strerror(errno)); + } + + pthread_attr_destroy(&thAttr); + dTrace("dnode mmgmt worker:%d is launched, total:%d", pWorker->workerId, tsMMgmtPool.num); + } + + dTrace("dnode mmgmt queue:%p is allocated", tsMMgmtQueue); + return TSDB_CODE_SUCCESS; +} + +void dnodeFreeMnodeRqueue() { + taosCloseQueue(tsMMgmtQueue); + tsMMgmtQueue = NULL; +} + +void dnodeDispatchToMnodeMgmtQueue(SRpcMsg *pMsg) { + if (!mnodeIsRunning() || tsMMgmtQueue == NULL) { + dnodeSendRediretMsg(pMsg); + return; + } + + SMnodeMsg *pMgmt = (SMnodeMsg *)taosAllocateQitem(sizeof(SMnodeMsg)); + pMgmt->rpcMsg = *pMsg; + taosWriteQitem(tsMMgmtQueue, TAOS_QTYPE_RPC, pMgmt); +} + +static void dnodeSendRpcMnodeMgmtRsp(SMnodeMsg *pMgmt, int32_t code) { + if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + + SRpcMsg rpcRsp = { + .handle = pMgmt->rpcMsg.handle, + .pCont = pMgmt->rspRet.rsp, + .contLen = pMgmt->rspRet.len, + .code = pMgmt->rspRet.code, + }; + + rpcSendResponse(&rpcRsp); + rpcFreeCont(pMgmt->rpcMsg.pCont); +} + +static void *dnodeProcessMnodeMgmtQueue(void *param) { + SMnodeMsg *pMgmtMsg; + int32_t type; + void * unUsed; + + while (1) { + if (taosReadQitemFromQset(tsMMgmtQset, &type, (void **)&pMgmtMsg, &unUsed) == 0) { + dTrace("dnodeProcessMnodeMgmtQueue: got no message from qset, exiting..."); + break; + } + + dTrace("%p, msg:%s will be processed", pMgmtMsg->rpcMsg.ahandle, taosMsg[pMgmtMsg->rpcMsg.msgType]); + int32_t code = mnodeProcessMgmt(pMgmtMsg); + dnodeSendRpcMnodeMgmtRsp(pMgmtMsg, code); + taosFreeQitem(pMgmtMsg); + } + + return NULL; +} diff --git a/src/dnode/src/dnodePeer.c b/src/dnode/src/dnodePeer.c index c91da4953d..9695de1209 100644 --- a/src/dnode/src/dnodePeer.c +++ b/src/dnode/src/dnodePeer.c @@ -25,8 +25,10 @@ #include "trpc.h" #include "dnode.h" #include "dnodeInt.h" -#include "dnodeMgmt.h" +#include "dnodeVMgmt.h" #include "dnodeVWrite.h" +#include "dnodeMRead.h" +#include "dnodeMWrite.h" #include "mnode.h" extern void dnodeUpdateIpSet(SRpcIpSet *pIpSet); @@ -48,11 +50,11 @@ int32_t dnodeInitServer() { dnodeProcessReqMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM] = dnodeDispatchToDnodeMgmt; dnodeProcessReqMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE] = dnodeDispatchToDnodeMgmt; - dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = mgmtProcessReqMsgFromDnode; - dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = mgmtProcessReqMsgFromDnode; - dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_GRANT] = mgmtProcessReqMsgFromDnode; - dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_STATUS] = mgmtProcessReqMsgFromDnode; - dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_AUTH] = mgmtProcessReqMsgFromDnode; + dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = dnodeDispatchToMnodeReadQueue; + dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = dnodeDispatchToMnodeReadQueue; + dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_AUTH] = dnodeDispatchToMnodeReadQueue; + dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_GRANT] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_STATUS] = dnodeDispatchToMnodeWriteQueue; SRpcInit rpcInit; memset(&rpcInit, 0, sizeof(rpcInit)); @@ -167,6 +169,6 @@ void dnodeSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg) { void dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp) { SRpcIpSet ipSet = {0}; - dnodeGetMnodeDnodeIpSet(&ipSet); + dnodeGetMnodeDnodeIpSet(&ipSet, false); rpcSendRecv(tsDnodeClientRpc, &ipSet, rpcMsg, rpcRsp); } diff --git a/src/dnode/src/dnodeShell.c b/src/dnode/src/dnodeShell.c index fbed164839..031d860b1e 100644 --- a/src/dnode/src/dnodeShell.c +++ b/src/dnode/src/dnodeShell.c @@ -26,6 +26,8 @@ #include "dnodeInt.h" #include "dnodeVRead.h" #include "dnodeVWrite.h" +#include "dnodeMRead.h" +#include "dnodeMWrite.h" #include "dnodeShell.h" static void (*dnodeProcessShellMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *); @@ -43,35 +45,35 @@ int32_t dnodeInitShell() { dnodeProcessShellMsgFp[TSDB_MSG_TYPE_FETCH] = dnodeDispatchToVnodeReadQueue; // the following message shall be treated as mnode write - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CONNECT] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_ACCT] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_USER] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_USER] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE]= mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE]= mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM]= mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = mgmtProcessMsgFromShell; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_ACCT] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_USER] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_USER] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_USER] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE]= dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE]= dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_STREAM]= dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = dnodeDispatchToMnodeWriteQueue; // the following message shall be treated as mnode query - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_USE_DB] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLE_META] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_STABLE_VGROUP]= mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_SHOW] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = mgmtProcessMsgFromShell; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE]= mgmtProcessMsgFromShell; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CONNECT] = dnodeDispatchToMnodeReadQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_USE_DB] = dnodeDispatchToMnodeReadQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLE_META] = dnodeDispatchToMnodeReadQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_STABLE_VGROUP]= dnodeDispatchToMnodeReadQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = dnodeDispatchToMnodeReadQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_SHOW] = dnodeDispatchToMnodeReadQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = dnodeDispatchToMnodeReadQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE]= dnodeDispatchToMnodeReadQueue; int32_t numOfThreads = tsNumOfCores * tsNumOfThreadsPerCore; numOfThreads = (int32_t) ((1.0 - tsRatioOfQueryThreads) * numOfThreads / 2.0); diff --git a/src/dnode/src/dnodeVRead.c b/src/dnode/src/dnodeVRead.c index 81d14702b1..34bbdb5788 100644 --- a/src/dnode/src/dnodeVRead.c +++ b/src/dnode/src/dnodeVRead.c @@ -23,7 +23,7 @@ #include "twal.h" #include "tglobal.h" #include "dnodeInt.h" -#include "dnodeMgmt.h" +#include "dnodeVMgmt.h" #include "dnodeVRead.h" #include "vnode.h" diff --git a/src/dnode/src/dnodeVWrite.c b/src/dnode/src/dnodeVWrite.c index bf4e49e84d..3783b857d1 100644 --- a/src/dnode/src/dnodeVWrite.c +++ b/src/dnode/src/dnodeVWrite.c @@ -27,7 +27,7 @@ #include "tdataformat.h" #include "dnodeInt.h" #include "dnodeVWrite.h" -#include "dnodeMgmt.h" +#include "dnodeVMgmt.h" typedef struct { taos_qall qall; diff --git a/src/inc/dnode.h b/src/inc/dnode.h index 9884cf2870..bcab82cc5d 100644 --- a/src/inc/dnode.h +++ b/src/inc/dnode.h @@ -45,7 +45,7 @@ void dnodeSendRpcWriteRsp(void *pVnode, void *param, int32_t code); bool dnodeIsFirstDeploy(); char *dnodeGetMnodeMasterEp(); -void dnodeGetMnodeDnodeIpSet(void *ipSet); +void dnodeGetMnodeDnodeIpSet(void *ipSet, bool encode); void * dnodeGetMnodeInfos(); int32_t dnodeGetDnodeId(); diff --git a/src/inc/mnode.h b/src/inc/mnode.h index 48b1ac97bd..f025cb5e8a 100644 --- a/src/inc/mnode.h +++ b/src/inc/mnode.h @@ -20,17 +20,38 @@ extern "C" { #endif +typedef struct { + int len; + int code; + void *rsp; +} SMnodeRsp; + +typedef struct { + SRpcMsg rpcMsg; + SMnodeRsp rpcRsp; +} SMnodeMsg; + +SMnodeMsg *mnodeCreateMsg(SRpcMsg *rpcMsg); +bool mnodeInitMsg(SMnodeMsg *pMsg); +void mnodeRleaseMsg(SMnodeMsg *pMsg); + int32_t mgmtInitSystem(); int32_t mgmtStartSystem(); void mgmtCleanUpSystem(); void mgmtStopSystem(); void sdbUpdateSync(); +void* mnodeGetRqueue(void *); +void* mnodeGetWqueue(int32_t vgId); +bool mnodeIsRunning(); +int32_t mnodeProcessRead(SMnodeMsg *pMsg); +int32_t mnodeProcessWrite(SMnodeMsg *pMsg); +int32_t mnodeProcessMgmt(SMnodeMsg *pMsg); + int32_t mgmtRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey); void mgmtProcessMsgFromShell(SRpcMsg *rpcMsg); void mgmtProcessReqMsgFromDnode(SRpcMsg *rpcMsg); - #ifdef __cplusplus } #endif diff --git a/src/mnode/inc/mgmtAcct.h b/src/mnode/inc/mnodeAcct.h similarity index 100% rename from src/mnode/inc/mgmtAcct.h rename to src/mnode/inc/mnodeAcct.h diff --git a/src/mnode/inc/mgmtDClient.h b/src/mnode/inc/mnodeDClient.h similarity index 100% rename from src/mnode/inc/mgmtDClient.h rename to src/mnode/inc/mnodeDClient.h diff --git a/src/mnode/inc/mgmtDb.h b/src/mnode/inc/mnodeDb.h similarity index 100% rename from src/mnode/inc/mgmtDb.h rename to src/mnode/inc/mnodeDb.h diff --git a/src/mnode/inc/mgmtDef.h b/src/mnode/inc/mnodeDef.h similarity index 99% rename from src/mnode/inc/mgmtDef.h rename to src/mnode/inc/mnodeDef.h index 9d3e46205d..07920403b1 100644 --- a/src/mnode/inc/mgmtDef.h +++ b/src/mnode/inc/mnodeDef.h @@ -251,7 +251,7 @@ typedef struct { SDbObj *pDb; SVgObj *pVgroup; STableObj *pTable; -} SQueuedMsg; +} SMnodeMsg; #ifdef __cplusplus } diff --git a/src/mnode/inc/mgmtDnode.h b/src/mnode/inc/mnodeDnode.h similarity index 100% rename from src/mnode/inc/mgmtDnode.h rename to src/mnode/inc/mnodeDnode.h diff --git a/src/mnode/inc/mgmtInt.h b/src/mnode/inc/mnodeInt.h similarity index 100% rename from src/mnode/inc/mgmtInt.h rename to src/mnode/inc/mnodeInt.h diff --git a/src/mnode/inc/mgmtMnode.h b/src/mnode/inc/mnodeMnode.h similarity index 93% rename from src/mnode/inc/mgmtMnode.h rename to src/mnode/inc/mnodeMnode.h index 0973aa6ea6..123df73fb2 100644 --- a/src/mnode/inc/mgmtMnode.h +++ b/src/mnode/inc/mnodeMnode.h @@ -42,7 +42,9 @@ void mgmtIncMnodeRef(struct SMnodeObj *pMnode); void mgmtDecMnodeRef(struct SMnodeObj *pMnode); char * mgmtGetMnodeRoleStr(); -void mgmtGetMnodeIpSet(SRpcIpSet *ipSet); +void mgmtGetMnodeIpSetForPeer(SRpcIpSet *ipSet); +void mgmtGetMnodeIpSetForShell(SRpcIpSet *ipSet); + void mgmtGetMnodeInfos(void *mnodes); void mgmtUpdateMnodeIpSet(); diff --git a/src/mnode/inc/mgmtProfile.h b/src/mnode/inc/mnodeProfile.h similarity index 100% rename from src/mnode/inc/mgmtProfile.h rename to src/mnode/inc/mnodeProfile.h diff --git a/src/mnode/inc/mgmtSdb.h b/src/mnode/inc/mnodeSdb.h similarity index 100% rename from src/mnode/inc/mgmtSdb.h rename to src/mnode/inc/mnodeSdb.h diff --git a/src/mnode/inc/mgmtServer.h b/src/mnode/inc/mnodeServer.h similarity index 93% rename from src/mnode/inc/mgmtServer.h rename to src/mnode/inc/mnodeServer.h index 08e4463ad8..69df500bbc 100644 --- a/src/mnode/inc/mgmtServer.h +++ b/src/mnode/inc/mnodeServer.h @@ -20,8 +20,8 @@ extern "C" { #endif -int32_t mgmtInitServer(); -void mgmtCleanupServer(); +int32_t mnodeInitMgmt(); +void mgmtCleanupMgmt(); #ifdef __cplusplus } diff --git a/src/mnode/inc/mgmtShell.h b/src/mnode/inc/mnodeShell.h similarity index 75% rename from src/mnode/inc/mgmtShell.h rename to src/mnode/inc/mnodeShell.h index c3ae3e96e8..976dc360f3 100644 --- a/src/mnode/inc/mgmtShell.h +++ b/src/mnode/inc/mnodeShell.h @@ -23,15 +23,15 @@ extern "C" { int32_t mgmtInitShell(); void mgmtCleanUpShell(); -void mgmtAddShellMsgHandle(uint8_t msgType, void (*fp)(SQueuedMsg *queuedMsg)); +void mgmtAddShellMsgHandle(uint8_t msgType, void (*fp)(SMnodeMsg *queuedMsg)); typedef int32_t (*SShowMetaFp)(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); typedef int32_t (*SShowRetrieveFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn); -void mgmtAddShellShowMetaHandle(uint8_t showType, SShowMetaFp fp); -void mgmtAddShellShowRetrieveHandle(uint8_t showType, SShowRetrieveFp fp); +void mnodeAddShowMetaHandle(uint8_t showType, SShowMetaFp fp); +void mnodeAddShowRetrieveHandle(uint8_t showType, SShowRetrieveFp fp); -void mgmtAddToShellQueue(SQueuedMsg *queuedMsg); -void mgmtDealyedAddToShellQueue(SQueuedMsg *queuedMsg); +void mgmtAddToShellQueue(SMnodeMsg *queuedMsg); +void mgmtDealyedAddToShellQueue(SMnodeMsg *queuedMsg); void mgmtSendSimpleResp(void *thandle, int32_t code); bool mgmtCheckQhandle(uint64_t qhandle); @@ -39,8 +39,8 @@ void *mgmtSaveQhandle(void *qhandle, int32_t size); void mgmtFreeQhandle(void *qhandle, bool forceRemove); void *mgmtMallocQueuedMsg(SRpcMsg *rpcMsg); -void *mgmtCloneQueuedMsg(SQueuedMsg *pSrcMsg); -void mgmtFreeQueuedMsg(SQueuedMsg *pMsg); +void *mgmtCloneQueuedMsg(SMnodeMsg *pSrcMsg); +void mgmtFreeQueuedMsg(SMnodeMsg *pMsg); #ifdef __cplusplus } diff --git a/src/mnode/inc/mgmtTable.h b/src/mnode/inc/mnodeTable.h similarity index 100% rename from src/mnode/inc/mgmtTable.h rename to src/mnode/inc/mnodeTable.h diff --git a/src/mnode/inc/mgmtUser.h b/src/mnode/inc/mnodeUser.h similarity index 100% rename from src/mnode/inc/mgmtUser.h rename to src/mnode/inc/mnodeUser.h diff --git a/src/mnode/inc/mgmtVgroup.h b/src/mnode/inc/mnodeVgroup.h similarity index 97% rename from src/mnode/inc/mgmtVgroup.h rename to src/mnode/inc/mnodeVgroup.h index ab0345cd20..948aec06e5 100644 --- a/src/mnode/inc/mgmtVgroup.h +++ b/src/mnode/inc/mnodeVgroup.h @@ -35,7 +35,7 @@ void * mgmtGetNextVgroup(void *pIter, SVgObj **pVgroup); void mgmtUpdateVgroup(SVgObj *pVgroup); void mgmtUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *dnodeId, SVnodeLoad *pVload); -void mgmtCreateVgroup(SQueuedMsg *pMsg, SDbObj *pDb); +void mgmtCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb); void mgmtDropVgroup(SVgObj *pVgroup, void *ahandle); void mgmtAlterVgroup(SVgObj *pVgroup, void *ahandle); SVgObj *mgmtGetAvailableVgroup(SDbObj *pDb); diff --git a/src/mnode/src/mgmtServer.c b/src/mnode/src/mgmtServer.c deleted file mode 100644 index 7810189e34..0000000000 --- a/src/mnode/src/mgmtServer.c +++ /dev/null @@ -1,106 +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 "trpc.h" -#include "tsched.h" -#include "tsystem.h" -#include "tutil.h" -#include "tgrant.h" -#include "tbalance.h" -#include "tglobal.h" -#include "dnode.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtDb.h" -#include "mgmtMnode.h" -#include "mgmtProfile.h" -#include "mgmtShell.h" -#include "mgmtSdb.h" -#include "mgmtTable.h" -#include "mgmtVgroup.h" - -static void (*mgmtProcessDnodeMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *rpcMsg); -static void *tsMgmtServerQhandle = NULL; - -int32_t mgmtInitServer() { - - tsMgmtServerQhandle = taosInitScheduler(tsMaxShellConns, 1, "MS"); - - mPrint("server connection to dnode is opened"); - return 0; -} - -void mgmtCleanupServer() { - if (tsMgmtServerQhandle) { - taosCleanUpScheduler(tsMgmtServerQhandle); - tsMgmtServerQhandle = NULL; - } -} - -void dnodeAddServerMsgHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)) { - mgmtProcessDnodeMsgFp[msgType] = fp; -} - -static void mgmtProcessRequestFromDnode(SSchedMsg *sched) { - SRpcMsg *pMsg = sched->msg; - (*mgmtProcessDnodeMsgFp[pMsg->msgType])(pMsg); - rpcFreeCont(pMsg->pCont); - free(pMsg); -} - -static void mgmtAddToServerQueue(SRpcMsg *pMsg) { - SSchedMsg schedMsg; - schedMsg.msg = pMsg; - schedMsg.fp = mgmtProcessRequestFromDnode; - taosScheduleTask(tsMgmtServerQhandle, &schedMsg); -} - -void mgmtProcessReqMsgFromDnode(SRpcMsg *rpcMsg) { - if (mgmtProcessDnodeMsgFp[rpcMsg->msgType] == NULL) { - mError("%s is not processed in mnode", taosMsg[rpcMsg->msgType]); - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_MSG_NOT_PROCESSED); - rpcFreeCont(rpcMsg->pCont); - } - - if (rpcMsg->pCont == NULL) { - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_INVALID_MSG_LEN); - return; - } - - if (!sdbIsMaster()) { - SRpcConnInfo connInfo; - rpcGetConnInfo(rpcMsg->handle, &connInfo); - - SRpcIpSet ipSet = {0}; - dnodeGetMnodeDnodeIpSet(&ipSet); - for (int i = 0; i < ipSet.numOfIps; ++i) - ipSet.port[i] = htons(ipSet.port[i]); - - mTrace("conn from dnode ip:%s user:%s redirect msg, inUse:%d", taosIpStr(connInfo.clientIp), connInfo.user, ipSet.inUse); - for (int32_t i = 0; i < ipSet.numOfIps; ++i) { - mTrace("mnode index:%d %s:%d", i, ipSet.fqdn[i], htons(ipSet.port[i])); - } - rpcSendRedirectRsp(rpcMsg->handle, &ipSet); - return; - } - - SRpcMsg *pMsg = malloc(sizeof(SRpcMsg)); - memcpy(pMsg, rpcMsg, sizeof(SRpcMsg)); - mgmtAddToServerQueue(pMsg); -} - diff --git a/src/mnode/src/mgmtAcct.c b/src/mnode/src/mnodeAcct.c similarity index 100% rename from src/mnode/src/mgmtAcct.c rename to src/mnode/src/mnodeAcct.c diff --git a/src/mnode/src/mgmtBalance.c b/src/mnode/src/mnodeBalance.c similarity index 100% rename from src/mnode/src/mgmtBalance.c rename to src/mnode/src/mnodeBalance.c diff --git a/src/mnode/src/mgmtDb.c b/src/mnode/src/mnodeDb.c similarity index 98% rename from src/mnode/src/mgmtDb.c rename to src/mnode/src/mnodeDb.c index df18fe8786..09e53d13c9 100644 --- a/src/mnode/src/mgmtDb.c +++ b/src/mnode/src/mnodeDb.c @@ -41,13 +41,13 @@ static void * tsDbSdb = NULL; static int32_t tsDbUpdateSize; static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate); -static void mgmtDropDb(SQueuedMsg *newMsg); +static void mgmtDropDb(SMnodeMsg *newMsg); static int32_t mgmtSetDbDropping(SDbObj *pDb); static int32_t mgmtGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); static int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static void mgmtProcessCreateDbMsg(SQueuedMsg *pMsg); -static void mgmtProcessAlterDbMsg(SQueuedMsg *pMsg); -static void mgmtProcessDropDbMsg(SQueuedMsg *pMsg); +static void mgmtProcessCreateDbMsg(SMnodeMsg *pMsg); +static void mgmtProcessAlterDbMsg(SMnodeMsg *pMsg); +static void mgmtProcessDropDbMsg(SMnodeMsg *pMsg); static int32_t mgmtDbActionDestroy(SSdbOper *pOper) { tfree(pOper->pObj); @@ -150,8 +150,8 @@ int32_t mgmtInitDbs() { mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DB, mgmtProcessCreateDbMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_ALTER_DB, mgmtProcessAlterDbMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_DROP_DB, mgmtProcessDropDbMsg); - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_DB, mgmtGetDbMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_DB, mgmtRetrieveDbs); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DB, mgmtGetDbMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DB, mgmtRetrieveDbs); mTrace("table:dbs table is created"); return 0; @@ -748,7 +748,7 @@ static int32_t mgmtSetDbDropping(SDbObj *pDb) { return code; } -static void mgmtProcessCreateDbMsg(SQueuedMsg *pMsg) { +static void mgmtProcessCreateDbMsg(SMnodeMsg *pMsg) { SCMCreateDbMsg *pCreate = pMsg->pCont; pCreate->maxTables = htonl(pCreate->maxTables); @@ -935,7 +935,7 @@ static int32_t mgmtAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) { return TSDB_CODE_SUCCESS; } -static void mgmtProcessAlterDbMsg(SQueuedMsg *pMsg) { +static void mgmtProcessAlterDbMsg(SMnodeMsg *pMsg) { SCMAlterDbMsg *pAlter = pMsg->pCont; mTrace("db:%s, alter db msg is received from thandle:%p", pAlter->db, pMsg->thandle); @@ -963,7 +963,7 @@ static void mgmtProcessAlterDbMsg(SQueuedMsg *pMsg) { mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SUCCESS); } -static void mgmtDropDb(SQueuedMsg *pMsg) { +static void mgmtDropDb(SMnodeMsg *pMsg) { SDbObj *pDb = pMsg->pDb; mPrint("db:%s, drop db from sdb", pDb->name); @@ -980,7 +980,7 @@ static void mgmtDropDb(SQueuedMsg *pMsg) { mgmtSendSimpleResp(pMsg->thandle, code); } -static void mgmtProcessDropDbMsg(SQueuedMsg *pMsg) { +static void mgmtProcessDropDbMsg(SMnodeMsg *pMsg) { SCMDropDbMsg *pDrop = pMsg->pCont; mTrace("db:%s, drop db msg is received from thandle:%p", pDrop->db, pMsg->thandle); @@ -1022,7 +1022,7 @@ static void mgmtProcessDropDbMsg(SQueuedMsg *pMsg) { SVgObj *pVgroup = pMsg->pDb->pHead; if (pVgroup != NULL) { mPrint("vgId:%d, will be dropped", pVgroup->vgId); - SQueuedMsg *newMsg = mgmtCloneQueuedMsg(pMsg); + SMnodeMsg *newMsg = mgmtCloneQueuedMsg(pMsg); newMsg->ahandle = pVgroup; newMsg->expected = pVgroup->numOfVnodes; mgmtDropVgroup(pVgroup, newMsg); diff --git a/src/mnode/src/mgmtDnode.c b/src/mnode/src/mnodeDnode.c similarity index 96% rename from src/mnode/src/mgmtDnode.c rename to src/mnode/src/mnodeDnode.c index 93c8276b14..ce0b1d07e9 100644 --- a/src/mnode/src/mgmtDnode.c +++ b/src/mnode/src/mnodeDnode.c @@ -42,9 +42,9 @@ extern void * tsMnodeSdb; extern void * tsVgroupSdb; static int32_t mgmtCreateDnode(char *ep); -static void mgmtProcessCreateDnodeMsg(SQueuedMsg *pMsg); -static void mgmtProcessDropDnodeMsg(SQueuedMsg *pMsg); -static void mgmtProcessCfgDnodeMsg(SQueuedMsg *pMsg); +static void mgmtProcessCreateDnodeMsg(SMnodeMsg *pMsg); +static void mgmtProcessDropDnodeMsg(SMnodeMsg *pMsg); +static void mgmtProcessCfgDnodeMsg(SMnodeMsg *pMsg); static void mgmtProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) ; static void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg); static int32_t mgmtGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); @@ -153,14 +153,14 @@ int32_t mgmtInitDnodes() { mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CONFIG_DNODE, mgmtProcessCfgDnodeMsg); dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP, mgmtProcessCfgDnodeMsgRsp); dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_STATUS, mgmtProcessDnodeStatusMsg); - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_MODULE, mgmtGetModuleMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_MODULE, mgmtRetrieveModules); - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_CONFIGS, mgmtGetConfigMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_CONFIGS, mgmtRetrieveConfigs); - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_VNODES, mgmtGetVnodeMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_VNODES, mgmtRetrieveVnodes); - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_DNODE, mgmtGetDnodeMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_DNODE, mgmtRetrieveDnodes); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_MODULE, mgmtGetModuleMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_MODULE, mgmtRetrieveModules); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONFIGS, mgmtGetConfigMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONFIGS, mgmtRetrieveConfigs); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VNODES, mgmtGetVnodeMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VNODES, mgmtRetrieveVnodes); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DNODE, mgmtGetDnodeMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DNODE, mgmtRetrieveDnodes); mTrace("table:dnodes table is created"); return 0; @@ -236,7 +236,7 @@ void mgmtUpdateDnode(SDnodeObj *pDnode) { sdbUpdateRow(&oper); } -void mgmtProcessCfgDnodeMsg(SQueuedMsg *pMsg) { +void mgmtProcessCfgDnodeMsg(SMnodeMsg *pMsg) { SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; SCMCfgDnodeMsg *pCmCfgDnode = pMsg->pCont; @@ -451,7 +451,7 @@ static int32_t mgmtDropDnodeByEp(char *ep) { #endif } -static void mgmtProcessCreateDnodeMsg(SQueuedMsg *pMsg) { +static void mgmtProcessCreateDnodeMsg(SMnodeMsg *pMsg) { SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; SCMCreateDnodeMsg *pCreate = pMsg->pCont; @@ -472,7 +472,7 @@ static void mgmtProcessCreateDnodeMsg(SQueuedMsg *pMsg) { } -static void mgmtProcessDropDnodeMsg(SQueuedMsg *pMsg) { +static void mgmtProcessDropDnodeMsg(SMnodeMsg *pMsg) { SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; SCMDropDnodeMsg *pDrop = pMsg->pCont; diff --git a/src/mnode/src/mgmtGrant.c b/src/mnode/src/mnodeGrant.c similarity index 100% rename from src/mnode/src/mgmtGrant.c rename to src/mnode/src/mnodeGrant.c diff --git a/src/mnode/src/mgmtMain.c b/src/mnode/src/mnodeMain.c similarity index 80% rename from src/mnode/src/mgmtMain.c rename to src/mnode/src/mnodeMain.c index 2a8e139eec..204a8a638e 100644 --- a/src/mnode/src/mgmtMain.c +++ b/src/mnode/src/mnodeMain.c @@ -35,9 +35,13 @@ #include "mgmtTable.h" #include "mgmtShell.h" -extern void *tsMgmtTmr; +static void *tsMgmtTmr; static bool tsMgmtIsRunning = false; +static void mnodeInitTimer(); +static void mnodeCleanupTimer(); +static bool mnodeNeedStart() ; + int32_t mgmtStartSystem() { if (tsMgmtIsRunning) { mPrint("TDengine mgmt module already started..."); @@ -99,7 +103,7 @@ int32_t mgmtStartSystem() { return -1; } - if (mgmtInitServer() < 0) { + if (mnodeInitMgmt() < 0) { return -1; } @@ -112,16 +116,11 @@ int32_t mgmtStartSystem() { } int32_t mgmtInitSystem() { - if (mgmtInitShell() != 0) { - mError("failed to init shell"); - return -1; - } + mnodeInitTimer(); + mnodeInitRead(); + mnodeInitWrite(); - struct stat dirstat; - bool fileExist = (stat(tsMnodeDir, &dirstat) == 0); - bool asMaster = (strcmp(tsFirst, tsLocalEp) == 0); - - if (asMaster || fileExist) { + if (mnodeNeedStart()) { if (mgmtStartSystem() != 0) { return -1; } @@ -133,8 +132,12 @@ int32_t mgmtInitSystem() { void mgmtCleanUpSystem() { mPrint("starting to clean up mgmt"); tsMgmtIsRunning = false; - mgmtCleanUpShell(); - mgmtCleanupServer(); + + mnodeCleanupTimer(); + mnodeCleanupRead(); + mnodeCleanupWrite(); + + mgmtCleanupMgmt(); grantCleanUp(); balanceCleanUp(); sdbCleanUp(); @@ -153,9 +156,43 @@ void mgmtStopSystem() { mTrace("it is a master mgmt node, it could not be stopped"); return; } + mgmtCleanUpSystem(); mPrint("mgmt file is removed"); remove(tsMnodeDir); } + + + +void* mnodeGetWqueue(int32_t vgId) { + +} + + + +static void mnodeInitTimer() { + if (tsMgmtTmr != NULL) { + tsMgmtTmr = taosTmrInit((tsMaxShellConns)*3, 200, 3600000, "MND"); + } +} + +static void mnodeCleanupTimer() { + if (tsMgmtTmr != NULL) { + taosTmrCleanUp(tsMgmtTmr); + tsMgmtTmr = NULL; + } +} + +static bool mnodeNeedStart() { + struct stat dirstat; + bool fileExist = (stat(tsMnodeDir, &dirstat) == 0); + bool asMaster = (strcmp(tsFirst, tsLocalEp) == 0); + + if (asMaster || fileExist) { + return true; + } + + return false; +} diff --git a/src/mnode/src/mnodeMgmt.c b/src/mnode/src/mnodeMgmt.c new file mode 100644 index 0000000000..8833462406 --- /dev/null +++ b/src/mnode/src/mnodeMgmt.c @@ -0,0 +1,71 @@ +/* + * 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 "trpc.h" +#include "tsched.h" +#include "tsystem.h" +#include "tutil.h" +#include "tgrant.h" +#include "tbalance.h" +#include "tglobal.h" +#include "dnode.h" +#include "mgmtDef.h" +#include "mgmtInt.h" +#include "mgmtDb.h" +#include "mgmtMnode.h" +#include "mgmtProfile.h" +#include "mgmtShell.h" +#include "mgmtSdb.h" +#include "mgmtTable.h" +#include "mgmtVgroup.h" + +static void (*tsMnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *); + +void mnodeAddMgmtMsgHandle(uint8_t msgType, void (*fp)(SMnodeMsg *pMsg)) { + tsMnodeProcessMgmtMsgFp[msgType] = fp; +} + +int32_t mnodeProcessMgmt(SMnodeMsg *pMsg) { + SRpcMsg *rpcMsg = &pMsg->rpcMsg; + if (rpcMsg->pCont == NULL) { + mError("%p, msg:%s content is null", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + return TSDB_CODE_INVALID_MSG_LEN; + } + + if (!sdbIsMaster()) { + SMnodeRsp *rpcRsp = &pMsg->rpcRsp; + SRpcIpSet *ipSet = rpcMallocCont(sizeof(SRpcIpSet)); + mgmtGetMnodeIpSetForPeer(ipSet); + rpcRsp->rsp = ipSet; + rpcRsp->len = sizeof(SRpcIpSet); + + mTrace("%p, msg:%s will be redireced, inUse:%d", rpcMsg->ahandle, taosMsg[rpcMsg->msgType], ipSet->inUse); + for (int32_t i = 0; i < ipSet->numOfIps; ++i) { + mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); + } + + return TSDB_CODE_REDIRECT; + } + + if (tsMnodeProcessMgmtMsgFp[rpcMsg->msgType] == NULL) { + mError("%p, msg:%s not processed, no handle exist", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + return TSDB_CODE_MSG_NOT_PROCESSED; + } + + return (*tsMnodeProcessMgmtMsgFp[rpcMsg->msgType])(rpcMsg, ); +} diff --git a/src/mnode/src/mgmtMnode.c b/src/mnode/src/mnodeMnode.c similarity index 98% rename from src/mnode/src/mgmtMnode.c rename to src/mnode/src/mnodeMnode.c index 6471b7f182..aa028f594b 100644 --- a/src/mnode/src/mgmtMnode.c +++ b/src/mnode/src/mnodeMnode.c @@ -154,8 +154,8 @@ int32_t mgmtInitMnodes() { return -1; } - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_MNODE, mgmtGetMnodeMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_MNODE, mgmtRetrieveMnodes); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_MNODE, mgmtGetMnodeMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_MNODE, mgmtRetrieveMnodes); mTrace("table:mnodes table is created"); return TSDB_CODE_SUCCESS; diff --git a/src/mnode/src/mgmtProfile.c b/src/mnode/src/mnodeProfile.c similarity index 97% rename from src/mnode/src/mgmtProfile.c rename to src/mnode/src/mnodeProfile.c index 6667bff052..3cf340db4a 100644 --- a/src/mnode/src/mgmtProfile.c +++ b/src/mnode/src/mnodeProfile.c @@ -672,7 +672,7 @@ int32_t mgmtRetrieveConns(SShowObj *pShow, char *data, int32_t rows, void *pConn return numOfRows; } -void mgmtProcessKillQueryMsg(SQueuedMsg *pMsg) { +void mgmtProcessKillQueryMsg(SMnodeMsg *pMsg) { SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; SUserObj *pUser = mgmtGetUserFromConn(pMsg->thandle); @@ -696,7 +696,7 @@ void mgmtProcessKillQueryMsg(SQueuedMsg *pMsg) { mgmtDecUserRef(pUser); } -void mgmtProcessKillStreamMsg(SQueuedMsg *pMsg) { +void mgmtProcessKillStreamMsg(SMnodeMsg *pMsg) { SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; SUserObj *pUser = mgmtGetUserFromConn(pMsg->thandle); @@ -720,7 +720,7 @@ void mgmtProcessKillStreamMsg(SQueuedMsg *pMsg) { mgmtDecUserRef(pUser); } -void mgmtProcessKillConnectionMsg(SQueuedMsg *pMsg) { +void mgmtProcessKillConnectionMsg(SMnodeMsg *pMsg) { SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; SUserObj *pUser = mgmtGetUserFromConn(pMsg->thandle); @@ -745,12 +745,12 @@ void mgmtProcessKillConnectionMsg(SQueuedMsg *pMsg) { } int32_t mgmtInitProfile() { - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mgmtGetQueryMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mgmtRetrieveQueries); - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mgmtGetConnsMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mgmtRetrieveConns); - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_STREAMS, mgmtGetStreamMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMS, mgmtRetrieveStreams); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mgmtGetQueryMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mgmtRetrieveQueries); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mgmtGetConnsMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mgmtRetrieveConns); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_STREAMS, mgmtGetStreamMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMS, mgmtRetrieveStreams); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mgmtProcessKillQueryMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mgmtProcessKillStreamMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_CONN, mgmtProcessKillConnectionMsg); diff --git a/src/mnode/src/mnodeRead.c b/src/mnode/src/mnodeRead.c new file mode 100644 index 0000000000..8d06113f8a --- /dev/null +++ b/src/mnode/src/mnodeRead.c @@ -0,0 +1,83 @@ +/* + * 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 "tbalance.h" +#include "tgrant.h" +#include "ttimer.h" +#include "tglobal.h" +#include "mnode.h" +#include "dnode.h" +#include "mgmtDef.h" +#include "mgmtInt.h" +#include "mgmtServer.h" +#include "mgmtAcct.h" +#include "mgmtDnode.h" +#include "mgmtMnode.h" +#include "mgmtDb.h" +#include "mgmtSdb.h" +#include "mgmtVgroup.h" +#include "mgmtUser.h" +#include "mgmtTable.h" +#include "mgmtShell.h" + +static void (*tsMnodeProcessReadMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *); + +void mnodeAddReadMsgHandle(uint8_t msgType, void (*fp)(SMnodeMsg *pMsg)) { + tsMnodeProcessReadMsgFp[msgType] = fp; +} + +int32_t mnodeProcessRead(SMnodeMsg *pMsg) { + SRpcMsg *rpcMsg = &pMsg->rpcMsg; + if (rpcMsg->pCont == NULL) { + mError("%p, msg:%s content is null", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + return TSDB_CODE_INVALID_MSG_LEN; + } + + if (!sdbIsMaster()) { + SMnodeRsp *rpcRsp = &pMsg->rpcRsp; + SRpcIpSet *ipSet = rpcMallocCont(sizeof(SRpcIpSet)); + mgmtGetMnodeIpSetForShell(ipSet); + rpcRsp->rsp = ipSet; + rpcRsp->len = sizeof(SRpcIpSet); + + mTrace("%p, msg:%s will be redireced, inUse:%d", rpcMsg->ahandle, taosMsg[rpcMsg->msgType], ipSet->inUse); + for (int32_t i = 0; i < ipSet->numOfIps; ++i) { + mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); + } + + return TSDB_CODE_REDIRECT; + } + + if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) { + mError("%p, msg:%s not processed, grant time expired", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + return TSDB_CODE_GRANT_EXPIRED; + } + + if (tsMnodeProcessReadMsgFp[rpcMsg->msgType] == NULL) { + mError("%p, msg:%s not processed, no handle exist", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + return TSDB_CODE_MSG_NOT_PROCESSED; + } + + if (!mnodeInitMsg(pMsg)) { + mError("%p, msg:%s not processed, reason:%s", rpcMsg->ahandle, taosMsg[rpcMsg->msgType], tstrerror(terrno)); + return terrno; + } + + return (*tsMgmtProcessShellMsgFp[rpcMsg->msgType])(pMsg); +} diff --git a/src/mnode/src/mgmtSdb.c b/src/mnode/src/mnodeSdb.c similarity index 100% rename from src/mnode/src/mgmtSdb.c rename to src/mnode/src/mnodeSdb.c diff --git a/src/mnode/src/mgmtShell.c b/src/mnode/src/mnodeShow.c similarity index 72% rename from src/mnode/src/mgmtShell.c rename to src/mnode/src/mnodeShow.c index ccbed350dc..8138fafc06 100644 --- a/src/mnode/src/mgmtShell.c +++ b/src/mnode/src/mnodeShow.c @@ -41,142 +41,52 @@ typedef int32_t (*SShowMetaFp)(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); typedef int32_t (*SShowRetrieveFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static bool mgmtCheckMsgReadOnly(SQueuedMsg *pMsg); -static void mgmtProcessUnSupportMsg(SRpcMsg *rpcMsg); -static void mgmtProcessShowMsg(SQueuedMsg *queuedMsg); -static void mgmtProcessRetrieveMsg(SQueuedMsg *queuedMsg); -static void mgmtProcessHeartBeatMsg(SQueuedMsg *queuedMsg); -static void mgmtProcessConnectMsg(SQueuedMsg *queuedMsg); -static void mgmtProcessUseMsg(SQueuedMsg *queuedMsg); +static void mgmtProcessShowMsg(SMnodeMsg *queuedMsg); +static void mgmtProcessRetrieveMsg(SMnodeMsg *queuedMsg); +static void mgmtProcessHeartBeatMsg(SMnodeMsg *queuedMsg); +static void mgmtProcessConnectMsg(SMnodeMsg *queuedMsg); +static void mgmtProcessUseMsg(SMnodeMsg *queuedMsg); static void mgmtFreeShowObj(void *data); -void *tsMgmtTmr; -static void *tsMgmtTranQhandle = NULL; -static void (*tsMgmtProcessShellMsgFp[TSDB_MSG_TYPE_MAX])(SQueuedMsg *) = {0}; static void *tsQhandleCache = NULL; -static SShowMetaFp tsMgmtShowMetaFp[TSDB_MGMT_TABLE_MAX] = {0}; -static SShowRetrieveFp tsMgmtShowRetrieveFp[TSDB_MGMT_TABLE_MAX] = {0}; +static SShowMetaFp tsMnodeShowMetaFp[TSDB_MGMT_TABLE_MAX] = {0}; +static SShowRetrieveFp tsMnodeShowRetrieveFp[TSDB_MGMT_TABLE_MAX] = {0}; -int32_t mgmtInitShell() { - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_SHOW, mgmtProcessShowMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_RETRIEVE, mgmtProcessRetrieveMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_HEARTBEAT, mgmtProcessHeartBeatMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CONNECT, mgmtProcessConnectMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_USE_DB, mgmtProcessUseMsg); +void mnodeInitShow() { + mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_SHOW, mgmtProcessShowMsg); + mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_RETRIEVE, mgmtProcessRetrieveMsg); + mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_HEARTBEAT, mgmtProcessHeartBeatMsg); + mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_CONNECT, mgmtProcessConnectMsg); + mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_USE_DB, mgmtProcessUseMsg); - tsMgmtTmr = taosTmrInit((tsMaxShellConns) * 3, 200, 3600000, "MND"); - tsMgmtTranQhandle = taosInitScheduler(tsMaxShellConns, 1, "mnodeT"); tsQhandleCache = taosCacheInitWithCb(tsMgmtTmr, 10, mgmtFreeShowObj); - - return 0; } -void mgmtCleanUpShell() { - if (tsMgmtTmr != NULL){ - taosTmrCleanUp(tsMgmtTmr); - tsMgmtTmr = NULL; - } - +void mnodeCleanUpShow() { if (tsQhandleCache != NULL) { taosCacheCleanup(tsQhandleCache); tsQhandleCache = NULL; } - - if (tsMgmtTranQhandle != NULL) { - taosCleanUpScheduler(tsMgmtTranQhandle); - tsMgmtTranQhandle = NULL; - } } -void mgmtAddShellMsgHandle(uint8_t showType, void (*fp)(SQueuedMsg *queuedMsg)) { - tsMgmtProcessShellMsgFp[showType] = fp; +void mnodeAddShowMetaHandle(uint8_t showType, SShowMetaFp fp) { + tsMnodeShowMetaFp[showType] = fp; } -void mgmtAddShellShowMetaHandle(uint8_t showType, SShowMetaFp fp) { - tsMgmtShowMetaFp[showType] = fp; +void mnodeAddShowRetrieveHandle(uint8_t msgType, SShowRetrieveFp fp) { + tsMnodeShowRetrieveFp[msgType] = fp; } -void mgmtAddShellShowRetrieveHandle(uint8_t msgType, SShowRetrieveFp fp) { - tsMgmtShowRetrieveFp[msgType] = fp; +int32_t mnodeProcessRead(int msgType, void *pCont, int32_t contLen, SRspRet *ret) { + if (vnodeProcessReadMsgFp[msgType] == NULL) + return TSDB_CODE_MSG_NOT_PROCESSED; + + if (pVnode->status == TAOS_VN_STATUS_DELETING || pVnode->status == TAOS_VN_STATUS_CLOSING) + return TSDB_CODE_NOT_ACTIVE_VNODE; + + return (*vnodeProcessReadMsgFp[msgType])(pVnode, pCont, contLen, ret); } -void mgmtProcessTranRequest(SSchedMsg *sched) { - SQueuedMsg *queuedMsg = sched->msg; - (*tsMgmtProcessShellMsgFp[queuedMsg->msgType])(queuedMsg); - mgmtFreeQueuedMsg(queuedMsg); -} - -void mgmtAddToShellQueue(SQueuedMsg *queuedMsg) { - SSchedMsg schedMsg; - schedMsg.msg = queuedMsg; - schedMsg.fp = mgmtProcessTranRequest; - taosScheduleTask(tsMgmtTranQhandle, &schedMsg); -} - -static void mgmtDoDealyedAddToShellQueue(void *param, void *tmrId) { - mgmtAddToShellQueue(param); -} - -void mgmtDealyedAddToShellQueue(SQueuedMsg *queuedMsg) { - void *unUsed = NULL; - taosTmrReset(mgmtDoDealyedAddToShellQueue, 300, queuedMsg, tsMgmtTmr, &unUsed); -} - -void mgmtProcessMsgFromShell(SRpcMsg *rpcMsg) { - - mTrace("%p, msg:%s will be processed", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); - - if (rpcMsg->pCont == NULL) { - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_INVALID_MSG_LEN); - return; - } - - if (!sdbIsMaster()) { - SRpcConnInfo connInfo; - rpcGetConnInfo(rpcMsg->handle, &connInfo); - - SRpcIpSet ipSet = {0}; - mgmtGetMnodeIpSet(&ipSet); - mTrace("conn from shell ip:%s user:%s redirect msg, inUse:%d", taosIpStr(connInfo.clientIp), connInfo.user, ipSet.inUse); - for (int32_t i = 0; i < ipSet.numOfIps; ++i) { - mTrace("mnode index:%d ip:%s:%d", i, ipSet.fqdn[i], htons(ipSet.port[i])); - } - - rpcSendRedirectRsp(rpcMsg->handle, &ipSet); - return; - } - - if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) { - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_GRANT_EXPIRED); - rpcFreeCont(rpcMsg->pCont); - return; - } - - if (tsMgmtProcessShellMsgFp[rpcMsg->msgType] == NULL) { - mgmtProcessUnSupportMsg(rpcMsg); - rpcFreeCont(rpcMsg->pCont); - return; - } - - SQueuedMsg *pMsg = mgmtMallocQueuedMsg(rpcMsg); - if (pMsg == NULL) { - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_INVALID_USER); - rpcFreeCont(rpcMsg->pCont); - return; - } - - if (mgmtCheckMsgReadOnly(pMsg)) { - (*tsMgmtProcessShellMsgFp[rpcMsg->msgType])(pMsg); - mgmtFreeQueuedMsg(pMsg); - } else { - if (!pMsg->pUser->writeAuth) { - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS); - mgmtFreeQueuedMsg(pMsg); - } else { - mgmtAddToShellQueue(pMsg); - } - } -} char *mgmtGetShowTypeStr(int32_t showType) { switch (showType) { @@ -200,14 +110,14 @@ char *mgmtGetShowTypeStr(int32_t showType) { } } -static void mgmtProcessShowMsg(SQueuedMsg *pMsg) { +static void mgmtProcessShowMsg(SMnodeMsg *pMsg) { SCMShowMsg *pShowMsg = pMsg->pCont; if (pShowMsg->type >= TSDB_MGMT_TABLE_MAX) { mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_MSG_TYPE); return; } - if (!tsMgmtShowMetaFp[pShowMsg->type] || !tsMgmtShowRetrieveFp[pShowMsg->type]) { + if (!tsMnodeShowMetaFp[pShowMsg->type] || !tsMnodeShowRetrieveFp[pShowMsg->type]) { mError("show type:%s is not support", mgmtGetShowTypeStr(pShowMsg->type)); mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_OPS_NOT_SUPPORT); return; @@ -232,7 +142,7 @@ static void mgmtProcessShowMsg(SQueuedMsg *pMsg) { pShowRsp->qhandle = htobe64((uint64_t) pShow); mTrace("show:%p, type:%s, start to get meta", pShow, mgmtGetShowTypeStr(pShowMsg->type)); - int32_t code = (*tsMgmtShowMetaFp[pShowMsg->type])(&pShowRsp->tableMeta, pShow, pMsg->thandle); + int32_t code = (*tsMnodeShowMetaFp[pShowMsg->type])(&pShowRsp->tableMeta, pShow, pMsg->thandle); if (code == 0) { SRpcMsg rpcRsp = { .handle = pMsg->thandle, @@ -252,7 +162,7 @@ static void mgmtProcessShowMsg(SQueuedMsg *pMsg) { } } -static void mgmtProcessRetrieveMsg(SQueuedMsg *pMsg) { +static void mgmtProcessRetrieveMsg(SMnodeMsg *pMsg) { int32_t rowsToRead = 0; int32_t size = 0; int32_t rowsRead = 0; @@ -291,7 +201,7 @@ static void mgmtProcessRetrieveMsg(SQueuedMsg *pMsg) { // 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 = (*tsMgmtShowRetrieveFp[pShow->type])(pShow, pRsp->data, rowsToRead, pMsg->thandle); + rowsRead = (*tsMnodeShowRetrieveFp[pShow->type])(pShow, pRsp->data, rowsToRead, pMsg->thandle); if (rowsRead < 0) { // TSDB_CODE_ACTION_IN_PROGRESS; rpcFreeCont(pRsp); @@ -318,7 +228,7 @@ static void mgmtProcessRetrieveMsg(SQueuedMsg *pMsg) { } } -static void mgmtProcessHeartBeatMsg(SQueuedMsg *pMsg) { +static void mgmtProcessHeartBeatMsg(SMnodeMsg *pMsg) { SCMHeartBeatRsp *pHBRsp = (SCMHeartBeatRsp *) rpcMallocCont(sizeof(SCMHeartBeatRsp)); if (pHBRsp == NULL) { mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY); @@ -347,7 +257,7 @@ static void mgmtProcessHeartBeatMsg(SQueuedMsg *pMsg) { rpcSendResponse(&rpcRsp); } -static void mgmtProcessConnectMsg(SQueuedMsg *pMsg) { +static void mgmtProcessConnectMsg(SMnodeMsg *pMsg) { SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; SCMConnectMsg *pConnectMsg = pMsg->pCont; @@ -407,7 +317,7 @@ connect_over: rpcSendResponse(&rpcRsp); } -static void mgmtProcessUseMsg(SQueuedMsg *pMsg) { +static void mgmtProcessUseMsg(SMnodeMsg *pMsg) { SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; SCMUseDbMsg *pUseDbMsg = pMsg->pCont; @@ -426,7 +336,7 @@ static void mgmtProcessUseMsg(SQueuedMsg *pMsg) { /** * check if we need to add mgmtProcessTableMetaMsg into tranQueue, which will be executed one-by-one. */ -static bool mgmtCheckTableMetaMsgReadOnly(SQueuedMsg *pMsg) { +static bool mgmtCheckTableMetaMsgReadOnly(SMnodeMsg *pMsg) { SCMTableInfoMsg *pInfo = pMsg->pCont; if (pMsg->pTable == NULL) pMsg->pTable = mgmtGetTable(pInfo->tableId); if (pMsg->pTable != NULL) return true; @@ -441,7 +351,7 @@ static bool mgmtCheckTableMetaMsgReadOnly(SQueuedMsg *pMsg) { return true; } -static bool mgmtCheckMsgReadOnly(SQueuedMsg *pMsg) { +static bool mgmtCheckMsgReadOnly(SMnodeMsg *pMsg) { if (pMsg->msgType == TSDB_MSG_TYPE_CM_TABLE_META) { return mgmtCheckTableMetaMsgReadOnly(pMsg); } @@ -514,23 +424,30 @@ void mgmtFreeQhandle(void *qhandle, bool forceRemove) { taosCacheRelease(tsQhandleCache, &qhandle, forceRemove); } -void *mgmtMallocQueuedMsg(SRpcMsg *rpcMsg) { +void *mgmtMallocQueuedMsg(SRpcMsg *rpcMsg, SRspRet *pRet) { SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle); if (pUser == NULL) { + terrno = TSDB_CODE_INVALID_USER; + return NULL; + } + + SMnodeMsg *pMsg = calloc(1, sizeof(SMnodeMsg)); + if (pMsg == NULL) { + terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; return NULL; } - SQueuedMsg *pMsg = calloc(1, sizeof(SQueuedMsg)); pMsg->thandle = rpcMsg->handle; pMsg->msgType = rpcMsg->msgType; pMsg->contLen = rpcMsg->contLen; - pMsg->pCont = rpcMsg->pCont; - pMsg->pUser = pUser; + pMsg->pCont = rpcMsg->pCont; + pMsg->pUser = pUser; + pMsg->pRet = pRet; return pMsg; } -void mgmtFreeQueuedMsg(SQueuedMsg *pMsg) { +void mgmtFreeQueuedMsg(SMnodeMsg *pMsg) { if (pMsg != NULL) { rpcFreeCont(pMsg->pCont); if (pMsg->pUser) mgmtDecUserRef(pMsg->pUser); @@ -543,8 +460,8 @@ void mgmtFreeQueuedMsg(SQueuedMsg *pMsg) { } } -void* mgmtCloneQueuedMsg(SQueuedMsg *pSrcMsg) { - SQueuedMsg *pDestMsg = calloc(1, sizeof(SQueuedMsg)); +void* mgmtCloneQueuedMsg(SMnodeMsg *pSrcMsg) { + SMnodeMsg *pDestMsg = calloc(1, sizeof(SMnodeMsg)); pDestMsg->thandle = pSrcMsg->thandle; pDestMsg->msgType = pSrcMsg->msgType; diff --git a/src/mnode/src/mgmtTable.c b/src/mnode/src/mnodeTable.c similarity index 97% rename from src/mnode/src/mgmtTable.c rename to src/mnode/src/mnodeTable.c index 53fbd64f87..609be0f542 100644 --- a/src/mnode/src/mgmtTable.c +++ b/src/mnode/src/mnodeTable.c @@ -58,27 +58,27 @@ static int32_t mgmtRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, static int32_t mgmtRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn); static int32_t mgmtGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static void mgmtProcessCreateTableMsg(SQueuedMsg *queueMsg); -static void mgmtProcessCreateSuperTableMsg(SQueuedMsg *pMsg); -static void mgmtProcessCreateChildTableMsg(SQueuedMsg *pMsg); +static void mgmtProcessCreateTableMsg(SMnodeMsg *queueMsg); +static void mgmtProcessCreateSuperTableMsg(SMnodeMsg *pMsg); +static void mgmtProcessCreateChildTableMsg(SMnodeMsg *pMsg); static void mgmtProcessCreateChildTableRsp(SRpcMsg *rpcMsg); -static void mgmtProcessDropTableMsg(SQueuedMsg *queueMsg); -static void mgmtProcessDropSuperTableMsg(SQueuedMsg *pMsg); +static void mgmtProcessDropTableMsg(SMnodeMsg *queueMsg); +static void mgmtProcessDropSuperTableMsg(SMnodeMsg *pMsg); static void mgmtProcessDropSuperTableRsp(SRpcMsg *rpcMsg); -static void mgmtProcessDropChildTableMsg(SQueuedMsg *pMsg); +static void mgmtProcessDropChildTableMsg(SMnodeMsg *pMsg); static void mgmtProcessDropChildTableRsp(SRpcMsg *rpcMsg); -static void mgmtProcessSuperTableVgroupMsg(SQueuedMsg *queueMsg); -static void mgmtProcessMultiTableMetaMsg(SQueuedMsg *queueMsg); +static void mgmtProcessSuperTableVgroupMsg(SMnodeMsg *queueMsg); +static void mgmtProcessMultiTableMetaMsg(SMnodeMsg *queueMsg); static void mgmtProcessTableCfgMsg(SRpcMsg *rpcMsg); -static void mgmtProcessTableMetaMsg(SQueuedMsg *queueMsg); -static void mgmtGetSuperTableMeta(SQueuedMsg *pMsg); -static void mgmtGetChildTableMeta(SQueuedMsg *pMsg); -static void mgmtAutoCreateChildTable(SQueuedMsg *pMsg); +static void mgmtProcessTableMetaMsg(SMnodeMsg *queueMsg); +static void mgmtGetSuperTableMeta(SMnodeMsg *pMsg); +static void mgmtGetChildTableMeta(SMnodeMsg *pMsg); +static void mgmtAutoCreateChildTable(SMnodeMsg *pMsg); -static void mgmtProcessAlterTableMsg(SQueuedMsg *queueMsg); +static void mgmtProcessAlterTableMsg(SMnodeMsg *queueMsg); static void mgmtProcessAlterTableRsp(SRpcMsg *rpcMsg); static int32_t mgmtFindSuperTableColumnIndex(SSuperTableObj *pStable, char *colName); @@ -559,10 +559,10 @@ int32_t mgmtInitTables() { dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_TABLE, mgmtProcessTableCfgMsg); - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_TABLE, mgmtGetShowTableMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_TABLE, mgmtRetrieveShowTables); - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_METRIC, mgmtGetShowSuperTableMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_METRIC, mgmtRetrieveShowSuperTables); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_TABLE, mgmtGetShowTableMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_TABLE, mgmtRetrieveShowTables); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_METRIC, mgmtGetShowSuperTableMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_METRIC, mgmtRetrieveShowSuperTables); return TSDB_CODE_SUCCESS; } @@ -655,7 +655,7 @@ static void mgmtExtractTableName(char* tableId, char* name) { } } -static void mgmtProcessCreateTableMsg(SQueuedMsg *pMsg) { +static void mgmtProcessCreateTableMsg(SMnodeMsg *pMsg) { SCMCreateTableMsg *pCreate = pMsg->pCont; if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDb(pCreate->db); @@ -689,7 +689,7 @@ static void mgmtProcessCreateTableMsg(SQueuedMsg *pMsg) { } } -static void mgmtProcessDropTableMsg(SQueuedMsg *pMsg) { +static void mgmtProcessDropTableMsg(SMnodeMsg *pMsg) { SCMDropTableMsg *pDrop = pMsg->pCont; if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDbByTableId(pDrop->tableId); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { @@ -726,7 +726,7 @@ static void mgmtProcessDropTableMsg(SQueuedMsg *pMsg) { } } -static void mgmtProcessTableMetaMsg(SQueuedMsg *pMsg) { +static void mgmtProcessTableMetaMsg(SMnodeMsg *pMsg) { SCMTableInfoMsg *pInfo = pMsg->pCont; pInfo->createFlag = htons(pInfo->createFlag); mTrace("table:%s, table meta msg is received from thandle:%p, createFlag:%d", pInfo->tableId, pMsg->thandle, pInfo->createFlag); @@ -755,7 +755,7 @@ static void mgmtProcessTableMetaMsg(SQueuedMsg *pMsg) { } } -static void mgmtProcessCreateSuperTableMsg(SQueuedMsg *pMsg) { +static void mgmtProcessCreateSuperTableMsg(SMnodeMsg *pMsg) { SCMCreateTableMsg *pCreate = pMsg->pCont; SSuperTableObj *pStable = calloc(1, sizeof(SSuperTableObj)); if (pStable == NULL) { @@ -812,7 +812,7 @@ static void mgmtProcessCreateSuperTableMsg(SQueuedMsg *pMsg) { } } -static void mgmtProcessDropSuperTableMsg(SQueuedMsg *pMsg) { +static void mgmtProcessDropSuperTableMsg(SMnodeMsg *pMsg) { SSuperTableObj *pStable = (SSuperTableObj *)pMsg->pTable; if (pStable->numOfTables != 0) { SHashMutableIterator *pIter = taosHashCreateIter(pStable->vgHash); @@ -1239,7 +1239,7 @@ static int32_t mgmtSetSchemaFromSuperTable(SSchema *pSchema, SSuperTableObj *pTa return (pTable->numOfColumns + pTable->numOfTags) * sizeof(SSchema); } -static void mgmtGetSuperTableMeta(SQueuedMsg *pMsg) { +static void mgmtGetSuperTableMeta(SMnodeMsg *pMsg) { SSuperTableObj *pTable = (SSuperTableObj *)pMsg->pTable; STableMetaMsg *pMeta = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16)); pMeta->uid = htobe64(pTable->uid); @@ -1263,7 +1263,7 @@ static void mgmtGetSuperTableMeta(SQueuedMsg *pMsg) { mTrace("stable:%s, uid:%" PRIu64 " table meta is retrieved", pTable->info.tableId, pTable->uid); } -static void mgmtProcessSuperTableVgroupMsg(SQueuedMsg *pMsg) { +static void mgmtProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) { SCMSTableVgroupMsg *pInfo = pMsg->pCont; int32_t numOfTable = htonl(pInfo->numOfTables); @@ -1487,7 +1487,7 @@ static SChildTableObj* mgmtDoCreateChildTable(SCMCreateTableMsg *pCreate, SVgObj return pTable; } -static void mgmtProcessCreateChildTableMsg(SQueuedMsg *pMsg) { +static void mgmtProcessCreateChildTableMsg(SMnodeMsg *pMsg) { SCMCreateTableMsg *pCreate = pMsg->pCont; int32_t code = grantCheck(TSDB_GRANT_TIMESERIES); if (code != TSDB_CODE_SUCCESS) { @@ -1536,7 +1536,7 @@ static void mgmtProcessCreateChildTableMsg(SQueuedMsg *pMsg) { } SRpcIpSet ipSet = mgmtGetIpSetFromVgroup(pVgroup); - SQueuedMsg *newMsg = mgmtCloneQueuedMsg(pMsg); + SMnodeMsg *newMsg = mgmtCloneQueuedMsg(pMsg); newMsg->ahandle = pMsg->pTable; newMsg->maxRetry = 10; SRpcMsg rpcMsg = { @@ -1550,7 +1550,7 @@ static void mgmtProcessCreateChildTableMsg(SQueuedMsg *pMsg) { dnodeSendMsgToDnode(&ipSet, &rpcMsg); } -static void mgmtProcessDropChildTableMsg(SQueuedMsg *pMsg) { +static void mgmtProcessDropChildTableMsg(SMnodeMsg *pMsg) { SChildTableObj *pTable = (SChildTableObj *)pMsg->pTable; if (pMsg->pVgroup == NULL) pMsg->pVgroup = mgmtGetVgroup(pTable->vgId); if (pMsg->pVgroup == NULL) { @@ -1575,7 +1575,7 @@ static void mgmtProcessDropChildTableMsg(SQueuedMsg *pMsg) { SRpcIpSet ipSet = mgmtGetIpSetFromVgroup(pMsg->pVgroup); mPrint("table:%s, send drop ctable msg", pDrop->tableId); - SQueuedMsg *newMsg = mgmtCloneQueuedMsg(pMsg); + SMnodeMsg *newMsg = mgmtCloneQueuedMsg(pMsg); newMsg->ahandle = pMsg->pTable; SRpcMsg rpcMsg = { .handle = newMsg, @@ -1695,7 +1695,7 @@ static int32_t mgmtSetSchemaFromNormalTable(SSchema *pSchema, SChildTableObj *pT return numOfCols * sizeof(SSchema); } -static int32_t mgmtDoGetChildTableMeta(SQueuedMsg *pMsg, STableMetaMsg *pMeta) { +static int32_t mgmtDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) { SDbObj *pDb = pMsg->pDb; SChildTableObj *pTable = (SChildTableObj *)pMsg->pTable; @@ -1740,7 +1740,7 @@ static int32_t mgmtDoGetChildTableMeta(SQueuedMsg *pMsg, STableMetaMsg *pMeta) { return TSDB_CODE_SUCCESS; } -static void mgmtAutoCreateChildTable(SQueuedMsg *pMsg) { +static void mgmtAutoCreateChildTable(SMnodeMsg *pMsg) { SCMTableInfoMsg *pInfo = pMsg->pCont; STagData* pTag = (STagData*)pInfo->tags; @@ -1760,7 +1760,7 @@ static void mgmtAutoCreateChildTable(SQueuedMsg *pMsg) { memcpy(pCreateMsg->schema, pInfo->tags, contLen - sizeof(SCMCreateTableMsg)); - SQueuedMsg *newMsg = mgmtCloneQueuedMsg(pMsg); + SMnodeMsg *newMsg = mgmtCloneQueuedMsg(pMsg); newMsg->msgType = TSDB_MSG_TYPE_CM_CREATE_TABLE; newMsg->pCont = pCreateMsg; @@ -1768,7 +1768,7 @@ static void mgmtAutoCreateChildTable(SQueuedMsg *pMsg) { mgmtAddToShellQueue(newMsg); } -static void mgmtGetChildTableMeta(SQueuedMsg *pMsg) { +static void mgmtGetChildTableMeta(SMnodeMsg *pMsg) { STableMetaMsg *pMeta = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16)); if (pMeta == NULL) { mError("table:%s, failed to get table meta, no enough memory", pMsg->pTable->tableId); @@ -1926,7 +1926,7 @@ static void mgmtProcessTableCfgMsg(SRpcMsg *rpcMsg) { static void mgmtProcessDropChildTableRsp(SRpcMsg *rpcMsg) { if (rpcMsg->handle == NULL) return; - SQueuedMsg *queueMsg = rpcMsg->handle; + SMnodeMsg *queueMsg = rpcMsg->handle; queueMsg->received++; SChildTableObj *pTable = queueMsg->ahandle; @@ -1974,7 +1974,7 @@ static void mgmtProcessDropChildTableRsp(SRpcMsg *rpcMsg) { static void mgmtProcessCreateChildTableRsp(SRpcMsg *rpcMsg) { if (rpcMsg->handle == NULL) return; - SQueuedMsg *queueMsg = rpcMsg->handle; + SMnodeMsg *queueMsg = rpcMsg->handle; queueMsg->received++; SChildTableObj *pTable = queueMsg->ahandle; @@ -2020,7 +2020,7 @@ static void mgmtProcessAlterTableRsp(SRpcMsg *rpcMsg) { mTrace("alter table rsp received, handle:%p code:%s", rpcMsg->handle, tstrerror(rpcMsg->code)); } -static void mgmtProcessMultiTableMetaMsg(SQueuedMsg *pMsg) { +static void mgmtProcessMultiTableMetaMsg(SMnodeMsg *pMsg) { SCMMultiTableInfoMsg *pInfo = pMsg->pCont; pInfo->numOfTables = htonl(pInfo->numOfTables); @@ -2207,7 +2207,7 @@ static int32_t mgmtRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, return numOfRows; } -static void mgmtProcessAlterTableMsg(SQueuedMsg *pMsg) { +static void mgmtProcessAlterTableMsg(SMnodeMsg *pMsg) { SCMAlterTableMsg *pAlter = pMsg->pCont; mTrace("table:%s, alter table msg is received from thandle:%p", pAlter->tableId, pMsg->thandle); diff --git a/src/mnode/src/mgmtUser.c b/src/mnode/src/mnodeUser.c similarity index 96% rename from src/mnode/src/mgmtUser.c rename to src/mnode/src/mnodeUser.c index 62a98c4170..e346d804c2 100644 --- a/src/mnode/src/mgmtUser.c +++ b/src/mnode/src/mnodeUser.c @@ -34,9 +34,9 @@ static void * tsUserSdb = NULL; static int32_t tsUserUpdateSize = 0; static int32_t mgmtGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); static int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static void mgmtProcessCreateUserMsg(SQueuedMsg *pMsg); -static void mgmtProcessAlterUserMsg(SQueuedMsg *pMsg); -static void mgmtProcessDropUserMsg(SQueuedMsg *pMsg); +static void mgmtProcessCreateUserMsg(SMnodeMsg *pMsg); +static void mgmtProcessAlterUserMsg(SMnodeMsg *pMsg); +static void mgmtProcessDropUserMsg(SMnodeMsg *pMsg); static void mgmtProcessAuthMsg(SRpcMsg *rpcMsg); static int32_t mgmtUserActionDestroy(SSdbOper *pOper) { @@ -139,8 +139,8 @@ int32_t mgmtInitUsers() { mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_USER, mgmtProcessCreateUserMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_ALTER_USER, mgmtProcessAlterUserMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_DROP_USER, mgmtProcessDropUserMsg); - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_USER, mgmtGetUserMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_USER, mgmtRetrieveUsers); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_USER, mgmtGetUserMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_USER, mgmtRetrieveUsers); dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_AUTH, mgmtProcessAuthMsg); mTrace("table:%s, hash is created", tableDesc.tableName); @@ -344,7 +344,7 @@ SUserObj *mgmtGetUserFromConn(void *pConn) { } } -static void mgmtProcessCreateUserMsg(SQueuedMsg *pMsg) { +static void mgmtProcessCreateUserMsg(SMnodeMsg *pMsg) { int32_t code; SUserObj *pOperUser = pMsg->pUser; @@ -362,7 +362,7 @@ static void mgmtProcessCreateUserMsg(SQueuedMsg *pMsg) { mgmtSendSimpleResp(pMsg->thandle, code); } -static void mgmtProcessAlterUserMsg(SQueuedMsg *pMsg) { +static void mgmtProcessAlterUserMsg(SMnodeMsg *pMsg) { int32_t code; SUserObj *pOperUser = pMsg->pUser; @@ -457,7 +457,7 @@ static void mgmtProcessAlterUserMsg(SQueuedMsg *pMsg) { mgmtDecUserRef(pUser); } -static void mgmtProcessDropUserMsg(SQueuedMsg *pMsg) { +static void mgmtProcessDropUserMsg(SMnodeMsg *pMsg) { int32_t code; SUserObj *pOperUser = pMsg->pUser; diff --git a/src/mnode/src/mgmtVgroup.c b/src/mnode/src/mnodeVgroup.c similarity index 98% rename from src/mnode/src/mgmtVgroup.c rename to src/mnode/src/mnodeVgroup.c index 960863d665..ffc5487a42 100644 --- a/src/mnode/src/mgmtVgroup.c +++ b/src/mnode/src/mnodeVgroup.c @@ -220,8 +220,8 @@ int32_t mgmtInitVgroups() { return -1; } - mgmtAddShellShowMetaHandle(TSDB_MGMT_TABLE_VGROUP, mgmtGetVgroupMeta); - mgmtAddShellShowRetrieveHandle(TSDB_MGMT_TABLE_VGROUP, mgmtRetrieveVgroups); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VGROUP, mgmtGetVgroupMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VGROUP, mgmtRetrieveVgroups); dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP, mgmtProcessCreateVnodeRsp); dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_DROP_VNODE_RSP, mgmtProcessDropVnodeRsp); dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_VNODE, mgmtProcessVnodeCfgMsg); @@ -297,7 +297,7 @@ void *mgmtGetNextVgroup(void *pIter, SVgObj **pVgroup) { return sdbFetchRow(tsVgroupSdb, pIter, (void **)pVgroup); } -void mgmtCreateVgroup(SQueuedMsg *pMsg, SDbObj *pDb) { +void mgmtCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { SVgObj *pVgroup = (SVgObj *)calloc(1, sizeof(SVgObj)); strcpy(pVgroup->dbName, pDb->name); pVgroup->numOfVnodes = pDb->cfg.replications; @@ -617,7 +617,7 @@ void mgmtSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle) { static void mgmtProcessCreateVnodeRsp(SRpcMsg *rpcMsg) { if (rpcMsg->handle == NULL) return; - SQueuedMsg *queueMsg = rpcMsg->handle; + SMnodeMsg *queueMsg = rpcMsg->handle; queueMsg->received++; if (rpcMsg->code == TSDB_CODE_SUCCESS) { queueMsg->code = rpcMsg->code; @@ -632,7 +632,7 @@ static void mgmtProcessCreateVnodeRsp(SRpcMsg *rpcMsg) { if (queueMsg->received != queueMsg->expected) return; if (queueMsg->received == queueMsg->successed) { - SQueuedMsg *newMsg = mgmtCloneQueuedMsg(queueMsg); + SMnodeMsg *newMsg = mgmtCloneQueuedMsg(queueMsg); mgmtAddToShellQueue(newMsg); } else { SSdbOper oper = { @@ -684,7 +684,7 @@ static void mgmtProcessDropVnodeRsp(SRpcMsg *rpcMsg) { mTrace("drop vnode rsp is received, handle:%p", rpcMsg->handle); if (rpcMsg->handle == NULL) return; - SQueuedMsg *queueMsg = rpcMsg->handle; + SMnodeMsg *queueMsg = rpcMsg->handle; queueMsg->received++; if (rpcMsg->code == TSDB_CODE_SUCCESS) { queueMsg->code = rpcMsg->code; @@ -708,7 +708,7 @@ static void mgmtProcessDropVnodeRsp(SRpcMsg *rpcMsg) { code = TSDB_CODE_SDB_ERROR; } - SQueuedMsg *newMsg = mgmtCloneQueuedMsg(queueMsg); + SMnodeMsg *newMsg = mgmtCloneQueuedMsg(queueMsg); mgmtAddToShellQueue(newMsg); queueMsg->pCont = NULL; diff --git a/src/mnode/src/mnodeWrite.c b/src/mnode/src/mnodeWrite.c new file mode 100644 index 0000000000..0fb4cf3d49 --- /dev/null +++ b/src/mnode/src/mnodeWrite.c @@ -0,0 +1,96 @@ +/* + * 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 "tbalance.h" +#include "tgrant.h" +#include "ttimer.h" +#include "tglobal.h" +#include "dnode.h" +#include "mgmtDef.h" +#include "mgmtInt.h" +#include "mgmtServer.h" +#include "mgmtAcct.h" +#include "mgmtDnode.h" +#include "mgmtMnode.h" +#include "mgmtDb.h" +#include "mgmtSdb.h" +#include "mgmtVgroup.h" +#include "mgmtUser.h" +#include "mgmtTable.h" +#include "mgmtShell.h" + +static void (*tsMnodeProcessWriteMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *); + +void mnodeAddWriteMsgHandle(uint8_t msgType, void (*fp)(SMnodeMsg *pMsg)) { + tsMnodeProcessWriteMsgFp[msgType] = fp; +} + +int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { + SRpcMsg *rpcMsg = &pMsg->rpcMsg; + if (rpcMsg->pCont == NULL) { + mError("%p, msg:%s content is null", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + return TSDB_CODE_INVALID_MSG_LEN; + } + + if (!sdbIsMaster()) { + SMnodeRsp *rpcRsp = &pMsg->rpcRsp; + SRpcIpSet *ipSet = rpcMallocCont(sizeof(SRpcIpSet)); + mgmtGetMnodeIpSetForShell(ipSet); + rpcRsp->rsp = ipSet; + rpcRsp->len = sizeof(SRpcIpSet); + + mTrace("%p, msg:%s will be redireced, inUse:%d", rpcMsg->ahandle, taosMsg[rpcMsg->msgType], ipSet->inUse); + for (int32_t i = 0; i < ipSet->numOfIps; ++i) { + mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); + } + + return TSDB_CODE_REDIRECT; + } + + if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) { + mError("%p, msg:%s not processed, grant time expired", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + return TSDB_CODE_GRANT_EXPIRED; + } + + if (tsMnodeProcessReadMsgFp[rpcMsg->msgType] == NULL) { + mError("%p, msg:%s not processed, no handle exist", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + return TSDB_CODE_MSG_NOT_PROCESSED; + } + + if (!mnodeInitMsg(pMsg)) { + mError("%p, msg:%s not processed, reason:%s", rpcMsg->ahandle, taosMsg[rpcMsg->msgType], tstrerror(terrno)); + return terrno; + } + + if (!pMsg->pUser->writeAuth) { + mError("%p, msg:%s not processed, no rights", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + return TSDB_CODE_NO_RIGHTS; + } + + return (*tsMnodeProcessWriteMsgFp[rpcMsg->msgType])(pMsg); +} + +static void mgmtDoDealyedAddToShellQueue(void *param, void *tmrId) { + mgmtAddToShellQueue(param); +} + +void mgmtDealyedAddToShellQueue(SMnodeMsg *queuedMsg) { + void *unUsed = NULL; + taosTmrReset(mgmtDoDealyedAddToShellQueue, 300, queuedMsg, tsMgmtTmr, &unUsed); +} \ No newline at end of file From 7ac821f218a56a4cd61df9d1c924d1674aa1a43e Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Tue, 26 May 2020 12:20:58 +0000 Subject: [PATCH 03/17] [TD-335] rename some defs --- src/client/src/tscSQLParser.c | 4 +- src/client/src/tscServer.c | 2 +- src/inc/taosmsg.h | 34 +++++----- src/mnode/inc/mnodeDb.h | 2 +- src/mnode/inc/mnodeProfile.h | 2 +- src/mnode/inc/mnodeShell.h | 2 +- src/mnode/inc/mnodeTable.h | 2 +- src/mnode/inc/mnodeUser.h | 2 +- src/mnode/inc/mnodeVgroup.h | 2 +- src/mnode/src/mnodeAcct.c | 12 ++-- src/mnode/src/mnodeBalance.c | 12 ++-- src/mnode/src/mnodeDb.c | 28 ++++---- src/mnode/src/mnodeDnode.c | 32 ++++----- src/mnode/src/mnodeGrant.c | 2 +- src/mnode/src/mnodeMain.c | 24 +++---- src/mnode/src/mnodeMgmt.c | 18 ++--- src/mnode/src/mnodeMnode.c | 18 ++--- src/mnode/src/mnodeProfile.c | 34 +++++----- src/mnode/src/mnodeRead.c | 6 +- src/mnode/src/mnodeSdb.c | 10 +-- src/mnode/src/mnodeShow.c | 119 +++++++++++++++------------------- src/mnode/src/mnodeTable.c | 32 ++++----- src/mnode/src/mnodeUser.c | 18 ++--- src/mnode/src/mnodeVgroup.c | 24 +++---- src/mnode/src/mnodeWrite.c | 24 +++---- 25 files changed, 227 insertions(+), 238 deletions(-) diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index d23d0e1860..087f546eaa 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -2175,7 +2175,7 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { */ SShowInfo* pShowInfo = &pInfo->pDCLInfo->showOpt; int16_t showType = pShowInfo->showType; - if (showType == TSDB_MGMT_TABLE_TABLE || showType == TSDB_MGMT_TABLE_METRIC || showType == TSDB_MGMT_TABLE_VGROUP) { + if (showType == TSDB_MNODE_TABLE_TABLE || showType == TSDB_MNODE_TABLE_METRIC || showType == TSDB_MNODE_TABLE_VGROUP) { // db prefix in tagCond, show table conds in payload SSQLToken* pDbPrefixToken = &pShowInfo->prefix; if (pDbPrefixToken->type != 0) { @@ -2212,7 +2212,7 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2); } } - } else if (showType == TSDB_MGMT_TABLE_VNODES) { + } else if (showType == TSDB_MNODE_TABLE_VNODES) { if (pShowInfo->prefix.type == 0) { return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "No specified ip of dnode"); } diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c index 0aac5daa2e..669f777d81 100644 --- a/src/client/src/tscServer.c +++ b/src/client/src/tscServer.c @@ -1116,7 +1116,7 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) { SShowInfo *pShowInfo = &pInfo->pDCLInfo->showOpt; pShowMsg->type = pShowInfo->showType; - if (pShowInfo->showType != TSDB_MGMT_TABLE_VNODES) { + if (pShowInfo->showType != TSDB_MNODE_TABLE_VNODES) { SSQLToken *pPattern = &pShowInfo->pattern; if (pPattern->type > 0) { // only show tables support wildcard query strncpy(pShowMsg->payload, pPattern->z, pPattern->n); diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h index f550b1660f..f493a2b542 100644 --- a/src/inc/taosmsg.h +++ b/src/inc/taosmsg.h @@ -121,23 +121,23 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY14, "dummy14" ) #define TSDB_IE_TYPE_DNODE_STATE 7 enum _mgmt_table { - TSDB_MGMT_TABLE_ACCT, - TSDB_MGMT_TABLE_USER, - TSDB_MGMT_TABLE_DB, - TSDB_MGMT_TABLE_TABLE, - TSDB_MGMT_TABLE_DNODE, - TSDB_MGMT_TABLE_MNODE, - TSDB_MGMT_TABLE_VGROUP, - TSDB_MGMT_TABLE_METRIC, - TSDB_MGMT_TABLE_MODULE, - TSDB_MGMT_TABLE_QUERIES, - TSDB_MGMT_TABLE_STREAMS, - TSDB_MGMT_TABLE_CONFIGS, - TSDB_MGMT_TABLE_CONNS, - TSDB_MGMT_TABLE_SCORES, - TSDB_MGMT_TABLE_GRANTS, - TSDB_MGMT_TABLE_VNODES, - TSDB_MGMT_TABLE_MAX, + TSDB_MNODE_TABLE_ACCT, + TSDB_MNODE_TABLE_USER, + TSDB_MNODE_TABLE_DB, + TSDB_MNODE_TABLE_TABLE, + TSDB_MNODE_TABLE_DNODE, + TSDB_MNODE_TABLE_MNODE, + TSDB_MNODE_TABLE_VGROUP, + TSDB_MNODE_TABLE_METRIC, + TSDB_MNODE_TABLE_MODULE, + TSDB_MNODE_TABLE_QUERIES, + TSDB_MNODE_TABLE_STREAMS, + TSDB_MNODE_TABLE_CONFIGS, + TSDB_MNODE_TABLE_CONNS, + TSDB_MNODE_TABLE_SCORES, + TSDB_MNODE_TABLE_GRANTS, + TSDB_MNODE_TABLE_VNODES, + TSDB_MNODE_TABLE_MAX, }; #define TSDB_ALTER_TABLE_ADD_TAG_COLUMN 1 diff --git a/src/mnode/inc/mnodeDb.h b/src/mnode/inc/mnodeDb.h index 4ad46eee7b..5339a878f1 100644 --- a/src/mnode/inc/mnodeDb.h +++ b/src/mnode/inc/mnodeDb.h @@ -20,7 +20,7 @@ extern "C" { #endif -#include "mgmtDef.h" +#include "mnodeDef.h" enum _TSDB_DB_STATUS { TSDB_DB_STATUS_READY, diff --git a/src/mnode/inc/mnodeProfile.h b/src/mnode/inc/mnodeProfile.h index f33ff9c3fa..cb5234c7e6 100644 --- a/src/mnode/inc/mnodeProfile.h +++ b/src/mnode/inc/mnodeProfile.h @@ -19,7 +19,7 @@ #ifdef __cplusplus extern "C" { #endif -#include "mgmtDef.h" +#include "mnodeDef.h" int32_t mgmtInitProfile(); void mgmtCleanUpProfile(); diff --git a/src/mnode/inc/mnodeShell.h b/src/mnode/inc/mnodeShell.h index 976dc360f3..53fb5827c1 100644 --- a/src/mnode/inc/mnodeShell.h +++ b/src/mnode/inc/mnodeShell.h @@ -19,7 +19,7 @@ #ifdef __cplusplus extern "C" { #endif -#include "mgmtDef.h" +#include "mnodeDef.h" int32_t mgmtInitShell(); void mgmtCleanUpShell(); diff --git a/src/mnode/inc/mnodeTable.h b/src/mnode/inc/mnodeTable.h index 3ef4c6d453..cee2a88ee4 100644 --- a/src/mnode/inc/mnodeTable.h +++ b/src/mnode/inc/mnodeTable.h @@ -20,7 +20,7 @@ extern "C" { #endif -#include "mgmtDef.h" +#include "mnodeDef.h" int32_t mgmtInitTables(); void mgmtCleanUpTables(); diff --git a/src/mnode/inc/mnodeUser.h b/src/mnode/inc/mnodeUser.h index 2edd71f3e7..fc5ad13b8a 100644 --- a/src/mnode/inc/mnodeUser.h +++ b/src/mnode/inc/mnodeUser.h @@ -19,7 +19,7 @@ #ifdef __cplusplus extern "C" { #endif -#include "mgmtDef.h" +#include "mnodeDef.h" int32_t mgmtInitUsers(); void mgmtCleanUpUsers(); diff --git a/src/mnode/inc/mnodeVgroup.h b/src/mnode/inc/mnodeVgroup.h index 948aec06e5..b1359e0734 100644 --- a/src/mnode/inc/mnodeVgroup.h +++ b/src/mnode/inc/mnodeVgroup.h @@ -20,7 +20,7 @@ extern "C" { #endif -#include "mgmtDef.h" +#include "mnodeDef.h" int32_t mgmtInitVgroups(); void mgmtCleanUpVgroups(); diff --git a/src/mnode/src/mnodeAcct.c b/src/mnode/src/mnodeAcct.c index a35591382c..dce771fefd 100644 --- a/src/mnode/src/mnodeAcct.c +++ b/src/mnode/src/mnodeAcct.c @@ -19,12 +19,12 @@ #include "ttime.h" #include "tutil.h" #include "dnode.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtAcct.h" -#include "mgmtDb.h" -#include "mgmtSdb.h" -#include "mgmtUser.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeAcct.h" +#include "mnodeDb.h" +#include "mnodeSdb.h" +#include "mnodeUser.h" void * tsAcctSdb = NULL; static int32_t tsAcctUpdateSize; diff --git a/src/mnode/src/mnodeBalance.c b/src/mnode/src/mnodeBalance.c index f8410a207e..e70458a3fa 100644 --- a/src/mnode/src/mnodeBalance.c +++ b/src/mnode/src/mnodeBalance.c @@ -18,12 +18,12 @@ #include "trpc.h" #include "tbalance.h" #include "tglobal.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtMnode.h" -#include "mgmtDnode.h" -#include "mgmtSdb.h" -#include "mgmtVgroup.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeMnode.h" +#include "mnodeDnode.h" +#include "mnodeSdb.h" +#include "mnodeVgroup.h" #ifndef _SYNC diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c index 09e53d13c9..871ce32c6f 100644 --- a/src/mnode/src/mnodeDb.c +++ b/src/mnode/src/mnodeDb.c @@ -24,18 +24,18 @@ #include "tname.h" #include "tbalance.h" #include "tdataformat.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtAcct.h" -#include "mgmtDb.h" -#include "mgmtDnode.h" -#include "mgmtMnode.h" -#include "mgmtShell.h" -#include "mgmtProfile.h" -#include "mgmtSdb.h" -#include "mgmtTable.h" -#include "mgmtUser.h" -#include "mgmtVgroup.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeAcct.h" +#include "mnodeDb.h" +#include "mnodeDnode.h" +#include "mnodeMnode.h" +#include "mnodeShell.h" +#include "mnodeProfile.h" +#include "mnodeSdb.h" +#include "mnodeTable.h" +#include "mnodeUser.h" +#include "mnodeVgroup.h" static void * tsDbSdb = NULL; static int32_t tsDbUpdateSize; @@ -150,8 +150,8 @@ int32_t mgmtInitDbs() { mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DB, mgmtProcessCreateDbMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_ALTER_DB, mgmtProcessAlterDbMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_DROP_DB, mgmtProcessDropDbMsg); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DB, mgmtGetDbMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DB, mgmtRetrieveDbs); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_DB, mgmtGetDbMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_DB, mgmtRetrieveDbs); mTrace("table:dbs table is created"); return 0; diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c index ce0b1d07e9..5715554935 100644 --- a/src/mnode/src/mnodeDnode.c +++ b/src/mnode/src/mnodeDnode.c @@ -26,14 +26,14 @@ #include "tsync.h" #include "tdataformat.h" #include "dnode.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtDnode.h" -#include "mgmtMnode.h" -#include "mgmtSdb.h" -#include "mgmtShell.h" -#include "mgmtUser.h" -#include "mgmtVgroup.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeDnode.h" +#include "mnodeMnode.h" +#include "mnodeSdb.h" +#include "mnodeShell.h" +#include "mnodeUser.h" +#include "mnodeVgroup.h" int32_t tsAccessSquence = 0; static void *tsDnodeSdb = NULL; @@ -153,14 +153,14 @@ int32_t mgmtInitDnodes() { mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CONFIG_DNODE, mgmtProcessCfgDnodeMsg); dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP, mgmtProcessCfgDnodeMsgRsp); dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_STATUS, mgmtProcessDnodeStatusMsg); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_MODULE, mgmtGetModuleMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_MODULE, mgmtRetrieveModules); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONFIGS, mgmtGetConfigMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONFIGS, mgmtRetrieveConfigs); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VNODES, mgmtGetVnodeMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VNODES, mgmtRetrieveVnodes); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DNODE, mgmtGetDnodeMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DNODE, mgmtRetrieveDnodes); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_MODULE, mgmtGetModuleMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_MODULE, mgmtRetrieveModules); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_CONFIGS, mgmtGetConfigMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_CONFIGS, mgmtRetrieveConfigs); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_VNODES, mgmtGetVnodeMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_VNODES, mgmtRetrieveVnodes); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_DNODE, mgmtGetDnodeMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_DNODE, mgmtRetrieveDnodes); mTrace("table:dnodes table is created"); return 0; diff --git a/src/mnode/src/mnodeGrant.c b/src/mnode/src/mnodeGrant.c index f44b47e20c..7329629ef9 100644 --- a/src/mnode/src/mnodeGrant.c +++ b/src/mnode/src/mnodeGrant.c @@ -18,7 +18,7 @@ #include "os.h" #include "taoserror.h" #include "tgrant.h" -#include "mgmtInt.h" +#include "mnodeInt.h" int32_t grantInit() { return TSDB_CODE_SUCCESS; } void grantCleanUp() {} diff --git a/src/mnode/src/mnodeMain.c b/src/mnode/src/mnodeMain.c index 204a8a638e..563e679b34 100644 --- a/src/mnode/src/mnodeMain.c +++ b/src/mnode/src/mnodeMain.c @@ -22,18 +22,18 @@ #include "ttimer.h" #include "tglobal.h" #include "dnode.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtServer.h" -#include "mgmtAcct.h" -#include "mgmtDnode.h" -#include "mgmtMnode.h" -#include "mgmtDb.h" -#include "mgmtSdb.h" -#include "mgmtVgroup.h" -#include "mgmtUser.h" -#include "mgmtTable.h" -#include "mgmtShell.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeServer.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 "mnodeShell.h" static void *tsMgmtTmr; static bool tsMgmtIsRunning = false; diff --git a/src/mnode/src/mnodeMgmt.c b/src/mnode/src/mnodeMgmt.c index 8833462406..49f4c90fa5 100644 --- a/src/mnode/src/mnodeMgmt.c +++ b/src/mnode/src/mnodeMgmt.c @@ -24,15 +24,15 @@ #include "tbalance.h" #include "tglobal.h" #include "dnode.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtDb.h" -#include "mgmtMnode.h" -#include "mgmtProfile.h" -#include "mgmtShell.h" -#include "mgmtSdb.h" -#include "mgmtTable.h" -#include "mgmtVgroup.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeDb.h" +#include "mnodeMnode.h" +#include "mnodeProfile.h" +#include "mnodeShell.h" +#include "mnodeSdb.h" +#include "mnodeTable.h" +#include "mnodeVgroup.h" static void (*tsMnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *); diff --git a/src/mnode/src/mnodeMnode.c b/src/mnode/src/mnodeMnode.c index aa028f594b..f939dfb426 100644 --- a/src/mnode/src/mnodeMnode.c +++ b/src/mnode/src/mnodeMnode.c @@ -23,13 +23,13 @@ #include "ttime.h" #include "tsocket.h" #include "tdataformat.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtMnode.h" -#include "mgmtDnode.h" -#include "mgmtSdb.h" -#include "mgmtShell.h" -#include "mgmtUser.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeMnode.h" +#include "mnodeDnode.h" +#include "mnodeSdb.h" +#include "mnodeShell.h" +#include "mnodeUser.h" static void * tsMnodeSdb = NULL; static int32_t tsMnodeUpdateSize = 0; @@ -154,8 +154,8 @@ int32_t mgmtInitMnodes() { return -1; } - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_MNODE, mgmtGetMnodeMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_MNODE, mgmtRetrieveMnodes); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_MNODE, mgmtGetMnodeMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_MNODE, mgmtRetrieveMnodes); mTrace("table:mnodes table is created"); return TSDB_CODE_SUCCESS; diff --git a/src/mnode/src/mnodeProfile.c b/src/mnode/src/mnodeProfile.c index 3cf340db4a..3236197c83 100644 --- a/src/mnode/src/mnodeProfile.c +++ b/src/mnode/src/mnodeProfile.c @@ -18,17 +18,17 @@ #include "taosmsg.h" #include "taoserror.h" #include "tutil.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtAcct.h" -#include "mgmtDnode.h" -#include "mgmtDb.h" -#include "mgmtMnode.h" -#include "mgmtProfile.h" -#include "mgmtShell.h" -#include "mgmtTable.h" -#include "mgmtUser.h" -#include "mgmtVgroup.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeAcct.h" +#include "mnodeDnode.h" +#include "mnodeDb.h" +#include "mnodeMnode.h" +#include "mnodeProfile.h" +#include "mnodeShell.h" +#include "mnodeTable.h" +#include "mnodeUser.h" +#include "mnodeVgroup.h" int32_t mgmtSaveQueryStreamList(SCMHeartBeatMsg *pHBMsg); @@ -745,12 +745,12 @@ void mgmtProcessKillConnectionMsg(SMnodeMsg *pMsg) { } int32_t mgmtInitProfile() { - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mgmtGetQueryMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mgmtRetrieveQueries); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mgmtGetConnsMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mgmtRetrieveConns); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_STREAMS, mgmtGetStreamMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMS, mgmtRetrieveStreams); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_QUERIES, mgmtGetQueryMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_QUERIES, mgmtRetrieveQueries); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_CONNS, mgmtGetConnsMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_CONNS, mgmtRetrieveConns); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_STREAMS, mgmtGetStreamMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_STREAMS, mgmtRetrieveStreams); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mgmtProcessKillQueryMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mgmtProcessKillStreamMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_CONN, mgmtProcessKillConnectionMsg); diff --git a/src/mnode/src/mnodeRead.c b/src/mnode/src/mnodeRead.c index 8d06113f8a..c8983bf1e7 100644 --- a/src/mnode/src/mnodeRead.c +++ b/src/mnode/src/mnodeRead.c @@ -23,13 +23,13 @@ #include "tglobal.h" #include "mnode.h" #include "dnode.h" -#include "mgmtDef.h" +#include "mnodeDef.h" #include "mgmtInt.h" #include "mgmtServer.h" -#include "mgmtAcct.h" +#include "mnodeAcct.h" #include "mgmtDnode.h" #include "mgmtMnode.h" -#include "mgmtDb.h" +#include "mnodeDb.h" #include "mgmtSdb.h" #include "mgmtVgroup.h" #include "mgmtUser.h" diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c index 237d2ca499..e873c0b573 100644 --- a/src/mnode/src/mnodeSdb.c +++ b/src/mnode/src/mnodeSdb.c @@ -25,11 +25,11 @@ #include "tsync.h" #include "tglobal.h" #include "dnode.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtMnode.h" -#include "mgmtDnode.h" -#include "mgmtSdb.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeMnode.h" +#include "mnodeDnode.h" +#include "mnodeSdb.h" typedef enum { SDB_ACTION_INSERT, diff --git a/src/mnode/src/mnodeShow.c b/src/mnode/src/mnodeShow.c index 8138fafc06..a629d02fdd 100644 --- a/src/mnode/src/mnodeShow.c +++ b/src/mnode/src/mnodeShow.c @@ -25,41 +25,41 @@ #include "tglobal.h" #include "tcache.h" #include "dnode.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtAcct.h" -#include "mgmtDb.h" -#include "mgmtDnode.h" -#include "mgmtMnode.h" -#include "mgmtProfile.h" -#include "mgmtSdb.h" -#include "mgmtShell.h" -#include "mgmtTable.h" -#include "mgmtUser.h" -#include "mgmtVgroup.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 "mnodeShell.h" +#include "mnodeTable.h" +#include "mnodeUser.h" +#include "mnodeVgroup.h" typedef int32_t (*SShowMetaFp)(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); typedef int32_t (*SShowRetrieveFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static void mgmtProcessShowMsg(SMnodeMsg *queuedMsg); -static void mgmtProcessRetrieveMsg(SMnodeMsg *queuedMsg); -static void mgmtProcessHeartBeatMsg(SMnodeMsg *queuedMsg); -static void mgmtProcessConnectMsg(SMnodeMsg *queuedMsg); -static void mgmtProcessUseMsg(SMnodeMsg *queuedMsg); -static void mgmtFreeShowObj(void *data); +static void mnodeProcessShowMsg(SMnodeMsg *queuedMsg); +static void mnodeProcessRetrieveMsg(SMnodeMsg *queuedMsg); +static void mnodeProcessHeartBeatMsg(SMnodeMsg *queuedMsg); +static void mnodeProcessConnectMsg(SMnodeMsg *queuedMsg); +static void mnodeProcessUseMsg(SMnodeMsg *queuedMsg); +static void mnodeFreeShowObj(void *data); static void *tsQhandleCache = NULL; -static SShowMetaFp tsMnodeShowMetaFp[TSDB_MGMT_TABLE_MAX] = {0}; -static SShowRetrieveFp tsMnodeShowRetrieveFp[TSDB_MGMT_TABLE_MAX] = {0}; +static SShowMetaFp tsMnodeShowMetaFp[TSDB_MNODE_TABLE_MAX] = {0}; +static SShowRetrieveFp tsMnodeShowRetrieveFp[TSDB_MNODE_TABLE_MAX] = {0}; void mnodeInitShow() { - mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_SHOW, mgmtProcessShowMsg); - mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_RETRIEVE, mgmtProcessRetrieveMsg); - mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_HEARTBEAT, mgmtProcessHeartBeatMsg); - mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_CONNECT, mgmtProcessConnectMsg); - mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_USE_DB, mgmtProcessUseMsg); + 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); - tsQhandleCache = taosCacheInitWithCb(tsMgmtTmr, 10, mgmtFreeShowObj); + tsQhandleCache = taosCacheInitWithCb(tsMgmtTmr, 10, mnodeFreeShowObj); } void mnodeCleanUpShow() { @@ -77,48 +77,37 @@ void mnodeAddShowRetrieveHandle(uint8_t msgType, SShowRetrieveFp fp) { tsMnodeShowRetrieveFp[msgType] = fp; } -int32_t mnodeProcessRead(int msgType, void *pCont, int32_t contLen, SRspRet *ret) { - if (vnodeProcessReadMsgFp[msgType] == NULL) - return TSDB_CODE_MSG_NOT_PROCESSED; - - if (pVnode->status == TAOS_VN_STATUS_DELETING || pVnode->status == TAOS_VN_STATUS_CLOSING) - return TSDB_CODE_NOT_ACTIVE_VNODE; - - return (*vnodeProcessReadMsgFp[msgType])(pVnode, pCont, contLen, ret); -} - - -char *mgmtGetShowTypeStr(int32_t showType) { +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_CONFIGS: 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_MNODE_TABLE_ACCT: return "show accounts"; + case TSDB_MNODE_TABLE_USER: return "show users"; + case TSDB_MNODE_TABLE_DB: return "show databases"; + case TSDB_MNODE_TABLE_TABLE: return "show tables"; + case TSDB_MNODE_TABLE_DNODE: return "show dnodes"; + case TSDB_MNODE_TABLE_MNODE: return "show mnodes"; + case TSDB_MNODE_TABLE_VGROUP: return "show vgroups"; + case TSDB_MNODE_TABLE_METRIC: return "show stables"; + case TSDB_MNODE_TABLE_MODULE: return "show modules"; + case TSDB_MNODE_TABLE_QUERIES: return "show queries"; + case TSDB_MNODE_TABLE_STREAMS: return "show streams"; + case TSDB_MNODE_TABLE_CONFIGS: return "show configs"; + case TSDB_MNODE_TABLE_CONNS: return "show connections"; + case TSDB_MNODE_TABLE_SCORES: return "show scores"; + case TSDB_MNODE_TABLE_GRANTS: return "show grants"; + case TSDB_MNODE_TABLE_VNODES: return "show vnodes"; default: return "undefined"; } } -static void mgmtProcessShowMsg(SMnodeMsg *pMsg) { +static void mnodeProcessShowMsg(SMnodeMsg *pMsg) { SCMShowMsg *pShowMsg = pMsg->pCont; - if (pShowMsg->type >= TSDB_MGMT_TABLE_MAX) { + if (pShowMsg->type >= TSDB_MNODE_TABLE_MAX) { mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_MSG_TYPE); return; } if (!tsMnodeShowMetaFp[pShowMsg->type] || !tsMnodeShowRetrieveFp[pShowMsg->type]) { - mError("show type:%s is not support", mgmtGetShowTypeStr(pShowMsg->type)); + mError("show type:%s is not support", mnodeGetShowType(pShowMsg->type)); mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_OPS_NOT_SUPPORT); return; } @@ -141,7 +130,7 @@ static void mgmtProcessShowMsg(SMnodeMsg *pMsg) { pShow = mgmtSaveQhandle(pShow, showObjSize); pShowRsp->qhandle = htobe64((uint64_t) pShow); - mTrace("show:%p, type:%s, start to get meta", pShow, mgmtGetShowTypeStr(pShowMsg->type)); + mTrace("show:%p, type:%s, start to get meta", pShow, mnodeGetShowType(pShowMsg->type)); int32_t code = (*tsMnodeShowMetaFp[pShowMsg->type])(&pShowRsp->tableMeta, pShow, pMsg->thandle); if (code == 0) { SRpcMsg rpcRsp = { @@ -152,7 +141,7 @@ static void mgmtProcessShowMsg(SMnodeMsg *pMsg) { }; rpcSendResponse(&rpcRsp); } else { - mError("show:%p, type:%s, failed to get meta, reason:%s", pShow, mgmtGetShowTypeStr(pShowMsg->type), tstrerror(code)); + mError("show:%p, type:%s, failed to get meta, reason:%s", pShow, mnodeGetShowType(pShowMsg->type), tstrerror(code)); mgmtFreeQhandle(pShow, false); SRpcMsg rpcRsp = { .handle = pMsg->thandle, @@ -162,7 +151,7 @@ static void mgmtProcessShowMsg(SMnodeMsg *pMsg) { } } -static void mgmtProcessRetrieveMsg(SMnodeMsg *pMsg) { +static void mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { int32_t rowsToRead = 0; int32_t size = 0; int32_t rowsRead = 0; @@ -180,7 +169,7 @@ static void mgmtProcessRetrieveMsg(SMnodeMsg *pMsg) { } SShowObj *pShow = (SShowObj *)pRetrieve->qhandle; - mTrace("show:%p, type:%s, retrieve data", pShow, mgmtGetShowTypeStr(pShow->type)); + mTrace("show:%p, type:%s, retrieve data", pShow, mnodeGetShowType(pShow->type)); if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) { rowsToRead = pShow->numOfRows - pShow->numOfReads; @@ -228,7 +217,7 @@ static void mgmtProcessRetrieveMsg(SMnodeMsg *pMsg) { } } -static void mgmtProcessHeartBeatMsg(SMnodeMsg *pMsg) { +static void mnodeProcessHeartBeatMsg(SMnodeMsg *pMsg) { SCMHeartBeatRsp *pHBRsp = (SCMHeartBeatRsp *) rpcMallocCont(sizeof(SCMHeartBeatRsp)); if (pHBRsp == NULL) { mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY); @@ -257,7 +246,7 @@ static void mgmtProcessHeartBeatMsg(SMnodeMsg *pMsg) { rpcSendResponse(&rpcRsp); } -static void mgmtProcessConnectMsg(SMnodeMsg *pMsg) { +static void mnodeProcessConnectMsg(SMnodeMsg *pMsg) { SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; SCMConnectMsg *pConnectMsg = pMsg->pCont; @@ -317,7 +306,7 @@ connect_over: rpcSendResponse(&rpcRsp); } -static void mgmtProcessUseMsg(SMnodeMsg *pMsg) { +static void mnodeProcessUseMsg(SMnodeMsg *pMsg) { SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; SCMUseDbMsg *pUseDbMsg = pMsg->pCont; @@ -413,7 +402,7 @@ void* mgmtSaveQhandle(void *qhandle, int32_t size) { return NULL; } -static void mgmtFreeShowObj(void *data) { +static void mnodeFreeShowObj(void *data) { SShowObj *pShow = data; sdbFreeIter(pShow->pIter); mTrace("show:%p, is destroyed", pShow); diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c index 609be0f542..51161372fb 100644 --- a/src/mnode/src/mnodeTable.c +++ b/src/mnode/src/mnodeTable.c @@ -26,19 +26,19 @@ #include "tglobal.h" #include "hash.h" #include "dnode.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtAcct.h" -#include "mgmtDb.h" -#include "mgmtDnode.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeAcct.h" +#include "mnodeDb.h" +#include "mnodeDnode.h" #include "tgrant.h" -#include "mgmtMnode.h" -#include "mgmtProfile.h" -#include "mgmtSdb.h" -#include "mgmtShell.h" -#include "mgmtTable.h" -#include "mgmtUser.h" -#include "mgmtVgroup.h" +#include "mnodeMnode.h" +#include "mnodeProfile.h" +#include "mnodeSdb.h" +#include "mnodeShell.h" +#include "mnodeTable.h" +#include "mnodeUser.h" +#include "mnodeVgroup.h" #include "tcompare.h" #include "tdataformat.h" @@ -559,10 +559,10 @@ int32_t mgmtInitTables() { dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_TABLE, mgmtProcessTableCfgMsg); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_TABLE, mgmtGetShowTableMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_TABLE, mgmtRetrieveShowTables); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_METRIC, mgmtGetShowSuperTableMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_METRIC, mgmtRetrieveShowSuperTables); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_TABLE, mgmtGetShowTableMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_TABLE, mgmtRetrieveShowTables); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_METRIC, mgmtGetShowSuperTableMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_METRIC, mgmtRetrieveShowSuperTables); return TSDB_CODE_SUCCESS; } diff --git a/src/mnode/src/mnodeUser.c b/src/mnode/src/mnodeUser.c index e346d804c2..2a686d05ee 100644 --- a/src/mnode/src/mnodeUser.c +++ b/src/mnode/src/mnodeUser.c @@ -22,13 +22,13 @@ #include "tgrant.h" #include "tdataformat.h" #include "dnode.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtAcct.h" -#include "mgmtMnode.h" -#include "mgmtSdb.h" -#include "mgmtShell.h" -#include "mgmtUser.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeAcct.h" +#include "mnodeMnode.h" +#include "mnodeSdb.h" +#include "mnodeShell.h" +#include "mnodeUser.h" static void * tsUserSdb = NULL; static int32_t tsUserUpdateSize = 0; @@ -139,8 +139,8 @@ int32_t mgmtInitUsers() { mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_USER, mgmtProcessCreateUserMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_ALTER_USER, mgmtProcessAlterUserMsg); mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_DROP_USER, mgmtProcessDropUserMsg); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_USER, mgmtGetUserMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_USER, mgmtRetrieveUsers); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_USER, mgmtGetUserMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_USER, mgmtRetrieveUsers); dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_AUTH, mgmtProcessAuthMsg); mTrace("table:%s, hash is created", tableDesc.tableName); diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c index ffc5487a42..74753142aa 100644 --- a/src/mnode/src/mnodeVgroup.c +++ b/src/mnode/src/mnodeVgroup.c @@ -25,16 +25,16 @@ #include "tglobal.h" #include "dnode.h" #include "tdataformat.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtDb.h" -#include "mgmtDnode.h" -#include "mgmtMnode.h" -#include "mgmtProfile.h" -#include "mgmtSdb.h" -#include "mgmtShell.h" -#include "mgmtTable.h" -#include "mgmtVgroup.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeDb.h" +#include "mnodeDnode.h" +#include "mnodeMnode.h" +#include "mnodeProfile.h" +#include "mnodeSdb.h" +#include "mnodeShell.h" +#include "mnodeTable.h" +#include "mnodeVgroup.h" static void *tsVgroupSdb = NULL; static int32_t tsVgUpdateSize = 0; @@ -220,8 +220,8 @@ int32_t mgmtInitVgroups() { return -1; } - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VGROUP, mgmtGetVgroupMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VGROUP, mgmtRetrieveVgroups); + mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_VGROUP, mgmtGetVgroupMeta); + mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_VGROUP, mgmtRetrieveVgroups); dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP, mgmtProcessCreateVnodeRsp); dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_DROP_VNODE_RSP, mgmtProcessDropVnodeRsp); dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_VNODE, mgmtProcessVnodeCfgMsg); diff --git a/src/mnode/src/mnodeWrite.c b/src/mnode/src/mnodeWrite.c index 0fb4cf3d49..69a4a53077 100644 --- a/src/mnode/src/mnodeWrite.c +++ b/src/mnode/src/mnodeWrite.c @@ -22,18 +22,18 @@ #include "ttimer.h" #include "tglobal.h" #include "dnode.h" -#include "mgmtDef.h" -#include "mgmtInt.h" -#include "mgmtServer.h" -#include "mgmtAcct.h" -#include "mgmtDnode.h" -#include "mgmtMnode.h" -#include "mgmtDb.h" -#include "mgmtSdb.h" -#include "mgmtVgroup.h" -#include "mgmtUser.h" -#include "mgmtTable.h" -#include "mgmtShell.h" +#include "mnodeDef.h" +#include "mnodeInt.h" +#include "mnodeServer.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 "mnodeShell.h" static void (*tsMnodeProcessWriteMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *); From cf6872796b965202907d083794424645ed72a844 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Wed, 27 May 2020 10:10:16 +0000 Subject: [PATCH 04/17] [TD-335] first compiler vresion --- src/client/src/tscSQLParser.c | 4 +- src/client/src/tscServer.c | 2 +- src/common/inc/tglobal.h | 2 +- src/common/src/tglobal.c | 4 +- src/dnode/CMakeLists.txt | 2 +- src/dnode/inc/{dnodeMpeer.h => dnodeMPeer.h} | 6 +- src/dnode/inc/dnodeMgmt.h | 4 +- src/dnode/src/dnodeMPeer.c | 155 ++++ src/dnode/src/dnodeMRead.c | 18 +- src/dnode/src/dnodeMWrite.c | 54 +- src/dnode/src/dnodeMain.c | 8 +- src/dnode/src/dnodeMgmt.c | 158 ++-- src/dnode/src/dnodeModule.c | 6 +- src/dnode/src/dnodeMpeer.c | 155 ---- src/dnode/src/dnodePeer.c | 13 +- src/dnode/src/dnodeShell.c | 4 +- src/dnode/src/dnodeVRead.c | 8 +- src/dnode/src/dnodeVWrite.c | 2 +- src/inc/dnode.h | 23 +- src/inc/mnode.h | 56 +- src/inc/taosmsg.h | 34 +- src/inc/tbalance.h | 2 +- src/inc/trpc.h | 8 +- src/mnode/inc/mnodeAcct.h | 24 +- src/mnode/inc/mnodeDb.h | 40 +- src/mnode/inc/mnodeDef.h | 26 +- src/mnode/inc/mnodeDnode.h | 26 +- src/mnode/inc/mnodeInt.h | 4 +- src/mnode/inc/mnodeMnode.h | 32 +- src/mnode/inc/mnodePeer.h | 32 + src/mnode/inc/mnodeProfile.h | 8 +- src/mnode/inc/{mnodeServer.h => mnodeRead.h} | 9 +- src/mnode/inc/{mnodeShell.h => mnodeShow.h} | 21 +- src/mnode/inc/mnodeTable.h | 20 +- src/mnode/inc/mnodeUser.h | 22 +- src/mnode/inc/mnodeVgroup.h | 50 +- .../inc/{mnodeDClient.h => mnodeWrite.h} | 11 +- src/mnode/src/mnodeAcct.c | 71 +- src/mnode/src/mnodeBalance.c | 12 +- src/mnode/src/mnodeDb.c | 249 +++--- src/mnode/src/mnodeDnode.c | 350 ++++---- src/mnode/src/mnodeInt.c | 63 ++ src/mnode/src/mnodeMain.c | 81 +- src/mnode/src/mnodeMnode.c | 207 ++--- src/mnode/src/{mnodeMgmt.c => mnodePeer.c} | 41 +- src/mnode/src/mnodeProfile.c | 175 ++-- src/mnode/src/mnodeRead.c | 43 +- src/mnode/src/mnodeSdb.c | 20 +- src/mnode/src/mnodeShow.c | 311 ++----- src/mnode/src/mnodeTable.c | 823 +++++++++--------- src/mnode/src/mnodeUser.c | 195 ++--- src/mnode/src/mnodeVgroup.c | 289 +++--- src/mnode/src/mnodeWrite.c | 42 +- 53 files changed, 1972 insertions(+), 2053 deletions(-) rename src/dnode/inc/{dnodeMpeer.h => dnodeMPeer.h} (86%) create mode 100644 src/dnode/src/dnodeMPeer.c delete mode 100644 src/dnode/src/dnodeMpeer.c create mode 100644 src/mnode/inc/mnodePeer.h rename src/mnode/inc/{mnodeServer.h => mnodeRead.h} (77%) rename src/mnode/inc/{mnodeShell.h => mnodeShow.h} (62%) rename src/mnode/inc/{mnodeDClient.h => mnodeWrite.h} (72%) create mode 100644 src/mnode/src/mnodeInt.c rename src/mnode/src/{mnodeMgmt.c => mnodePeer.c} (56%) diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index 087f546eaa..d23d0e1860 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -2175,7 +2175,7 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { */ SShowInfo* pShowInfo = &pInfo->pDCLInfo->showOpt; int16_t showType = pShowInfo->showType; - if (showType == TSDB_MNODE_TABLE_TABLE || showType == TSDB_MNODE_TABLE_METRIC || showType == TSDB_MNODE_TABLE_VGROUP) { + if (showType == TSDB_MGMT_TABLE_TABLE || showType == TSDB_MGMT_TABLE_METRIC || showType == TSDB_MGMT_TABLE_VGROUP) { // db prefix in tagCond, show table conds in payload SSQLToken* pDbPrefixToken = &pShowInfo->prefix; if (pDbPrefixToken->type != 0) { @@ -2212,7 +2212,7 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2); } } - } else if (showType == TSDB_MNODE_TABLE_VNODES) { + } else if (showType == TSDB_MGMT_TABLE_VNODES) { if (pShowInfo->prefix.type == 0) { return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "No specified ip of dnode"); } diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c index 669f777d81..0aac5daa2e 100644 --- a/src/client/src/tscServer.c +++ b/src/client/src/tscServer.c @@ -1116,7 +1116,7 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) { SShowInfo *pShowInfo = &pInfo->pDCLInfo->showOpt; pShowMsg->type = pShowInfo->showType; - if (pShowInfo->showType != TSDB_MNODE_TABLE_VNODES) { + if (pShowInfo->showType != TSDB_MGMT_TABLE_VNODES) { SSQLToken *pPattern = &pShowInfo->pattern; if (pPattern->type > 0) { // only show tables support wildcard query strncpy(pShowMsg->payload, pPattern->z, pPattern->n); diff --git a/src/common/inc/tglobal.h b/src/common/inc/tglobal.h index 319772b606..3cae25aead 100644 --- a/src/common/inc/tglobal.h +++ b/src/common/inc/tglobal.h @@ -100,7 +100,7 @@ extern int32_t tsMaxMgmtConnections; extern int32_t tsBalanceInterval; extern int32_t tsOfflineThreshold; -extern int32_t tsMgmtEqualVnodeNum; +extern int32_t tsMnodeEqualVnodeNum; extern int32_t tsEnableHttpModule; extern int32_t tsEnableMqttModule; diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c index faf15c4215..81f5e449c8 100644 --- a/src/common/src/tglobal.c +++ b/src/common/src/tglobal.c @@ -117,7 +117,7 @@ int32_t tsMaxVnodeConnections = 10000; int32_t tsBalanceInterval = 300; // seconds int32_t tsOfflineThreshold = 86400*100; // seconds 10days -int32_t tsMgmtEqualVnodeNum = 4; +int32_t tsMnodeEqualVnodeNum = 4; int32_t tsEnableHttpModule = 1; int32_t tsEnableMqttModule = 0; // not finished yet, not started it by default @@ -874,7 +874,7 @@ static void doInitGlobalConfig() { // module configs cfg.option = "mgmtEqualVnodeNum"; - cfg.ptr = &tsMgmtEqualVnodeNum; + cfg.ptr = &tsMnodeEqualVnodeNum; cfg.valType = TAOS_CFG_VTYPE_INT32; cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW; cfg.minValue = 0; diff --git a/src/dnode/CMakeLists.txt b/src/dnode/CMakeLists.txt index 2faea588a9..de6e15e6b9 100644 --- a/src/dnode/CMakeLists.txt +++ b/src/dnode/CMakeLists.txt @@ -16,7 +16,7 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM)) AUX_SOURCE_DIRECTORY(src SRC) ADD_EXECUTABLE(taosd ${SRC}) - TARGET_LINK_LIBRARIES(taosd taos_static monitor http mqtt tsdb twal vnode cJson lz4) + TARGET_LINK_LIBRARIES(taosd mnode taos_static monitor http mqtt tsdb twal vnode cJson lz4) IF (TD_ACCOUNT) TARGET_LINK_LIBRARIES(taosd account) diff --git a/src/dnode/inc/dnodeMpeer.h b/src/dnode/inc/dnodeMPeer.h similarity index 86% rename from src/dnode/inc/dnodeMpeer.h rename to src/dnode/inc/dnodeMPeer.h index 93b31c1749..0015532f15 100644 --- a/src/dnode/inc/dnodeMpeer.h +++ b/src/dnode/inc/dnodeMPeer.h @@ -20,9 +20,9 @@ extern "C" { #endif -int32_t dnodeInitMnodeMgmt(); -void dnodeCleanupMnodeMgmt(); -void dnodeDispatchToMnodeMgmtQueue(SRpcMsg *pMsg); +int32_t dnodeInitMnodePeer(); +void dnodeCleanupMnodePeer(); +void dnodeDispatchToMnodePeerQueue(SRpcMsg *pMsg); #ifdef __cplusplus } diff --git a/src/dnode/inc/dnodeMgmt.h b/src/dnode/inc/dnodeMgmt.h index 949a7c6eee..28844ba0e5 100644 --- a/src/dnode/inc/dnodeMgmt.h +++ b/src/dnode/inc/dnodeMgmt.h @@ -32,7 +32,9 @@ void* dnodeGetVnodeWal(void *pVnode); void* dnodeGetVnodeTsdb(void *pVnode); void dnodeReleaseVnode(void *pVnode); -void dnodeSendRediretMsg(SRpcMsg *pMsg); +void dnodeSendRedirectMsg(int32_t msgType, void *thandle, bool forShell); +void dnodeGetMnodeIpSetForPeer(void *ipSet); +void dnodeGetMnodeIpSetForShell(void *ipSe); #ifdef __cplusplus } diff --git a/src/dnode/src/dnodeMPeer.c b/src/dnode/src/dnodeMPeer.c new file mode 100644 index 0000000000..400215472d --- /dev/null +++ b/src/dnode/src/dnodeMPeer.c @@ -0,0 +1,155 @@ +/* + * 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 "taosmsg.h" +#include "tutil.h" +#include "tqueue.h" +#include "trpc.h" +#include "twal.h" +#include "tglobal.h" +#include "mnode.h" +#include "dnode.h" +#include "dnodeInt.h" +#include "dnodeMgmt.h" +#include "dnodeMWrite.h" + +typedef struct { + pthread_t thread; + int32_t workerId; +} SMPeerWorker; + +typedef struct { + int32_t num; + SMPeerWorker *peerWorker; +} SMPeerWorkerPool; + +static SMPeerWorkerPool tsMPeerPool; +static taos_qset tsMPeerQset; +static taos_queue tsMPeerQueue; + +static void *dnodeProcessMnodePeerQueue(void *param); + +int32_t dnodeInitMnodePeer() { + tsMPeerQset = taosOpenQset(); + + tsMPeerPool.num = 1; + tsMPeerPool.peerWorker = (SMPeerWorker *)calloc(sizeof(SMPeerWorker), tsMPeerPool.num); + + if (tsMPeerPool.peerWorker == NULL) return -1; + for (int32_t i = 0; i < tsMPeerPool.num; ++i) { + SMPeerWorker *pWorker = tsMPeerPool.peerWorker + i; + pWorker->workerId = i; + } + + dPrint("dnode mpeer is opened"); + return 0; +} + +void dnodeCleanupMnodePeer() { + for (int32_t i = 0; i < tsMPeerPool.num; ++i) { + SMPeerWorker *pWorker = tsMPeerPool.peerWorker + i; + if (pWorker->thread) { + taosQsetThreadResume(tsMPeerQset); + } + } + + for (int32_t i = 0; i < tsMPeerPool.num; ++i) { + SMPeerWorker *pWorker = tsMPeerPool.peerWorker + i; + if (pWorker->thread) { + pthread_join(pWorker->thread, NULL); + } + } + + dPrint("dnode mmgmt is closed"); +} + +int32_t dnodeAllocateMnodePqueue() { + tsMPeerQueue = taosOpenQueue(); + if (tsMPeerQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + + taosAddIntoQset(tsMPeerQset, tsMPeerQueue, NULL); + + for (int32_t i = 0; i < tsMPeerPool.num; ++i) { + SMPeerWorker *pWorker = tsMPeerPool.peerWorker + 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, dnodeProcessMnodePeerQueue, pWorker) != 0) { + dError("failed to create thread to process mmgmt queue, reason:%s", strerror(errno)); + } + + pthread_attr_destroy(&thAttr); + dTrace("dnode mmgmt worker:%d is launched, total:%d", pWorker->workerId, tsMPeerPool.num); + } + + dTrace("dnode mmgmt queue:%p is allocated", tsMPeerQueue); + return TSDB_CODE_SUCCESS; +} + +void dnodeFreeMnodePqueue() { + taosCloseQueue(tsMPeerQueue); + tsMPeerQueue = NULL; +} + +void dnodeDispatchToMnodePeerQueue(SRpcMsg *pMsg) { + if (!mnodeIsRunning() || tsMPeerQueue == NULL) { + dnodeSendRedirectMsg(pMsg->msgType, pMsg->handle, false); + return; + } + + SMnodeMsg *pPeer = (SMnodeMsg *)taosAllocateQitem(sizeof(SMnodeMsg)); + mnodeCreateMsg(pPeer, pMsg); + taosWriteQitem(tsMPeerQueue, TAOS_QTYPE_RPC, pPeer); +} + +static void dnodeSendRpcMnodePeerRsp(SMnodeMsg *pPeer, int32_t code) { + if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + + SRpcMsg rpcRsp = { + .handle = pPeer->thandle, + .pCont = pPeer->rpcRsp.rsp, + .contLen = pPeer->rpcRsp.len, + .code = code, + }; + + rpcSendResponse(&rpcRsp); + mnodeCleanupMsg(pPeer); +} + +static void *dnodeProcessMnodePeerQueue(void *param) { + SMnodeMsg *pPeerMsg; + int32_t type; + void * unUsed; + + while (1) { + if (taosReadQitemFromQset(tsMPeerQset, &type, (void **)&pPeerMsg, &unUsed) == 0) { + dTrace("dnodeProcessMnodePeerQueue: got no message from qset, exiting..."); + break; + } + + dTrace("%p, msg:%s will be processed", pPeerMsg->ahandle, taosMsg[pPeerMsg->msgType]); + int32_t code = mnodeProcessPeerReq(pPeerMsg); + dnodeSendRpcMnodePeerRsp(pPeerMsg, code); + taosFreeQitem(pPeerMsg); + } + + return NULL; +} diff --git a/src/dnode/src/dnodeMRead.c b/src/dnode/src/dnodeMRead.c index cd785a804e..64375a3d7b 100644 --- a/src/dnode/src/dnodeMRead.c +++ b/src/dnode/src/dnodeMRead.c @@ -25,7 +25,7 @@ #include "mnode.h" #include "dnode.h" #include "dnodeInt.h" -#include "dnodeVMgmt.h" +#include "dnodeMgmt.h" #include "dnodeMRead.h" typedef struct { @@ -116,12 +116,12 @@ void dnodeFreeMnodeRqueue() { void dnodeDispatchToMnodeReadQueue(SRpcMsg *pMsg) { if (!mnodeIsRunning() || tsMReadQueue == NULL) { - dnodeSendRediretMsg(pMsg); + dnodeSendRedirectMsg(pMsg->msgType, pMsg->handle, true); return; } SMnodeMsg *pRead = (SMnodeMsg *)taosAllocateQitem(sizeof(SMnodeMsg)); - pRead->rpcMsg = *pMsg; + mnodeCreateMsg(pRead, pMsg); taosWriteQitem(tsMReadQueue, TAOS_QTYPE_RPC, pRead); } @@ -129,14 +129,14 @@ static void dnodeSendRpcMnodeReadRsp(SMnodeMsg *pRead, int32_t code) { if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; SRpcMsg rpcRsp = { - .handle = pRead->rpcMsg.handle, - .pCont = pRead->rspRet.rsp, - .contLen = pRead->rspRet.len, - .code = pRead->rspRet.code, + .handle = pRead->thandle, + .pCont = pRead->rpcRsp.rsp, + .contLen = pRead->rpcRsp.len, + .code = code, }; rpcSendResponse(&rpcRsp); - rpcFreeCont(pRead->rpcMsg.pCont); + mnodeCleanupMsg(pRead); } static void *dnodeProcessMnodeReadQueue(void *param) { @@ -150,7 +150,7 @@ static void *dnodeProcessMnodeReadQueue(void *param) { break; } - dTrace("%p, msg:%s will be processed", pReadMsg->rpcMsg.ahandle, taosMsg[pReadMsg->rpcMsg.msgType]); + dTrace("%p, msg:%s will be processed", pReadMsg->ahandle, taosMsg[pReadMsg->msgType]); int32_t code = mnodeProcessRead(pReadMsg); dnodeSendRpcMnodeReadRsp(pReadMsg, code); taosFreeQitem(pReadMsg); diff --git a/src/dnode/src/dnodeMWrite.c b/src/dnode/src/dnodeMWrite.c index b768b31b01..56022b4bf6 100644 --- a/src/dnode/src/dnodeMWrite.c +++ b/src/dnode/src/dnodeMWrite.c @@ -18,6 +18,7 @@ #include "taoserror.h" #include "taosmsg.h" #include "tutil.h" +#include "ttimer.h" #include "tqueue.h" #include "trpc.h" #include "twal.h" @@ -25,7 +26,7 @@ #include "mnode.h" #include "dnode.h" #include "dnodeInt.h" -#include "dnodeVMgmt.h" +#include "dnodeMgmt.h" #include "dnodeMWrite.h" typedef struct { @@ -41,6 +42,7 @@ typedef struct { static SMWriteWorkerPool tsMWritePool; static taos_qset tsMWriteQset; static taos_queue tsMWriteQueue; +extern void * tsDnodeTmr; static void *dnodeProcessMnodeWriteQueue(void *param); @@ -78,7 +80,7 @@ void dnodeCleanupMnodeWrite() { dPrint("dnode mwrite is closed"); } -int32_t dnodeAllocateMnodeRqueue() { +int32_t dnodeAllocateMnodeWqueue() { tsMWriteQueue = taosOpenQueue(); if (tsMWriteQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; @@ -104,34 +106,35 @@ int32_t dnodeAllocateMnodeRqueue() { return TSDB_CODE_SUCCESS; } -void dnodeFreeMnodeRqueue() { +void dnodeFreeMnodeWqueue() { taosCloseQueue(tsMWriteQueue); tsMWriteQueue = NULL; } void dnodeDispatchToMnodeWriteQueue(SRpcMsg *pMsg) { if (!mnodeIsRunning() || tsMWriteQueue == NULL) { - dnodeSendRediretMsg(pMsg); + dnodeSendRedirectMsg(pMsg->msgType, pMsg->handle, true); return; } SMnodeMsg *pWrite = (SMnodeMsg *)taosAllocateQitem(sizeof(SMnodeMsg)); - pWrite->rpcMsg = *pMsg; + mnodeCreateMsg(pWrite, pMsg); taosWriteQitem(tsMWriteQueue, TAOS_QTYPE_RPC, pWrite); } -static void dnodeSendRpcMnodeWriteRsp(SMnodeMsg *pWrite, int32_t code) { +void dnodeSendRpcMnodeWriteRsp(void *pRaw, int32_t code) { + SMnodeMsg *pWrite = pRaw; if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; SRpcMsg rpcRsp = { - .handle = pWrite->rpcMsg.handle, - .pCont = pWrite->rspRet.rsp, - .contLen = pWrite->rspRet.len, - .code = pWrite->rspRet.code, + .handle = pWrite->thandle, + .pCont = pWrite->rpcRsp.rsp, + .contLen = pWrite->rpcRsp.len, + .code = code, }; rpcSendResponse(&rpcRsp); - rpcFreeCont(pWrite->rpcMsg.pCont); + mnodeCleanupMsg(pWrite); } static void *dnodeProcessMnodeWriteQueue(void *param) { @@ -145,7 +148,7 @@ static void *dnodeProcessMnodeWriteQueue(void *param) { break; } - dTrace("%p, msg:%s will be processed", pWriteMsg->rpcMsg.ahandle, taosMsg[pWriteMsg->rpcMsg.msgType]); + dTrace("%p, msg:%s will be processed", pWriteMsg->ahandle, taosMsg[pWriteMsg->msgType]); int32_t code = mnodeProcessWrite(pWriteMsg); dnodeSendRpcMnodeWriteRsp(pWriteMsg, code); taosFreeQitem(pWriteMsg); @@ -153,3 +156,30 @@ static void *dnodeProcessMnodeWriteQueue(void *param) { return NULL; } + +static void dnodeFreeMnodeWriteMsg(void *pMsg) { + SMnodeMsg *pWrite = pMsg; + mnodeCleanupMsg(pWrite); + taosFreeQitem(pWrite); +} + +void dnodeReprocessMnodeWriteMsg(void *pMsg) { + SMnodeMsg *pWrite = pMsg; + + if (!mnodeIsRunning() || tsMWriteQueue == NULL) { + dnodeSendRedirectMsg(pWrite->msgType, pWrite->thandle, true); + dnodeFreeMnodeWriteMsg(pWrite); + } else { + taosWriteQitem(tsMWriteQueue, TAOS_QTYPE_RPC, pWrite); + } +} + +static void dnodeDoDelayReprocessMnodeWriteMsg(void *param, void *tmrId) { + dnodeReprocessMnodeWriteMsg(param); +} + +void dnodeDelayReprocessMnodeWriteMsg(void *pMsg) { + SMnodeMsg *mnodeMsg = pMsg; + void *unUsed = NULL; + taosTmrReset(dnodeDoDelayReprocessMnodeWriteMsg, 300, mnodeMsg, tsDnodeTmr, &unUsed); +} \ No newline at end of file diff --git a/src/dnode/src/dnodeMain.c b/src/dnode/src/dnodeMain.c index e9e9480aef..76f9446e0e 100644 --- a/src/dnode/src/dnodeMain.c +++ b/src/dnode/src/dnodeMain.c @@ -21,14 +21,14 @@ #include "tglobal.h" #include "dnode.h" #include "dnodeInt.h" -#include "dnodeVMgmt.h" +#include "dnodeMgmt.h" #include "dnodePeer.h" #include "dnodeModule.h" #include "dnodeVRead.h" #include "dnodeVWrite.h" #include "dnodeMRead.h" #include "dnodeMWrite.h" -#include "dnodeMMgmt.h" +#include "dnodeMPeer.h" #include "dnodeShell.h" static int32_t dnodeInitStorage(); @@ -72,7 +72,7 @@ int32_t dnodeInitSystem() { if (dnodeInitVnodeWrite() != 0) return -1; if (dnodeInitMnodeRead() != 0) return -1; if (dnodeInitMnodeWrite() != 0) return -1; - if (dnodeInitMnodeMgmt() != 0) return -1; + if (dnodeInitMnodePeer() != 0) return -1; if (dnodeInitClient() != 0) return -1; if (dnodeInitServer() != 0) return -1; if (dnodeInitMgmt() != 0) return -1; @@ -95,7 +95,7 @@ void dnodeCleanUpSystem() { dnodeCleanupMgmt(); dnodeCleanupServer(); dnodeCleanupClient(); - dnodeCleanupMnodeMgmt(); + dnodeCleanupMnodePeer(); dnodeCleanupMnodeWrite(); dnodeCleanupMnodeRead(); dnodeCleanupVnodeWrite(); diff --git a/src/dnode/src/dnodeMgmt.c b/src/dnode/src/dnodeMgmt.c index 442b517846..ec7ff4c66c 100644 --- a/src/dnode/src/dnodeMgmt.c +++ b/src/dnode/src/dnodeMgmt.c @@ -32,13 +32,22 @@ #include "vnode.h" #include "mnode.h" #include "dnodeInt.h" -#include "dnodeVMgmt.h" +#include "dnodeMgmt.h" #include "dnodeVRead.h" #include "dnodeVWrite.h" #include "dnodeModule.h" #define MPEER_CONTENT_LEN 2000 +void * tsDnodeTmr = NULL; +static void * tsStatusTimer = NULL; +static uint32_t tsRebootTime; + +static SRpcIpSet tsDMnodeIpSetForPeer = {0}; +static SRpcIpSet tsDMnodeIpSetForShell = {0}; +static SDMMnodeInfos tsDMnodeInfos = {0}; +static SDMDnodeCfg tsDnodeCfg = {0}; + static void dnodeUpdateMnodeInfos(SDMMnodeInfos *pMnodes); static bool dnodeReadMnodeInfos(); static void dnodeSaveMnodeInfos(); @@ -48,14 +57,6 @@ static void dnodeSaveDnodeCfg(); static void dnodeProcessStatusRsp(SRpcMsg *pMsg); static void dnodeSendStatusMsg(void *handle, void *tmrId); -static void *tsDnodeTmr = NULL; -static void *tsStatusTimer = NULL; -static uint32_t tsRebootTime; - -static SRpcIpSet tsMnodeIpSet = {0}; -static SDMMnodeInfos tsMnodeInfos = {0}; -static SDMDnodeCfg tsDnodeCfg = {0}; - static int32_t dnodeOpenVnodes(); static void dnodeCloseVnodes(); static int32_t dnodeProcessCreateVnodeMsg(SRpcMsg *pMsg); @@ -81,22 +82,40 @@ int32_t dnodeInitMgmt() { } if (!dnodeReadMnodeInfos()) { - memset(&tsMnodeIpSet, 0, sizeof(SRpcIpSet)); - memset(&tsMnodeInfos, 0, sizeof(SDMMnodeInfos)); - tsMnodeIpSet.numOfIps = 1; - taosGetFqdnPortFromEp(tsFirst, tsMnodeIpSet.fqdn[0], &tsMnodeIpSet.port[0]); - tsMnodeIpSet.port[0] += TSDB_PORT_DNODEDNODE; + memset(&tsDMnodeIpSetForPeer, 0, sizeof(SRpcIpSet)); + memset(&tsDMnodeIpSetForShell, 0, sizeof(SRpcIpSet)); + memset(&tsDMnodeInfos, 0, sizeof(SDMMnodeInfos)); + + tsDMnodeIpSetForPeer.numOfIps = 1; + taosGetFqdnPortFromEp(tsFirst, tsDMnodeIpSetForPeer.fqdn[0], &tsDMnodeIpSetForPeer.port[0]); + tsDMnodeIpSetForPeer.port[0] += TSDB_PORT_DNODEDNODE; + + tsDMnodeIpSetForShell.numOfIps = 1; + taosGetFqdnPortFromEp(tsFirst, tsDMnodeIpSetForShell.fqdn[0], &tsDMnodeIpSetForShell.port[0]); + tsDMnodeIpSetForShell.port[0] += TSDB_PORT_DNODESHELL; + if (strcmp(tsSecond, tsFirst) != 0) { - tsMnodeIpSet.numOfIps = 2; - taosGetFqdnPortFromEp(tsSecond, tsMnodeIpSet.fqdn[1], &tsMnodeIpSet.port[1]); - tsMnodeIpSet.port[1] += TSDB_PORT_DNODEDNODE; + tsDMnodeIpSetForPeer.numOfIps = 2; + taosGetFqdnPortFromEp(tsSecond, tsDMnodeIpSetForPeer.fqdn[1], &tsDMnodeIpSetForPeer.port[1]); + tsDMnodeIpSetForPeer.port[1] += TSDB_PORT_DNODEDNODE; + + tsDMnodeIpSetForShell.numOfIps = 2; + taosGetFqdnPortFromEp(tsSecond, tsDMnodeIpSetForShell.fqdn[1], &tsDMnodeIpSetForShell.port[1]); + tsDMnodeIpSetForShell.port[1] += TSDB_PORT_DNODESHELL; } } else { - tsMnodeIpSet.inUse = tsMnodeInfos.inUse; - tsMnodeIpSet.numOfIps = tsMnodeInfos.nodeNum; - for (int32_t i = 0; i < tsMnodeInfos.nodeNum; i++) { - taosGetFqdnPortFromEp(tsMnodeInfos.nodeInfos[i].nodeEp, tsMnodeIpSet.fqdn[i], &tsMnodeIpSet.port[i]); - tsMnodeIpSet.port[i] += TSDB_PORT_DNODEDNODE; + tsDMnodeIpSetForPeer.inUse = tsDMnodeInfos.inUse; + tsDMnodeIpSetForPeer.numOfIps = tsDMnodeInfos.nodeNum; + for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) { + taosGetFqdnPortFromEp(tsDMnodeInfos.nodeInfos[i].nodeEp, tsDMnodeIpSetForPeer.fqdn[i], &tsDMnodeIpSetForPeer.port[i]); + tsDMnodeIpSetForPeer.port[i] += TSDB_PORT_DNODEDNODE; + } + + tsDMnodeIpSetForShell.inUse = tsDMnodeInfos.inUse; + tsDMnodeIpSetForShell.numOfIps = tsDMnodeInfos.nodeNum; + for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) { + taosGetFqdnPortFromEp(tsDMnodeInfos.nodeInfos[i].nodeEp, tsDMnodeIpSetForShell.fqdn[i], &tsDMnodeIpSetForShell.port[i]); + tsDMnodeIpSetForShell.port[i] += TSDB_PORT_DNODESHELL; } } @@ -265,26 +284,23 @@ static int32_t dnodeProcessConfigDnodeMsg(SRpcMsg *pMsg) { return taosCfgDynamicOptions(pCfg->config); } -void dnodeUpdateIpSet(SRpcIpSet *pIpSet) { +void dnodeUpdateMnodeIpSetForPeer(SRpcIpSet *pIpSet) { dPrint("mnode IP list is changed, numOfIps:%d inUse:%d", pIpSet->numOfIps, pIpSet->inUse); for (int i = 0; i < pIpSet->numOfIps; ++i) { dPrint("mnode index:%d %s:%u", i, pIpSet->fqdn[i], pIpSet->port[i]) } - tsMnodeIpSet = *pIpSet; + tsDMnodeIpSetForPeer = *pIpSet; } -void dnodeGetMnodeDnodeIpSet(void *ipSetRaw, bool encode) { +void dnodeGetMnodeIpSetForPeer(void *ipSetRaw) { SRpcIpSet *ipSet = ipSetRaw; - ipSet->numOfIps = tsMnodeInfos.nodeNum; - ipSet->inUse = tsMnodeInfos.inUse; - for (int32_t i = 0; i < tsMnodeInfos.nodeNum; ++i) { - taosGetFqdnPortFromEp(tsMnodeInfos.nodeInfos[i].nodeEp, ipSet->fqdn[i], &ipSet->port[i]); - ipSet->port[i] += TSDB_PORT_DNODEDNODE; - if (encode) { - ipSet->port[i] = htons(ipSet->port[i]); - } - } + *ipSet = tsDMnodeIpSetForPeer; +} + +void dnodeGetMnodeIpSetForShell(void *ipSetRaw) { + SRpcIpSet *ipSet = ipSetRaw; + *ipSet = tsDMnodeIpSetForShell; } static void dnodeProcessStatusRsp(SRpcMsg *pMsg) { @@ -324,22 +340,22 @@ static void dnodeProcessStatusRsp(SRpcMsg *pMsg) { } static void dnodeUpdateMnodeInfos(SDMMnodeInfos *pMnodes) { - bool mnodesChanged = (memcmp(&tsMnodeInfos, pMnodes, sizeof(SDMMnodeInfos)) != 0); - bool mnodesNotInit = (tsMnodeInfos.nodeNum == 0); + bool mnodesChanged = (memcmp(&tsDMnodeInfos, pMnodes, sizeof(SDMMnodeInfos)) != 0); + bool mnodesNotInit = (tsDMnodeInfos.nodeNum == 0); if (!(mnodesChanged || mnodesNotInit)) return; - memcpy(&tsMnodeInfos, pMnodes, sizeof(SDMMnodeInfos)); + memcpy(&tsDMnodeInfos, pMnodes, sizeof(SDMMnodeInfos)); - tsMnodeIpSet.inUse = tsMnodeInfos.inUse; - tsMnodeIpSet.numOfIps = tsMnodeInfos.nodeNum; - for (int32_t i = 0; i < tsMnodeInfos.nodeNum; i++) { - taosGetFqdnPortFromEp(tsMnodeInfos.nodeInfos[i].nodeEp, tsMnodeIpSet.fqdn[i], &tsMnodeIpSet.port[i]); - tsMnodeIpSet.port[i] += TSDB_PORT_DNODEDNODE; + tsDMnodeIpSetForPeer.inUse = tsDMnodeInfos.inUse; + tsDMnodeIpSetForPeer.numOfIps = tsDMnodeInfos.nodeNum; + for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) { + taosGetFqdnPortFromEp(tsDMnodeInfos.nodeInfos[i].nodeEp, tsDMnodeIpSetForPeer.fqdn[i], &tsDMnodeIpSetForPeer.port[i]); + tsDMnodeIpSetForPeer.port[i] += TSDB_PORT_DNODEDNODE; } - dPrint("mnodes is changed, nodeNum:%d inUse:%d", tsMnodeInfos.nodeNum, tsMnodeInfos.inUse); - for (int32_t i = 0; i < tsMnodeInfos.nodeNum; i++) { - dPrint("mnode:%d, %s", tsMnodeInfos.nodeInfos[i].nodeId, tsMnodeInfos.nodeInfos[i].nodeEp); + dPrint("mnodes is changed, nodeNum:%d inUse:%d", tsDMnodeInfos.nodeNum, tsDMnodeInfos.inUse); + for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) { + dPrint("mnode:%d, %s", tsDMnodeInfos.nodeInfos[i].nodeId, tsDMnodeInfos.nodeInfos[i].nodeEp); } dnodeSaveMnodeInfos(); @@ -377,14 +393,14 @@ static bool dnodeReadMnodeInfos() { dError("failed to read mnode mgmtIpList.json, inUse not found"); goto PARSE_OVER; } - tsMnodeInfos.inUse = inUse->valueint; + tsDMnodeInfos.inUse = inUse->valueint; cJSON* nodeNum = cJSON_GetObjectItem(root, "nodeNum"); if (!nodeNum || nodeNum->type != cJSON_Number) { dError("failed to read mnode mgmtIpList.json, nodeNum not found"); goto PARSE_OVER; } - tsMnodeInfos.nodeNum = nodeNum->valueint; + tsDMnodeInfos.nodeNum = nodeNum->valueint; cJSON* nodeInfos = cJSON_GetObjectItem(root, "nodeInfos"); if (!nodeInfos || nodeInfos->type != cJSON_Array) { @@ -393,7 +409,7 @@ static bool dnodeReadMnodeInfos() { } int size = cJSON_GetArraySize(nodeInfos); - if (size != tsMnodeInfos.nodeNum) { + if (size != tsDMnodeInfos.nodeNum) { dError("failed to read mnode mgmtIpList.json, nodeInfos size not matched"); goto PARSE_OVER; } @@ -407,21 +423,21 @@ static bool dnodeReadMnodeInfos() { dError("failed to read mnode mgmtIpList.json, nodeId not found"); goto PARSE_OVER; } - tsMnodeInfos.nodeInfos[i].nodeId = nodeId->valueint; + tsDMnodeInfos.nodeInfos[i].nodeId = nodeId->valueint; cJSON *nodeEp = cJSON_GetObjectItem(nodeInfo, "nodeEp"); if (!nodeEp || nodeEp->type != cJSON_String || nodeEp->valuestring == NULL) { dError("failed to read mnode mgmtIpList.json, nodeName not found"); goto PARSE_OVER; } - strncpy(tsMnodeInfos.nodeInfos[i].nodeEp, nodeEp->valuestring, TSDB_EP_LEN); + strncpy(tsDMnodeInfos.nodeInfos[i].nodeEp, nodeEp->valuestring, TSDB_EP_LEN); } ret = true; - dPrint("read mnode iplist successed, numOfIps:%d inUse:%d", tsMnodeInfos.nodeNum, tsMnodeInfos.inUse); - for (int32_t i = 0; i < tsMnodeInfos.nodeNum; i++) { - dPrint("mnode:%d, %s", tsMnodeInfos.nodeInfos[i].nodeId, tsMnodeInfos.nodeInfos[i].nodeEp); + dPrint("read mnode iplist successed, numOfIps:%d inUse:%d", tsDMnodeInfos.nodeNum, tsDMnodeInfos.inUse); + for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) { + dPrint("mnode:%d, %s", tsDMnodeInfos.nodeInfos[i].nodeId, tsDMnodeInfos.nodeInfos[i].nodeEp); } PARSE_OVER: @@ -442,13 +458,13 @@ static void dnodeSaveMnodeInfos() { char * content = calloc(1, maxLen + 1); len += snprintf(content + len, maxLen - len, "{\n"); - len += snprintf(content + len, maxLen - len, " \"inUse\": %d,\n", tsMnodeInfos.inUse); - len += snprintf(content + len, maxLen - len, " \"nodeNum\": %d,\n", tsMnodeInfos.nodeNum); + len += snprintf(content + len, maxLen - len, " \"inUse\": %d,\n", tsDMnodeInfos.inUse); + len += snprintf(content + len, maxLen - len, " \"nodeNum\": %d,\n", tsDMnodeInfos.nodeNum); len += snprintf(content + len, maxLen - len, " \"nodeInfos\": [{\n"); - for (int32_t i = 0; i < tsMnodeInfos.nodeNum; i++) { - len += snprintf(content + len, maxLen - len, " \"nodeId\": %d,\n", tsMnodeInfos.nodeInfos[i].nodeId); - len += snprintf(content + len, maxLen - len, " \"nodeEp\": \"%s\"\n", tsMnodeInfos.nodeInfos[i].nodeEp); - if (i < tsMnodeInfos.nodeNum -1) { + for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) { + len += snprintf(content + len, maxLen - len, " \"nodeId\": %d,\n", tsDMnodeInfos.nodeInfos[i].nodeId); + len += snprintf(content + len, maxLen - len, " \"nodeEp\": \"%s\"\n", tsDMnodeInfos.nodeInfos[i].nodeEp); + if (i < tsDMnodeInfos.nodeNum -1) { len += snprintf(content + len, maxLen - len, " },{\n"); } else { len += snprintf(content + len, maxLen - len, " }]\n"); @@ -464,11 +480,11 @@ static void dnodeSaveMnodeInfos() { } char *dnodeGetMnodeMasterEp() { - return tsMnodeInfos.nodeInfos[tsMnodeIpSet.inUse].nodeEp; + return tsDMnodeInfos.nodeInfos[tsDMnodeIpSetForPeer.inUse].nodeEp; } void* dnodeGetMnodeInfos() { - return &tsMnodeInfos; + return &tsDMnodeInfos; } static void dnodeSendStatusMsg(void *handle, void *tmrId) { @@ -511,7 +527,7 @@ static void dnodeSendStatusMsg(void *handle, void *tmrId) { .msgType = TSDB_MSG_TYPE_DM_STATUS }; - dnodeSendMsgToDnode(&tsMnodeIpSet, &rpcMsg); + dnodeSendMsgToDnode(&tsDMnodeIpSetForPeer, &rpcMsg); } static bool dnodeReadDnodeCfg() { @@ -593,14 +609,18 @@ int32_t dnodeGetDnodeId() { return tsDnodeCfg.dnodeId; } -void dnodeSendRediretMsg(SRpcMsg *rpcMsg) { +void dnodeSendRedirectMsg(int32_t msgType, void *thandle, bool forShell) { SRpcConnInfo connInfo; - rpcGetConnInfo(rpcMsg->handle, &connInfo); + rpcGetConnInfo(thandle, &connInfo); SRpcIpSet ipSet = {0}; - dnodeGetMnodeDnodeIpSet(&ipSet); - - dTrace("msg:%s will be redirected, dnodeIp:%s user:%s, numOfIps:%d inUse:%d", taosMsg[rpcMsg->msgType], + if (forShell) { + dnodeGetMnodeIpSetForShell(&ipSet); + } else { + dnodeGetMnodeIpSetForPeer(&ipSet); + } + + dTrace("msg:%s will be redirected, dnodeIp:%s user:%s, numOfIps:%d inUse:%d", taosMsg[msgType], taosIpStr(connInfo.clientIp), connInfo.user, ipSet.numOfIps, ipSet.inUse); for (int i = 0; i < ipSet.numOfIps; ++i) { @@ -608,5 +628,5 @@ void dnodeSendRediretMsg(SRpcMsg *rpcMsg) { ipSet.port[i] = htons(ipSet.port[i]); } - rpcSendRedirectRsp(rpcMsg->handle, &ipSet); -} \ No newline at end of file + rpcSendRedirectRsp(thandle, &ipSet); +} diff --git a/src/dnode/src/dnodeModule.c b/src/dnode/src/dnodeModule.c index 2f3008c33e..61c1ec9382 100644 --- a/src/dnode/src/dnodeModule.c +++ b/src/dnode/src/dnodeModule.c @@ -48,9 +48,9 @@ static void dnodeUnSetModuleStatus(int32_t module) { static void dnodeAllocModules() { tsModule[TSDB_MOD_MGMT].enable = false; tsModule[TSDB_MOD_MGMT].name = "mgmt"; - tsModule[TSDB_MOD_MGMT].initFp = mgmtInitSystem; - tsModule[TSDB_MOD_MGMT].cleanUpFp = mgmtCleanUpSystem; - tsModule[TSDB_MOD_MGMT].startFp = mgmtStartSystem; + tsModule[TSDB_MOD_MGMT].initFp = mnodeInitSystem; + tsModule[TSDB_MOD_MGMT].cleanUpFp = mnodeCleanupSystem; + tsModule[TSDB_MOD_MGMT].startFp = mnodeStartSystem; tsModule[TSDB_MOD_MGMT].stopFp = mgmtStopSystem; tsModule[TSDB_MOD_HTTP].enable = (tsEnableHttpModule == 1); diff --git a/src/dnode/src/dnodeMpeer.c b/src/dnode/src/dnodeMpeer.c deleted file mode 100644 index d1bfa3a048..0000000000 --- a/src/dnode/src/dnodeMpeer.c +++ /dev/null @@ -1,155 +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 "taosmsg.h" -#include "tutil.h" -#include "tqueue.h" -#include "trpc.h" -#include "twal.h" -#include "tglobal.h" -#include "mnode.h" -#include "dnode.h" -#include "dnodeInt.h" -#include "dnodeVMgmt.h" -#include "dnodeMWrite.h" - -typedef struct { - pthread_t thread; - int32_t workerId; -} SMMgmtWorker; - -typedef struct { - int32_t num; - SMMgmtWorker *mgmtWorker; -} SMMgmtWorkerPool; - -static SMMgmtWorkerPool tsMMgmtPool; -static taos_qset tsMMgmtQset; -static taos_queue tsMMgmtQueue; - -static void *dnodeProcessMnodeMgmtQueue(void *param); - -int32_t dnodeInitMnodeMgmt() { - tsMMgmtQset = taosOpenQset(); - - tsMMgmtPool.num = 1; - tsMMgmtPool.mgmtWorker = (SMMgmtWorker *)calloc(sizeof(SMMgmtWorker), tsMMgmtPool.num); - - if (tsMMgmtPool.mgmtWorker == NULL) return -1; - for (int32_t i = 0; i < tsMMgmtPool.num; ++i) { - SMMgmtWorker *pWorker = tsMMgmtPool.mgmtWorker + i; - pWorker->workerId = i; - } - - dPrint("dnode mmgmt is opened"); - return 0; -} - -void dnodeCleanupMnodeMgmt() { - for (int32_t i = 0; i < tsMMgmtPool.num; ++i) { - SMMgmtWorker *pWorker = tsMMgmtPool.mgmtWorker + i; - if (pWorker->thread) { - taosQsetThreadResume(tsMMgmtQset); - } - } - - for (int32_t i = 0; i < tsMMgmtPool.num; ++i) { - SMMgmtWorker *pWorker = tsMMgmtPool.mgmtWorker + i; - if (pWorker->thread) { - pthread_join(pWorker->thread, NULL); - } - } - - dPrint("dnode mmgmt is closed"); -} - -int32_t dnodeAllocateMnodeMqueue() { - tsMMgmtQueue = taosOpenQueue(); - if (tsMMgmtQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; - - taosAddIntoQset(tsMMgmtQset, tsMMgmtQueue, NULL); - - for (int32_t i = 0; i < tsMMgmtPool.num; ++i) { - SMMgmtWorker *pWorker = tsMMgmtPool.mgmtWorker + 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, dnodeProcessMnodeMgmtQueue, pWorker) != 0) { - dError("failed to create thread to process mmgmt queue, reason:%s", strerror(errno)); - } - - pthread_attr_destroy(&thAttr); - dTrace("dnode mmgmt worker:%d is launched, total:%d", pWorker->workerId, tsMMgmtPool.num); - } - - dTrace("dnode mmgmt queue:%p is allocated", tsMMgmtQueue); - return TSDB_CODE_SUCCESS; -} - -void dnodeFreeMnodeRqueue() { - taosCloseQueue(tsMMgmtQueue); - tsMMgmtQueue = NULL; -} - -void dnodeDispatchToMnodeMgmtQueue(SRpcMsg *pMsg) { - if (!mnodeIsRunning() || tsMMgmtQueue == NULL) { - dnodeSendRediretMsg(pMsg); - return; - } - - SMnodeMsg *pMgmt = (SMnodeMsg *)taosAllocateQitem(sizeof(SMnodeMsg)); - pMgmt->rpcMsg = *pMsg; - taosWriteQitem(tsMMgmtQueue, TAOS_QTYPE_RPC, pMgmt); -} - -static void dnodeSendRpcMnodeMgmtRsp(SMnodeMsg *pMgmt, int32_t code) { - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; - - SRpcMsg rpcRsp = { - .handle = pMgmt->rpcMsg.handle, - .pCont = pMgmt->rspRet.rsp, - .contLen = pMgmt->rspRet.len, - .code = pMgmt->rspRet.code, - }; - - rpcSendResponse(&rpcRsp); - rpcFreeCont(pMgmt->rpcMsg.pCont); -} - -static void *dnodeProcessMnodeMgmtQueue(void *param) { - SMnodeMsg *pMgmtMsg; - int32_t type; - void * unUsed; - - while (1) { - if (taosReadQitemFromQset(tsMMgmtQset, &type, (void **)&pMgmtMsg, &unUsed) == 0) { - dTrace("dnodeProcessMnodeMgmtQueue: got no message from qset, exiting..."); - break; - } - - dTrace("%p, msg:%s will be processed", pMgmtMsg->rpcMsg.ahandle, taosMsg[pMgmtMsg->rpcMsg.msgType]); - int32_t code = mnodeProcessMgmt(pMgmtMsg); - dnodeSendRpcMnodeMgmtRsp(pMgmtMsg, code); - taosFreeQitem(pMgmtMsg); - } - - return NULL; -} diff --git a/src/dnode/src/dnodePeer.c b/src/dnode/src/dnodePeer.c index 9695de1209..53e664b58b 100644 --- a/src/dnode/src/dnodePeer.c +++ b/src/dnode/src/dnodePeer.c @@ -23,15 +23,15 @@ #include "taosmsg.h" #include "tglobal.h" #include "trpc.h" +#include "mnode.h" #include "dnode.h" #include "dnodeInt.h" -#include "dnodeVMgmt.h" +#include "dnodeMgmt.h" #include "dnodeVWrite.h" #include "dnodeMRead.h" #include "dnodeMWrite.h" -#include "mnode.h" -extern void dnodeUpdateIpSet(SRpcIpSet *pIpSet); +extern void dnodeUpdateMnodeIpSetForPeer(SRpcIpSet *pIpSet); static void (*dnodeProcessReqMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *); static void dnodeProcessReqMsgFromDnode(SRpcMsg *pMsg, SRpcIpSet *); static void (*dnodeProcessRspMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *rpcMsg); @@ -148,9 +148,10 @@ void dnodeCleanupClient() { } static void dnodeProcessRspFromDnode(SRpcMsg *pMsg, SRpcIpSet *pIpSet) { - if (dnodeProcessRspMsgFp[pMsg->msgType]) { - if (pMsg->msgType == TSDB_MSG_TYPE_DM_STATUS_RSP && pIpSet) dnodeUpdateIpSet(pIpSet); + if (pMsg->msgType == TSDB_MSG_TYPE_DM_STATUS_RSP && pIpSet) { + dnodeUpdateMnodeIpSetForPeer(pIpSet); + } (*dnodeProcessRspMsgFp[pMsg->msgType])(pMsg); } else { dError("RPC %p, msg:%s is not processed", pMsg->handle, taosMsg[pMsg->msgType]); @@ -169,6 +170,6 @@ void dnodeSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg) { void dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp) { SRpcIpSet ipSet = {0}; - dnodeGetMnodeDnodeIpSet(&ipSet, false); + dnodeGetMnodeIpSetForPeer(&ipSet); rpcSendRecv(tsDnodeClientRpc, &ipSet, rpcMsg, rpcRsp); } diff --git a/src/dnode/src/dnodeShell.c b/src/dnode/src/dnodeShell.c index 031d860b1e..68dfaef408 100644 --- a/src/dnode/src/dnodeShell.c +++ b/src/dnode/src/dnodeShell.c @@ -37,8 +37,6 @@ static void * tsDnodeShellRpc = NULL; static int32_t tsDnodeQueryReqNum = 0; static int32_t tsDnodeSubmitReqNum = 0; -void mgmtProcessMsgFromShell(SRpcMsg *rpcMsg); - int32_t dnodeInitShell() { dnodeProcessShellMsgFp[TSDB_MSG_TYPE_SUBMIT] = dnodeDispatchToVnodeWriteQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_QUERY] = dnodeDispatchToVnodeReadQueue; @@ -141,7 +139,7 @@ void dnodeProcessMsgFromShell(SRpcMsg *pMsg, SRpcIpSet *pIpSet) { } static int dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey) { - int code = mgmtRetriveAuth(user, spi, encrypt, secret, ckey); + int code = mnodeRetriveAuth(user, spi, encrypt, secret, ckey); if (code != TSDB_CODE_NOT_READY) return code; SDMAuthMsg *pMsg = rpcMallocCont(sizeof(SDMAuthMsg)); diff --git a/src/dnode/src/dnodeVRead.c b/src/dnode/src/dnodeVRead.c index 34bbdb5788..c2ca9fcd02 100644 --- a/src/dnode/src/dnodeVRead.c +++ b/src/dnode/src/dnodeVRead.c @@ -23,7 +23,7 @@ #include "twal.h" #include "tglobal.h" #include "dnodeInt.h" -#include "dnodeVMgmt.h" +#include "dnodeMgmt.h" #include "dnodeVRead.h" #include "vnode.h" @@ -93,7 +93,7 @@ void dnodeCleanupVnodeRead() { } void dnodeDispatchToVnodeReadQueue(SRpcMsg *pMsg) { - int32_t queuedMsgNum = 0; + int32_t mnodeMsgNum = 0; int32_t leftLen = pMsg->contLen; char *pCont = (char *) pMsg->pCont; void *pVnode; @@ -125,12 +125,12 @@ void dnodeDispatchToVnodeReadQueue(SRpcMsg *pMsg) { // next vnode leftLen -= pHead->contLen; pCont -= pHead->contLen; - queuedMsgNum++; + mnodeMsgNum++; taosWriteQitem(queue, TAOS_QTYPE_RPC, pRead); } - if (queuedMsgNum == 0) { + if (mnodeMsgNum == 0) { SRpcMsg rpcRsp = { .handle = pMsg->handle, .pCont = NULL, diff --git a/src/dnode/src/dnodeVWrite.c b/src/dnode/src/dnodeVWrite.c index 3783b857d1..bf4e49e84d 100644 --- a/src/dnode/src/dnodeVWrite.c +++ b/src/dnode/src/dnodeVWrite.c @@ -27,7 +27,7 @@ #include "tdataformat.h" #include "dnodeInt.h" #include "dnodeVWrite.h" -#include "dnodeVMgmt.h" +#include "dnodeMgmt.h" typedef struct { taos_qall qall; diff --git a/src/inc/dnode.h b/src/inc/dnode.h index bcab82cc5d..54108af4b9 100644 --- a/src/inc/dnode.h +++ b/src/inc/dnode.h @@ -43,16 +43,21 @@ void *dnodeAllocateRqueue(void *pVnode); void dnodeFreeRqueue(void *rqueue); void dnodeSendRpcWriteRsp(void *pVnode, void *param, int32_t code); -bool dnodeIsFirstDeploy(); -char *dnodeGetMnodeMasterEp(); -void dnodeGetMnodeDnodeIpSet(void *ipSet, bool encode); -void * dnodeGetMnodeInfos(); -int32_t dnodeGetDnodeId(); +bool dnodeIsFirstDeploy(); +char * dnodeGetMnodeMasterEp(); +void dnodeGetMnodeIpSetForPeer(void *ipSet); +void dnodeGetMnodeIpSetForShell(void *ipSet); +void * dnodeGetMnodeInfos(); +int32_t dnodeGetDnodeId(); -void dnodeAddClientRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)); -void dnodeAddServerMsgHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)); -void dnodeSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg); -void dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp); +void dnodeAddClientRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)); +void dnodeAddServerMsgHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)); +void dnodeSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg); +void dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp); + +void dnodeSendRpcMnodeWriteRsp(void *pMsg, int32_t code); +void dnodeReprocessMnodeWriteMsg(void *pMsg); +void dnodeDelayReprocessMnodeWriteMsg(void *pMsg); #ifdef __cplusplus } diff --git a/src/inc/mnode.h b/src/inc/mnode.h index f025cb5e8a..da0a899f37 100644 --- a/src/inc/mnode.h +++ b/src/inc/mnode.h @@ -13,44 +13,62 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_H -#define TDENGINE_MGMT_H +#ifndef TDENGINE_MNODE_H +#define TDENGINE_MNODE_H #ifdef __cplusplus extern "C" { #endif +struct SAcctObj; +struct SDnodeObj; +struct SUserObj; +struct SDbObj; +struct SVgObj; +struct STableObj; +struct SRpcMsg; + typedef struct { int len; - int code; void *rsp; } SMnodeRsp; -typedef struct { - SRpcMsg rpcMsg; +typedef struct SMnodeMsg { SMnodeRsp rpcRsp; + uint8_t msgType; + int8_t received; + int8_t successed; + int8_t expected; + int8_t retry; + int8_t maxRetry; + int32_t contLen; + int32_t code; + void * ahandle; + void * thandle; + void * pCont; + struct SAcctObj * pAcct; + struct SDnodeObj *pDnode; + struct SUserObj * pUser; + struct SDbObj * pDb; + struct SVgObj * pVgroup; + struct STableObj *pTable; } SMnodeMsg; -SMnodeMsg *mnodeCreateMsg(SRpcMsg *rpcMsg); -bool mnodeInitMsg(SMnodeMsg *pMsg); -void mnodeRleaseMsg(SMnodeMsg *pMsg); +void mnodeCreateMsg(SMnodeMsg *pMsg, struct SRpcMsg *rpcMsg); +int32_t mnodeInitMsg(SMnodeMsg *pMsg); +void mnodeCleanupMsg(SMnodeMsg *pMsg); -int32_t mgmtInitSystem(); -int32_t mgmtStartSystem(); -void mgmtCleanUpSystem(); +int32_t mnodeInitSystem(); +int32_t mnodeStartSystem(); +void mnodeCleanupSystem(); void mgmtStopSystem(); void sdbUpdateSync(); - -void* mnodeGetRqueue(void *); -void* mnodeGetWqueue(int32_t vgId); bool mnodeIsRunning(); int32_t mnodeProcessRead(SMnodeMsg *pMsg); int32_t mnodeProcessWrite(SMnodeMsg *pMsg); -int32_t mnodeProcessMgmt(SMnodeMsg *pMsg); - -int32_t mgmtRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey); -void mgmtProcessMsgFromShell(SRpcMsg *rpcMsg); -void mgmtProcessReqMsgFromDnode(SRpcMsg *rpcMsg); +int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg); +void mnodeProcessPeerRsp(struct SRpcMsg *pMsg); +int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey); #ifdef __cplusplus } diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h index f493a2b542..f550b1660f 100644 --- a/src/inc/taosmsg.h +++ b/src/inc/taosmsg.h @@ -121,23 +121,23 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY14, "dummy14" ) #define TSDB_IE_TYPE_DNODE_STATE 7 enum _mgmt_table { - TSDB_MNODE_TABLE_ACCT, - TSDB_MNODE_TABLE_USER, - TSDB_MNODE_TABLE_DB, - TSDB_MNODE_TABLE_TABLE, - TSDB_MNODE_TABLE_DNODE, - TSDB_MNODE_TABLE_MNODE, - TSDB_MNODE_TABLE_VGROUP, - TSDB_MNODE_TABLE_METRIC, - TSDB_MNODE_TABLE_MODULE, - TSDB_MNODE_TABLE_QUERIES, - TSDB_MNODE_TABLE_STREAMS, - TSDB_MNODE_TABLE_CONFIGS, - TSDB_MNODE_TABLE_CONNS, - TSDB_MNODE_TABLE_SCORES, - TSDB_MNODE_TABLE_GRANTS, - TSDB_MNODE_TABLE_VNODES, - TSDB_MNODE_TABLE_MAX, + TSDB_MGMT_TABLE_ACCT, + TSDB_MGMT_TABLE_USER, + TSDB_MGMT_TABLE_DB, + TSDB_MGMT_TABLE_TABLE, + TSDB_MGMT_TABLE_DNODE, + TSDB_MGMT_TABLE_MNODE, + TSDB_MGMT_TABLE_VGROUP, + TSDB_MGMT_TABLE_METRIC, + TSDB_MGMT_TABLE_MODULE, + TSDB_MGMT_TABLE_QUERIES, + TSDB_MGMT_TABLE_STREAMS, + TSDB_MGMT_TABLE_CONFIGS, + TSDB_MGMT_TABLE_CONNS, + TSDB_MGMT_TABLE_SCORES, + TSDB_MGMT_TABLE_GRANTS, + TSDB_MGMT_TABLE_VNODES, + TSDB_MGMT_TABLE_MAX, }; #define TSDB_ALTER_TABLE_ADD_TAG_COLUMN 1 diff --git a/src/inc/tbalance.h b/src/inc/tbalance.h index fee0452545..63437021fd 100644 --- a/src/inc/tbalance.h +++ b/src/inc/tbalance.h @@ -26,7 +26,7 @@ struct SDnodeObj; int32_t balanceInit(); void balanceCleanUp(); void balanceNotify(); -void balanceUpdateMgmt(); +void balanceUpdateMnode(); void balanceReset(); int32_t balanceAllocVnodes(struct SVgObj *pVgroup); int32_t balanceDropDnode(struct SDnodeObj *pDnode); diff --git a/src/inc/trpc.h b/src/inc/trpc.h index 16223b813a..5c5c77c251 100644 --- a/src/inc/trpc.h +++ b/src/inc/trpc.h @@ -28,21 +28,21 @@ extern "C" { extern int tsRpcHeadSize; -typedef struct { +typedef struct SRpcIpSet { int8_t inUse; int8_t numOfIps; uint16_t port[TSDB_MAX_REPLICA]; char fqdn[TSDB_MAX_REPLICA][TSDB_FQDN_LEN]; } SRpcIpSet; -typedef struct { +typedef struct SRpcConnInfo { uint32_t clientIp; uint16_t clientPort; uint32_t serverIp; char user[TSDB_USER_LEN]; } SRpcConnInfo; -typedef struct { +typedef struct SRpcMsg { uint8_t msgType; void *pCont; int contLen; @@ -51,7 +51,7 @@ typedef struct { void *ahandle; //app handle set by client, for debug purpose } SRpcMsg; -typedef struct { +typedef struct SRpcInit { uint16_t localPort; // local port char *label; // for debug purpose int numOfThreads; // number of threads to handle connections diff --git a/src/mnode/inc/mnodeAcct.h b/src/mnode/inc/mnodeAcct.h index 136c28f2ae..44c3fc3cb8 100644 --- a/src/mnode/inc/mnodeAcct.h +++ b/src/mnode/inc/mnodeAcct.h @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_ACCT_H -#define TDENGINE_MGMT_ACCT_H +#ifndef TDENGINE_MNODE_ACCT_H +#define TDENGINE_MNODE_ACCT_H #ifdef __cplusplus extern "C" { @@ -22,16 +22,16 @@ extern "C" { #include "tacct.h" -int32_t mgmtInitAccts(); -void mgmtCleanUpAccts(); -void * mgmtGetAcct(char *acctName); -void * mgmtGetNextAcct(void *pIter, SAcctObj **pAcct); -void mgmtIncAcctRef(SAcctObj *pAcct); -void mgmtDecAcctRef(SAcctObj *pAcct); -void mgmtAddDbToAcct(SAcctObj *pAcct, SDbObj *pDb); -void mgmtDropDbFromAcct(SAcctObj *pAcct, SDbObj *pDb); -void mgmtAddUserToAcct(SAcctObj *pAcct, SUserObj *pUser); -void mgmtDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser); +int32_t mnodeInitAccts(); +void mnodeCleanupAccts(); +void * mnodeGetAcct(char *acctName); +void * mnodeGetNextAcct(void *pIter, SAcctObj **pAcct); +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); #ifdef __cplusplus } diff --git a/src/mnode/inc/mnodeDb.h b/src/mnode/inc/mnodeDb.h index 5339a878f1..c8557af166 100644 --- a/src/mnode/inc/mnodeDb.h +++ b/src/mnode/inc/mnodeDb.h @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_DB_H -#define TDENGINE_MGMT_DB_H +#ifndef TDENGINE_MNODE_DB_H +#define TDENGINE_MNODE_DB_H #ifdef __cplusplus extern "C" { @@ -28,26 +28,26 @@ enum _TSDB_DB_STATUS { }; // api -int32_t mgmtInitDbs(); -void mgmtCleanUpDbs(); -SDbObj *mgmtGetDb(char *db); -SDbObj *mgmtGetDbByTableId(char *db); -void * mgmtGetNextDb(void *pIter, SDbObj **pDb); -void mgmtIncDbRef(SDbObj *pDb); -void mgmtDecDbRef(SDbObj *pDb); -bool mgmtCheckIsMonitorDB(char *db, char *monitordb); -void mgmtDropAllDbs(SAcctObj *pAcct); +int32_t mnodeInitDbs(); +void mnodeCleanupDbs(); +SDbObj *mnodeGetDb(char *db); +SDbObj *mnodeGetDbByTableId(char *db); +void * mnodeGetNextDb(void *pIter, SDbObj **pDb); +void mnodeIncDbRef(SDbObj *pDb); +void mnodeDecDbRef(SDbObj *pDb); +bool mnodeCheckIsMonitorDB(char *db, char *monitordb); +void mnodeDropAllDbs(SAcctObj *pAcct); // util func -void mgmtAddSuperTableIntoDb(SDbObj *pDb); -void mgmtRemoveSuperTableFromDb(SDbObj *pDb); -void mgmtAddTableIntoDb(SDbObj *pDb); -void mgmtRemoveTableFromDb(SDbObj *pDb); -void mgmtAddVgroupIntoDb(SVgObj *pVgroup); -void mgmtAddVgroupIntoDbTail(SVgObj *pVgroup); -void mgmtRemoveVgroupFromDb(SVgObj *pVgroup); -void mgmtMoveVgroupToTail(SVgObj *pVgroup); -void mgmtMoveVgroupToHead(SVgObj *pVgroup); +void mnodeAddSuperTableIntoDb(SDbObj *pDb); +void mnodeRemoveSuperTableFromDb(SDbObj *pDb); +void mnodeAddTableIntoDb(SDbObj *pDb); +void mnodeRemoveTableFromDb(SDbObj *pDb); +void mnodeAddVgroupIntoDb(SVgObj *pVgroup); +void mnodeAddVgroupIntoDbTail(SVgObj *pVgroup); +void mnodeRemoveVgroupFromDb(SVgObj *pVgroup); +void mnodeMoveVgroupToTail(SVgObj *pVgroup); +void mnodeMoveVgroupToHead(SVgObj *pVgroup); #ifdef __cplusplus } diff --git a/src/mnode/inc/mnodeDef.h b/src/mnode/inc/mnodeDef.h index 07920403b1..aacf8f419f 100644 --- a/src/mnode/inc/mnodeDef.h +++ b/src/mnode/inc/mnodeDef.h @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_DEF_H -#define TDENGINE_MGMT_DEF_H +#ifndef TDENGINE_MNODE_DEF_H +#define TDENGINE_MNODE_DEF_H #ifdef __cplusplus extern "C" { @@ -65,7 +65,7 @@ typedef struct SMnodeObj { int8_t role; } SMnodeObj; -typedef struct { +typedef struct STableObj { char *tableId; int8_t type; } STableObj; @@ -233,26 +233,6 @@ typedef struct { char payload[]; } SShowObj; -typedef struct { - uint8_t msgType; - int8_t received; - int8_t successed; - int8_t expected; - int8_t retry; - int8_t maxRetry; - int32_t contLen; - int32_t code; - void *ahandle; - void *thandle; - void *pCont; - SAcctObj *pAcct; - SDnodeObj*pDnode; - SUserObj *pUser; - SDbObj *pDb; - SVgObj *pVgroup; - STableObj *pTable; -} SMnodeMsg; - #ifdef __cplusplus } #endif diff --git a/src/mnode/inc/mnodeDnode.h b/src/mnode/inc/mnodeDnode.h index 14960c5701..75a1e29b0b 100644 --- a/src/mnode/inc/mnodeDnode.h +++ b/src/mnode/inc/mnodeDnode.h @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_CLUSTER_H -#define TDENGINE_CLUSTER_H +#ifndef TDENGINE_MNODE_DNODE_H +#define TDENGINE_MNODE_DNODE_H #ifdef __cplusplus extern "C" { @@ -27,21 +27,21 @@ typedef enum { TAOS_DN_STATUS_READY } EDnodeStatus; -int32_t mgmtInitDnodes(); +int32_t mnodeInitDnodes(); void mgmtCleanupDnodes(); -char* mgmtGetDnodeStatusStr(int32_t dnodeStatus); +char* mnodeGetDnodeStatusStr(int32_t dnodeStatus); void mgmtMonitorDnodeModule(); -int32_t mgmtGetDnodesNum(); -int32_t mgmtGetOnlinDnodesNum(); -void * mgmtGetNextDnode(void *pIter, SDnodeObj **pDnode); -void mgmtIncDnodeRef(SDnodeObj *pDnode); -void mgmtDecDnodeRef(SDnodeObj *pDnode); -void * mgmtGetDnode(int32_t dnodeId); -void * mgmtGetDnodeByEp(char *ep); -void mgmtUpdateDnode(SDnodeObj *pDnode); -int32_t mgmtDropDnode(SDnodeObj *pDnode); +int32_t mnodeGetDnodesNum(); +int32_t mnodeGetOnlinDnodesNum(); +void * mnodeGetNextDnode(void *pIter, SDnodeObj **pDnode); +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); extern int32_t tsAccessSquence; diff --git a/src/mnode/inc/mnodeInt.h b/src/mnode/inc/mnodeInt.h index a83d5beee0..466c3306a0 100644 --- a/src/mnode/inc/mnodeInt.h +++ b/src/mnode/inc/mnodeInt.h @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_LOG_H -#define TDENGINE_MGMT_LOG_H +#ifndef TDENGINE_MNODE_LOG_H +#define TDENGINE_MNODE_LOG_H #ifdef __cplusplus extern "C" { diff --git a/src/mnode/inc/mnodeMnode.h b/src/mnode/inc/mnodeMnode.h index 123df73fb2..14ea992206 100644 --- a/src/mnode/inc/mnodeMnode.h +++ b/src/mnode/inc/mnodeMnode.h @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_MNODE_H -#define TDENGINE_MGMT_MNODE_H +#ifndef TDENGINE_MNODE_MNODE_H +#define TDENGINE_MNODE_MNODE_H #ifdef __cplusplus extern "C" { @@ -28,25 +28,25 @@ typedef enum { TAOS_MN_STATUS_READY } EMnodeStatus; -int32_t mgmtInitMnodes(); +int32_t mnodeInitMnodes(); void mgmtCleanupMnodes(); -int32_t mgmtAddMnode(int32_t dnodeId); -int32_t mgmtDropMnode(int32_t dnodeId); -void mgmtDropMnodeLocal(int32_t dnodeId); +int32_t mnodeAddMnode(int32_t dnodeId); +int32_t mnodeDropMnode(int32_t dnodeId); +void mnodeDropMnodeLocal(int32_t dnodeId); -void * mgmtGetMnode(int32_t mnodeId); -int32_t mgmtGetMnodesNum(); -void * mgmtGetNextMnode(void *pIter, struct SMnodeObj **pMnode); -void mgmtIncMnodeRef(struct SMnodeObj *pMnode); -void mgmtDecMnodeRef(struct SMnodeObj *pMnode); +void * mnodeGetMnode(int32_t mnodeId); +int32_t mnodeGetMnodesNum(); +void * mnodeGetNextMnode(void *pIter, struct SMnodeObj **pMnode); +void mnodeIncMnodeRef(struct SMnodeObj *pMnode); +void mnodeDecMnodeRef(struct SMnodeObj *pMnode); -char * mgmtGetMnodeRoleStr(); -void mgmtGetMnodeIpSetForPeer(SRpcIpSet *ipSet); -void mgmtGetMnodeIpSetForShell(SRpcIpSet *ipSet); +char * mnodeGetMnodeRoleStr(); +void mnodeGetMnodeIpSetForPeer(SRpcIpSet *ipSet); +void mnodeGetMnodeIpSetForShell(SRpcIpSet *ipSet); -void mgmtGetMnodeInfos(void *mnodes); -void mgmtUpdateMnodeIpSet(); +void mnodeGetMnodeInfos(void *mnodes); +void mnodeUpdateMnodeIpSet(); #ifdef __cplusplus } diff --git a/src/mnode/inc/mnodePeer.h b/src/mnode/inc/mnodePeer.h new file mode 100644 index 0000000000..c81617266d --- /dev/null +++ b/src/mnode/inc/mnodePeer.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 TDENGINE_MNODE_PEER_H +#define TDENGINE_MNODE_PEER_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); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/mnode/inc/mnodeProfile.h b/src/mnode/inc/mnodeProfile.h index cb5234c7e6..0311983a38 100644 --- a/src/mnode/inc/mnodeProfile.h +++ b/src/mnode/inc/mnodeProfile.h @@ -13,16 +13,16 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_PROFILE_H -#define TDENGINE_MGMT_PROFILE_H +#ifndef TDENGINE_MNODE_PROFILE_H +#define TDENGINE_MNODE_PROFILE_H #ifdef __cplusplus extern "C" { #endif #include "mnodeDef.h" -int32_t mgmtInitProfile(); -void mgmtCleanUpProfile(); +int32_t mnodeInitProfile(); +void mnodeCleanupProfile(); #ifdef __cplusplus } diff --git a/src/mnode/inc/mnodeServer.h b/src/mnode/inc/mnodeRead.h similarity index 77% rename from src/mnode/inc/mnodeServer.h rename to src/mnode/inc/mnodeRead.h index 69df500bbc..5e7131f585 100644 --- a/src/mnode/inc/mnodeServer.h +++ b/src/mnode/inc/mnodeRead.h @@ -13,15 +13,16 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_DSERVER_H -#define TDENGINE_MGMT_DSERVER_H +#ifndef TDENGINE_MNODE_READ_H +#define TDENGINE_MNODE_READ_H #ifdef __cplusplus extern "C" { #endif +#include "mnodeDef.h" -int32_t mnodeInitMgmt(); -void mgmtCleanupMgmt(); +void mnodeAddReadMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg)); +int32_t mnodeProcessRead(SMnodeMsg *pMsg); #ifdef __cplusplus } diff --git a/src/mnode/inc/mnodeShell.h b/src/mnode/inc/mnodeShow.h similarity index 62% rename from src/mnode/inc/mnodeShell.h rename to src/mnode/inc/mnodeShow.h index 53fb5827c1..d571eabfd8 100644 --- a/src/mnode/inc/mnodeShell.h +++ b/src/mnode/inc/mnodeShow.h @@ -13,35 +13,22 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_SHELL_H -#define TDENGINE_MGMT_SHELL_H +#ifndef TDENGINE_MNODE_SHELL_H +#define TDENGINE_MNODE_SHELL_H #ifdef __cplusplus extern "C" { #endif #include "mnodeDef.h" -int32_t mgmtInitShell(); -void mgmtCleanUpShell(); -void mgmtAddShellMsgHandle(uint8_t msgType, void (*fp)(SMnodeMsg *queuedMsg)); +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); void mnodeAddShowMetaHandle(uint8_t showType, SShowMetaFp fp); void mnodeAddShowRetrieveHandle(uint8_t showType, SShowRetrieveFp fp); -void mgmtAddToShellQueue(SMnodeMsg *queuedMsg); -void mgmtDealyedAddToShellQueue(SMnodeMsg *queuedMsg); -void mgmtSendSimpleResp(void *thandle, int32_t code); - -bool mgmtCheckQhandle(uint64_t qhandle); -void *mgmtSaveQhandle(void *qhandle, int32_t size); -void mgmtFreeQhandle(void *qhandle, bool forceRemove); - -void *mgmtMallocQueuedMsg(SRpcMsg *rpcMsg); -void *mgmtCloneQueuedMsg(SMnodeMsg *pSrcMsg); -void mgmtFreeQueuedMsg(SMnodeMsg *pMsg); - #ifdef __cplusplus } #endif diff --git a/src/mnode/inc/mnodeTable.h b/src/mnode/inc/mnodeTable.h index cee2a88ee4..78ef0e37e8 100644 --- a/src/mnode/inc/mnodeTable.h +++ b/src/mnode/inc/mnodeTable.h @@ -22,16 +22,16 @@ extern "C" { #include "mnodeDef.h" -int32_t mgmtInitTables(); -void mgmtCleanUpTables(); -void * mgmtGetTable(char *tableId); -void mgmtIncTableRef(void *pTable); -void mgmtDecTableRef(void *pTable); -void * mgmtGetNextChildTable(void *pIter, SChildTableObj **pTable); -void * mgmtGetNextSuperTable(void *pIter, SSuperTableObj **pTable); -void mgmtDropAllChildTables(SDbObj *pDropDb); -void mgmtDropAllSuperTables(SDbObj *pDropDb); -void mgmtDropAllChildTablesInVgroups(SVgObj *pVgroup); +int32_t mnodeInitTables(); +void mnodeCleanupTables(); +void * mnodeGetTable(char *tableId); +void mnodeIncTableRef(void *pTable); +void mnodeDecTableRef(void *pTable); +void * mnodeGetNextChildTable(void *pIter, SChildTableObj **pTable); +void * mnodeGetNextSuperTable(void *pIter, SSuperTableObj **pTable); +void mnodeDropAllChildTables(SDbObj *pDropDb); +void mnodeDropAllSuperTables(SDbObj *pDropDb); +void mnodeDropAllChildTablesInVgroups(SVgObj *pVgroup); #ifdef __cplusplus } diff --git a/src/mnode/inc/mnodeUser.h b/src/mnode/inc/mnodeUser.h index fc5ad13b8a..338b43b47d 100644 --- a/src/mnode/inc/mnodeUser.h +++ b/src/mnode/inc/mnodeUser.h @@ -13,23 +13,23 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_USER_H -#define TDENGINE_MGMT_USER_H +#ifndef TDENGINE_MNODE_USER_H +#define TDENGINE_MNODE_USER_H #ifdef __cplusplus extern "C" { #endif #include "mnodeDef.h" -int32_t mgmtInitUsers(); -void mgmtCleanUpUsers(); -SUserObj *mgmtGetUser(char *name); -void * mgmtGetNextUser(void *pIter, SUserObj **pUser); -void mgmtIncUserRef(SUserObj *pUser); -void mgmtDecUserRef(SUserObj *pUser); -SUserObj *mgmtGetUserFromConn(void *pConn); -int32_t mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass); -void mgmtDropAllUsers(SAcctObj *pAcct); +int32_t mnodeInitUsers(); +void mnodeCleanupUsers(); +SUserObj *mnodeGetUser(char *name); +void * mnodeGetNextUser(void *pIter, SUserObj **pUser); +void mnodeIncUserRef(SUserObj *pUser); +void mnodeDecUserRef(SUserObj *pUser); +SUserObj *mnodeGetUserFromConn(void *pConn); +int32_t mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass); +void mnodeDropAllUsers(SAcctObj *pAcct); #ifdef __cplusplus } diff --git a/src/mnode/inc/mnodeVgroup.h b/src/mnode/inc/mnodeVgroup.h index b1359e0734..ac8eb73296 100644 --- a/src/mnode/inc/mnodeVgroup.h +++ b/src/mnode/inc/mnodeVgroup.h @@ -13,41 +13,41 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_VGROUP_H -#define TDENGINE_MGMT_VGROUP_H +#ifndef TDENGINE_MNODE_VGROUP_H +#define TDENGINE_MNODE_VGROUP_H #ifdef __cplusplus extern "C" { #endif -#include "mnodeDef.h" +struct SMnodeMsg; -int32_t mgmtInitVgroups(); -void mgmtCleanUpVgroups(); -SVgObj *mgmtGetVgroup(int32_t vgId); -void mgmtIncVgroupRef(SVgObj *pVgroup); -void mgmtDecVgroupRef(SVgObj *pVgroup); -void mgmtDropAllDbVgroups(SDbObj *pDropDb, bool sendMsg); -void mgmtDropAllDnodeVgroups(SDnodeObj *pDropDnode); -void mgmtUpdateAllDbVgroups(SDbObj *pAlterDb); +int32_t mnodeInitVgroups(); +void mnodeCleanupVgroups(); +SVgObj *mnodeGetVgroup(int32_t vgId); +void mnodeIncVgroupRef(SVgObj *pVgroup); +void mnodeDecVgroupRef(SVgObj *pVgroup); +void mnodeDropAllDbVgroups(SDbObj *pDropDb, bool sendMsg); +void mnodeDropAllDnodeVgroups(SDnodeObj *pDropDnode); +void mnodeUpdateAllDbVgroups(SDbObj *pAlterDb); -void * mgmtGetNextVgroup(void *pIter, SVgObj **pVgroup); -void mgmtUpdateVgroup(SVgObj *pVgroup); -void mgmtUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *dnodeId, SVnodeLoad *pVload); +void * mnodeGetNextVgroup(void *pIter, SVgObj **pVgroup); +void mnodeUpdateVgroup(SVgObj *pVgroup); +void mnodeUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *dnodeId, SVnodeLoad *pVload); -void mgmtCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb); -void mgmtDropVgroup(SVgObj *pVgroup, void *ahandle); -void mgmtAlterVgroup(SVgObj *pVgroup, void *ahandle); -SVgObj *mgmtGetAvailableVgroup(SDbObj *pDb); +int32_t mnodeCreateVgroup(struct SMnodeMsg *pMsg, SDbObj *pDb); +void mnodeDropVgroup(SVgObj *pVgroup, void *ahandle); +void mnodeAlterVgroup(SVgObj *pVgroup, void *ahandle); +SVgObj *mnodeGetAvailableVgroup(SDbObj *pDb); -void mgmtAddTableIntoVgroup(SVgObj *pVgroup, SChildTableObj *pTable); -void mgmtRemoveTableFromVgroup(SVgObj *pVgroup, SChildTableObj *pTable); -void mgmtSendCreateVnodeMsg(SVgObj *pVgroup, SRpcIpSet *ipSet, void *ahandle); -void mgmtSendDropVnodeMsg(int32_t vgId, SRpcIpSet *ipSet, void *ahandle); -void mgmtSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle); +void mnodeAddTableIntoVgroup(SVgObj *pVgroup, SChildTableObj *pTable); +void mnodeRemoveTableFromVgroup(SVgObj *pVgroup, SChildTableObj *pTable); +void mnodeSendCreateVnodeMsg(SVgObj *pVgroup, SRpcIpSet *ipSet, void *ahandle); +void mnodeSendDropVnodeMsg(int32_t vgId, SRpcIpSet *ipSet, void *ahandle); +void mnodeSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle); -SRpcIpSet mgmtGetIpSetFromVgroup(SVgObj *pVgroup); -SRpcIpSet mgmtGetIpSetFromIp(char *ep); +SRpcIpSet mnodeGetIpSetFromVgroup(SVgObj *pVgroup); +SRpcIpSet mnodeGetIpSetFromIp(char *ep); #ifdef __cplusplus } diff --git a/src/mnode/inc/mnodeDClient.h b/src/mnode/inc/mnodeWrite.h similarity index 72% rename from src/mnode/inc/mnodeDClient.h rename to src/mnode/inc/mnodeWrite.h index 1bd222f4bc..ced8eeb7c0 100644 --- a/src/mnode/inc/mnodeDClient.h +++ b/src/mnode/inc/mnodeWrite.h @@ -13,17 +13,16 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_MGMT_DCLIENT_H -#define TDENGINE_MGMT_DCLIENT_H +#ifndef TDENGINE_MNODE_WRITE_H +#define TDENGINE_MNODE_WRITE_H #ifdef __cplusplus extern "C" { #endif +#include "mnodeDef.h" -int32_t mgmtInitDClient(); -void mgmtCleanupDClient(); -void mgmtAddDClientRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)); -void mgmtSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg); +void mnodeAddWriteMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg)); +int32_t mnodeProcessRead(SMnodeMsg *pMsg); #ifdef __cplusplus } diff --git a/src/mnode/src/mnodeAcct.c b/src/mnode/src/mnodeAcct.c index dce771fefd..3836bcea52 100644 --- a/src/mnode/src/mnodeAcct.c +++ b/src/mnode/src/mnodeAcct.c @@ -17,7 +17,6 @@ #include "os.h" #include "taoserror.h" #include "ttime.h" -#include "tutil.h" #include "dnode.h" #include "mnodeDef.h" #include "mnodeInt.h" @@ -28,48 +27,48 @@ void * tsAcctSdb = NULL; static int32_t tsAcctUpdateSize; -static void mgmtCreateRootAcct(); +static void mnodeCreateRootAcct(); -static int32_t mgmtActionAcctDestroy(SSdbOper *pOper) { +static int32_t mnodeAcctActionDestroy(SSdbOper *pOper) { SAcctObj *pAcct = pOper->pObj; pthread_mutex_destroy(&pAcct->mutex); tfree(pOper->pObj); return TSDB_CODE_SUCCESS; } -static int32_t mgmtAcctActionInsert(SSdbOper *pOper) { +static int32_t mnodeAcctActionInsert(SSdbOper *pOper) { SAcctObj *pAcct = pOper->pObj; memset(&pAcct->acctInfo, 0, sizeof(SAcctInfo)); pthread_mutex_init(&pAcct->mutex, NULL); return TSDB_CODE_SUCCESS; } -static int32_t mgmtActionAcctDelete(SSdbOper *pOper) { +static int32_t mnodeAcctActionDelete(SSdbOper *pOper) { SAcctObj *pAcct = pOper->pObj; - mgmtDropAllUsers(pAcct); - mgmtDropAllDbs(pAcct); + mnodeDropAllUsers(pAcct); + mnodeDropAllDbs(pAcct); return TSDB_CODE_SUCCESS; } -static int32_t mgmtActionAcctUpdate(SSdbOper *pOper) { +static int32_t mnodeAcctActionUpdate(SSdbOper *pOper) { SAcctObj *pAcct = pOper->pObj; - SAcctObj *pSaved = mgmtGetAcct(pAcct->user); + SAcctObj *pSaved = mnodeGetAcct(pAcct->user); if (pAcct != pSaved) { memcpy(pSaved, pAcct, tsAcctUpdateSize); free(pAcct); } - mgmtDecAcctRef(pSaved); + mnodeDecAcctRef(pSaved); return TSDB_CODE_SUCCESS; } -static int32_t mgmtActionActionEncode(SSdbOper *pOper) { +static int32_t mnodeActionActionEncode(SSdbOper *pOper) { SAcctObj *pAcct = pOper->pObj; memcpy(pOper->rowData, pAcct, tsAcctUpdateSize); pOper->rowSize = tsAcctUpdateSize; return TSDB_CODE_SUCCESS; } -static int32_t mgmtActionAcctDecode(SSdbOper *pOper) { +static int32_t mnodeAcctActionDecode(SSdbOper *pOper) { SAcctObj *pAcct = (SAcctObj *) calloc(1, sizeof(SAcctObj)); if (pAcct == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; @@ -78,16 +77,16 @@ static int32_t mgmtActionAcctDecode(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtActionAcctRestored() { +static int32_t mnodeAcctActionRestored() { if (dnodeIsFirstDeploy()) { - mgmtCreateRootAcct(); + mnodeCreateRootAcct(); } acctInit(); return TSDB_CODE_SUCCESS; } -int32_t mgmtInitAccts() { +int32_t mnodeInitAccts() { SAcctObj tObj; tsAcctUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj; @@ -98,13 +97,13 @@ int32_t mgmtInitAccts() { .maxRowSize = tsAcctUpdateSize, .refCountPos = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj, .keyType = SDB_KEY_STRING, - .insertFp = mgmtAcctActionInsert, - .deleteFp = mgmtActionAcctDelete, - .updateFp = mgmtActionAcctUpdate, - .encodeFp = mgmtActionActionEncode, - .decodeFp = mgmtActionAcctDecode, - .destroyFp = mgmtActionAcctDestroy, - .restoredFp = mgmtActionAcctRestored + .insertFp = mnodeAcctActionInsert, + .deleteFp = mnodeAcctActionDelete, + .updateFp = mnodeAcctActionUpdate, + .encodeFp = mnodeActionActionEncode, + .decodeFp = mnodeAcctActionDecode, + .destroyFp = mnodeAcctActionDestroy, + .restoredFp = mnodeAcctActionRestored }; tsAcctSdb = sdbOpenTable(&tableDesc); @@ -117,52 +116,52 @@ int32_t mgmtInitAccts() { return TSDB_CODE_SUCCESS; } -void mgmtCleanUpAccts() { +void mnodeCleanupAccts() { sdbCloseTable(tsAcctSdb); acctCleanUp(); } -void *mgmtGetAcct(char *name) { +void *mnodeGetAcct(char *name) { return sdbGetRow(tsAcctSdb, name); } -void *mgmtGetNextAcct(void *pIter, SAcctObj **pAcct) { +void *mnodeGetNextAcct(void *pIter, SAcctObj **pAcct) { return sdbFetchRow(tsAcctSdb, pIter, (void **)pAcct); } -void mgmtIncAcctRef(SAcctObj *pAcct) { +void mnodeIncAcctRef(SAcctObj *pAcct) { sdbIncRef(tsAcctSdb, pAcct); } -void mgmtDecAcctRef(SAcctObj *pAcct) { +void mnodeDecAcctRef(SAcctObj *pAcct) { sdbDecRef(tsAcctSdb, pAcct); } -void mgmtAddDbToAcct(SAcctObj *pAcct, SDbObj *pDb) { +void mnodeAddDbToAcct(SAcctObj *pAcct, SDbObj *pDb) { atomic_add_fetch_32(&pAcct->acctInfo.numOfDbs, 1); pDb->pAcct = pAcct; - mgmtIncAcctRef(pAcct); + mnodeIncAcctRef(pAcct); } -void mgmtDropDbFromAcct(SAcctObj *pAcct, SDbObj *pDb) { +void mnodeDropDbFromAcct(SAcctObj *pAcct, SDbObj *pDb) { atomic_sub_fetch_32(&pAcct->acctInfo.numOfDbs, 1); pDb->pAcct = NULL; - mgmtDecAcctRef(pAcct); + mnodeDecAcctRef(pAcct); } -void mgmtAddUserToAcct(SAcctObj *pAcct, SUserObj *pUser) { +void mnodeAddUserToAcct(SAcctObj *pAcct, SUserObj *pUser) { atomic_add_fetch_32(&pAcct->acctInfo.numOfUsers, 1); pUser->pAcct = pAcct; - mgmtIncAcctRef(pAcct); + mnodeIncAcctRef(pAcct); } -void mgmtDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser) { +void mnodeDropUserFromAcct(SAcctObj *pAcct, SUserObj *pUser) { atomic_sub_fetch_32(&pAcct->acctInfo.numOfUsers, 1); pUser->pAcct = NULL; - mgmtDecAcctRef(pAcct); + mnodeDecAcctRef(pAcct); } -static void mgmtCreateRootAcct() { +static void mnodeCreateRootAcct() { int32_t numOfAccts = sdbGetNumOfRows(tsAcctSdb); if (numOfAccts != 0) return; diff --git a/src/mnode/src/mnodeBalance.c b/src/mnode/src/mnodeBalance.c index e70458a3fa..64d3c6d7c7 100644 --- a/src/mnode/src/mnodeBalance.c +++ b/src/mnode/src/mnodeBalance.c @@ -15,22 +15,18 @@ #define _DEFAULT_SOURCE #include "os.h" -#include "trpc.h" -#include "tbalance.h" #include "tglobal.h" #include "mnodeDef.h" #include "mnodeInt.h" -#include "mnodeMnode.h" #include "mnodeDnode.h" #include "mnodeSdb.h" -#include "mnodeVgroup.h" #ifndef _SYNC int32_t balanceInit() { return TSDB_CODE_SUCCESS; } void balanceCleanUp() {} void balanceNotify() {} -void balanceUpdateMgmt() {} +void balanceUpdateMnode() {} void balanceReset() {} int32_t balanceAllocVnodes(SVgObj *pVgroup) { @@ -40,12 +36,12 @@ int32_t balanceAllocVnodes(SVgObj *pVgroup) { float vnodeUsage = 1000.0; while (1) { - pIter = mgmtGetNextDnode(pIter, &pDnode); + pIter = mnodeGetNextDnode(pIter, &pDnode); if (pDnode == NULL) break; if (pDnode->totalVnodes > 0 && pDnode->openVnodes < pDnode->totalVnodes) { float openVnodes = pDnode->openVnodes; - if (pDnode->isMgmt) openVnodes += tsMgmtEqualVnodeNum; + if (pDnode->isMgmt) openVnodes += tsMnodeEqualVnodeNum; float usage = openVnodes / pDnode->totalVnodes; if (usage <= vnodeUsage) { @@ -53,7 +49,7 @@ int32_t balanceAllocVnodes(SVgObj *pVgroup) { vnodeUsage = usage; } } - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); } sdbFreeIter(pIter); diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c index 871ce32c6f..09fd7f5b3e 100644 --- a/src/mnode/src/mnodeDb.c +++ b/src/mnode/src/mnodeDb.c @@ -15,7 +15,6 @@ #define _DEFAULT_SOURCE #include "os.h" - #include "taoserror.h" #include "tutil.h" #include "tgrant.h" @@ -24,15 +23,17 @@ #include "tname.h" #include "tbalance.h" #include "tdataformat.h" +#include "mnode.h" #include "mnodeDef.h" #include "mnodeInt.h" #include "mnodeAcct.h" #include "mnodeDb.h" #include "mnodeDnode.h" #include "mnodeMnode.h" -#include "mnodeShell.h" #include "mnodeProfile.h" +#include "mnodeWrite.h" #include "mnodeSdb.h" +#include "mnodeShow.h" #include "mnodeTable.h" #include "mnodeUser.h" #include "mnodeVgroup.h" @@ -40,23 +41,23 @@ static void * tsDbSdb = NULL; static int32_t tsDbUpdateSize; -static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate); -static void mgmtDropDb(SMnodeMsg *newMsg); -static int32_t mgmtSetDbDropping(SDbObj *pDb); -static int32_t mgmtGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static void mgmtProcessCreateDbMsg(SMnodeMsg *pMsg); -static void mgmtProcessAlterDbMsg(SMnodeMsg *pMsg); -static void mgmtProcessDropDbMsg(SMnodeMsg *pMsg); +static int32_t mnodeCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate); +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 mnodeProcessAlterDbMsg(SMnodeMsg *pMsg); +static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg); -static int32_t mgmtDbActionDestroy(SSdbOper *pOper) { +static int32_t mnodeDbActionDestroy(SSdbOper *pOper) { tfree(pOper->pObj); return TSDB_CODE_SUCCESS; } -static int32_t mgmtDbActionInsert(SSdbOper *pOper) { +static int32_t mnodeDbActionInsert(SSdbOper *pOper) { SDbObj *pDb = pOper->pObj; - SAcctObj *pAcct = mgmtGetAcct(pDb->acct); + SAcctObj *pAcct = mnodeGetAcct(pDb->acct); pDb->pHead = NULL; pDb->pTail = NULL; @@ -65,8 +66,8 @@ static int32_t mgmtDbActionInsert(SSdbOper *pOper) { pDb->numOfSuperTables = 0; if (pAcct != NULL) { - mgmtAddDbToAcct(pAcct, pDb); - mgmtDecAcctRef(pAcct); + mnodeAddDbToAcct(pAcct, pDb); + mnodeDecAcctRef(pAcct); } else { mError("db:%s, acct:%s info not exist in sdb", pDb->name, pDb->acct); @@ -76,39 +77,39 @@ static int32_t mgmtDbActionInsert(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtDbActionDelete(SSdbOper *pOper) { +static int32_t mnodeDbActionDelete(SSdbOper *pOper) { SDbObj *pDb = pOper->pObj; - SAcctObj *pAcct = mgmtGetAcct(pDb->acct); + SAcctObj *pAcct = mnodeGetAcct(pDb->acct); - mgmtDropDbFromAcct(pAcct, pDb); - mgmtDropAllChildTables(pDb); - mgmtDropAllSuperTables(pDb); - mgmtDropAllDbVgroups(pDb, false); - mgmtDecAcctRef(pAcct); + mnodeDropDbFromAcct(pAcct, pDb); + mnodeDropAllChildTables(pDb); + mnodeDropAllSuperTables(pDb); + mnodeDropAllDbVgroups(pDb, false); + mnodeDecAcctRef(pAcct); return TSDB_CODE_SUCCESS; } -static int32_t mgmtDbActionUpdate(SSdbOper *pOper) { +static int32_t mnodeDbActionUpdate(SSdbOper *pOper) { SDbObj *pDb = pOper->pObj; - SDbObj *pSaved = mgmtGetDb(pDb->name); + SDbObj *pSaved = mnodeGetDb(pDb->name); if (pDb != pSaved) { memcpy(pSaved, pDb, pOper->rowSize); free(pDb); } - mgmtUpdateAllDbVgroups(pSaved); - mgmtDecDbRef(pSaved); + mnodeUpdateAllDbVgroups(pSaved); + mnodeDecDbRef(pSaved); return TSDB_CODE_SUCCESS; } -static int32_t mgmtDbActionEncode(SSdbOper *pOper) { +static int32_t mnodeDbActionEncode(SSdbOper *pOper) { SDbObj *pDb = pOper->pObj; memcpy(pOper->rowData, pDb, tsDbUpdateSize); pOper->rowSize = tsDbUpdateSize; return TSDB_CODE_SUCCESS; } -static int32_t mgmtDbActionDecode(SSdbOper *pOper) { +static int32_t mnodeDbActionDecode(SSdbOper *pOper) { SDbObj *pDb = (SDbObj *) calloc(1, sizeof(SDbObj)); if (pDb == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; @@ -117,11 +118,11 @@ static int32_t mgmtDbActionDecode(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtDbActionRestored() { +static int32_t mnodeDbActionRestored() { return 0; } -int32_t mgmtInitDbs() { +int32_t mnodeInitDbs() { SDbObj tObj; tsDbUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj; @@ -132,13 +133,13 @@ int32_t mgmtInitDbs() { .maxRowSize = tsDbUpdateSize, .refCountPos = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj, .keyType = SDB_KEY_STRING, - .insertFp = mgmtDbActionInsert, - .deleteFp = mgmtDbActionDelete, - .updateFp = mgmtDbActionUpdate, - .encodeFp = mgmtDbActionEncode, - .decodeFp = mgmtDbActionDecode, - .destroyFp = mgmtDbActionDestroy, - .restoredFp = mgmtDbActionRestored + .insertFp = mnodeDbActionInsert, + .deleteFp = mnodeDbActionDelete, + .updateFp = mnodeDbActionUpdate, + .encodeFp = mnodeDbActionEncode, + .decodeFp = mnodeDbActionDecode, + .destroyFp = mnodeDbActionDestroy, + .restoredFp = mnodeDbActionRestored }; tsDbSdb = sdbOpenTable(&tableDesc); @@ -147,33 +148,33 @@ int32_t mgmtInitDbs() { return -1; } - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DB, mgmtProcessCreateDbMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_ALTER_DB, mgmtProcessAlterDbMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_DROP_DB, mgmtProcessDropDbMsg); - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_DB, mgmtGetDbMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_DB, mgmtRetrieveDbs); + mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DB, mnodeProcessCreateDbMsg); + mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_ALTER_DB, mnodeProcessAlterDbMsg); + mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_DB, mnodeProcessDropDbMsg); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DB, mnodeGetDbMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DB, mnodeRetrieveDbs); mTrace("table:dbs table is created"); return 0; } -void *mgmtGetNextDb(void *pIter, SDbObj **pDb) { +void *mnodeGetNextDb(void *pIter, SDbObj **pDb) { return sdbFetchRow(tsDbSdb, pIter, (void **)pDb); } -SDbObj *mgmtGetDb(char *db) { +SDbObj *mnodeGetDb(char *db) { return (SDbObj *)sdbGetRow(tsDbSdb, db); } -void mgmtIncDbRef(SDbObj *pDb) { +void mnodeIncDbRef(SDbObj *pDb) { return sdbIncRef(tsDbSdb, pDb); } -void mgmtDecDbRef(SDbObj *pDb) { +void mnodeDecDbRef(SDbObj *pDb) { return sdbDecRef(tsDbSdb, pDb); } -SDbObj *mgmtGetDbByTableId(char *tableId) { +SDbObj *mnodeGetDbByTableId(char *tableId) { char db[TSDB_TABLE_ID_LEN], *pos; pos = strstr(tableId, TS_PATH_DELIMITER); @@ -181,10 +182,10 @@ SDbObj *mgmtGetDbByTableId(char *tableId) { memset(db, 0, sizeof(db)); strncpy(db, tableId, pos - tableId); - return mgmtGetDb(db); + return mnodeGetDb(db); } -static int32_t mgmtCheckDbCfg(SDbCfg *pCfg) { +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); @@ -290,7 +291,7 @@ static int32_t mgmtCheckDbCfg(SDbCfg *pCfg) { return TSDB_CODE_SUCCESS; } -static void mgmtSetDefaultDbCfg(SDbCfg *pCfg) { +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; @@ -307,13 +308,13 @@ static void mgmtSetDefaultDbCfg(SDbCfg *pCfg) { if (pCfg->replications < 0) pCfg->replications = tsReplications; } -static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) { +static int32_t mnodeCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) { int32_t code = acctCheck(pAcct, ACCT_GRANT_DB); if (code != 0) return code; - SDbObj *pDb = mgmtGetDb(pCreate->db); + SDbObj *pDb = mnodeGetDb(pCreate->db); if (pDb != NULL) { - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); if (pCreate->ignoreExist) { mTrace("db:%s, already exist, ignore exist is set", pCreate->db); return TSDB_CODE_SUCCESS; @@ -347,9 +348,9 @@ static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) { .replications = pCreate->replications }; - mgmtSetDefaultDbCfg(&pDb->cfg); + mnodeSetDefaultDbCfg(&pDb->cfg); - code = mgmtCheckDbCfg(&pDb->cfg); + code = mnodeCheckDbCfg(&pDb->cfg); if (code != TSDB_CODE_SUCCESS) { tfree(pDb); return code; @@ -371,7 +372,7 @@ static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) { return code; } -bool mgmtCheckIsMonitorDB(char *db, char *monitordb) { +bool mnodeCheckIsMonitorDB(char *db, char *monitordb) { char dbName[TSDB_DB_NAME_LEN + 1] = {0}; extractDBName(db, dbName); @@ -397,7 +398,7 @@ void mgmtPrintVgroups(SDbObj *pDb, char *oper) { } #endif -void mgmtAddVgroupIntoDb(SVgObj *pVgroup) { +void mnodeAddVgroupIntoDb(SVgObj *pVgroup) { SDbObj *pDb = pVgroup->pDb; pVgroup->next = pDb->pHead; @@ -410,7 +411,7 @@ void mgmtAddVgroupIntoDb(SVgObj *pVgroup) { pDb->numOfVgroups++; } -void mgmtAddVgroupIntoDbTail(SVgObj *pVgroup) { +void mnodeAddVgroupIntoDbTail(SVgObj *pVgroup) { SDbObj *pDb = pVgroup->pDb; pVgroup->next = NULL; pVgroup->prev = pDb->pTail; @@ -422,7 +423,7 @@ void mgmtAddVgroupIntoDbTail(SVgObj *pVgroup) { pDb->numOfVgroups++; } -void mgmtRemoveVgroupFromDb(SVgObj *pVgroup) { +void mnodeRemoveVgroupFromDb(SVgObj *pVgroup) { SDbObj *pDb = pVgroup->pDb; if (pVgroup->prev) pVgroup->prev->next = pVgroup->next; if (pVgroup->next) pVgroup->next->prev = pVgroup->prev; @@ -431,25 +432,25 @@ void mgmtRemoveVgroupFromDb(SVgObj *pVgroup) { pDb->numOfVgroups--; } -void mgmtMoveVgroupToTail(SVgObj *pVgroup) { - mgmtRemoveVgroupFromDb(pVgroup); - mgmtAddVgroupIntoDbTail(pVgroup); +void mnodeMoveVgroupToTail(SVgObj *pVgroup) { + mnodeRemoveVgroupFromDb(pVgroup); + mnodeAddVgroupIntoDbTail(pVgroup); } -void mgmtMoveVgroupToHead(SVgObj *pVgroup) { - mgmtRemoveVgroupFromDb(pVgroup); - mgmtAddVgroupIntoDb(pVgroup); +void mnodeMoveVgroupToHead(SVgObj *pVgroup) { + mnodeRemoveVgroupFromDb(pVgroup); + mnodeAddVgroupIntoDb(pVgroup); } -void mgmtCleanUpDbs() { +void mnodeCleanupDbs() { sdbCloseTable(tsDbSdb); } -static int32_t mgmtGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { +static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { int32_t cols = 0; SSchema *pSchema = pMeta->schema; - SUserObj *pUser = mgmtGetUserFromConn(pConn); + SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) return 0; pShow->bytes[cols] = TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE; @@ -583,32 +584,32 @@ static int32_t mgmtGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; pShow->numOfRows = pUser->pAcct->acctInfo.numOfDbs; - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return 0; } -static char *mgmtGetDbStr(char *src) { +static char *mnodeGetDbStr(char *src) { char *pos = strstr(src, TS_PATH_DELIMITER); return ++pos; } -static int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +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 = mgmtGetUserFromConn(pConn); + SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) return 0; while (numOfRows < rows) { - pShow->pIter = mgmtGetNextDb(pShow->pIter, &pDb); + pShow->pIter = mnodeGetNextDb(pShow->pIter, &pDb); if (pDb == NULL) break; cols = 0; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - char* name = mgmtGetDbStr(pDb->name); + char* name = mnodeGetDbStr(pDb->name); STR_WITH_MAXSIZE_TO_VARSTR(pWrite, name, TSDB_DB_NAME_LEN); cols++; @@ -706,31 +707,31 @@ static int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void * cols++; numOfRows++; - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); } pShow->numOfReads += numOfRows; - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return numOfRows; } -void mgmtAddSuperTableIntoDb(SDbObj *pDb) { +void mnodeAddSuperTableIntoDb(SDbObj *pDb) { atomic_add_fetch_32(&pDb->numOfSuperTables, 1); } -void mgmtRemoveSuperTableFromDb(SDbObj *pDb) { +void mnodeRemoveSuperTableFromDb(SDbObj *pDb) { atomic_add_fetch_32(&pDb->numOfSuperTables, -1); } -void mgmtAddTableIntoDb(SDbObj *pDb) { +void mnodeAddTableIntoDb(SDbObj *pDb) { atomic_add_fetch_32(&pDb->numOfTables, 1); } -void mgmtRemoveTableFromDb(SDbObj *pDb) { +void mnodeRemoveTableFromDb(SDbObj *pDb) { atomic_add_fetch_32(&pDb->numOfTables, -1); } -static int32_t mgmtSetDbDropping(SDbObj *pDb) { +static int32_t mnodeSetDbDropping(SDbObj *pDb) { if (pDb->status) return TSDB_CODE_SUCCESS; pDb->status = true; @@ -748,7 +749,7 @@ static int32_t mgmtSetDbDropping(SDbObj *pDb) { return code; } -static void mgmtProcessCreateDbMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg) { SCMCreateDbMsg *pCreate = pMsg->pCont; pCreate->maxTables = htonl(pCreate->maxTables); @@ -768,7 +769,7 @@ static void mgmtProcessCreateDbMsg(SMnodeMsg *pMsg) { } else if (!pMsg->pUser->writeAuth) { code = TSDB_CODE_NO_RIGHTS; } else { - code = mgmtCreateDb(pMsg->pUser->pAcct, pCreate); + code = mnodeCreateDb(pMsg->pUser->pAcct, pCreate); if (code == TSDB_CODE_SUCCESS) { mLPrint("db:%s, is created by %s", pCreate->db, pMsg->pUser->user); } else { @@ -776,10 +777,10 @@ static void mgmtProcessCreateDbMsg(SMnodeMsg *pMsg) { } } - mgmtSendSimpleResp(pMsg->thandle, code); + return code; } -static SDbCfg mgmtGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) { +static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) { SDbCfg newCfg = pDb->cfg; int32_t maxTables = htonl(pAlter->maxTables); int32_t cacheBlockSize = htonl(pAlter->cacheBlockSize); @@ -876,7 +877,7 @@ static SDbCfg mgmtGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) { terrno = TSDB_CODE_INVALID_OPTION; } - if (replications > mgmtGetDnodesNum()) { + if (replications > mnodeGetDnodesNum()) { mError("db:%s, no enough dnode to change replica:%d", pDb->name, replications); terrno = TSDB_CODE_NO_ENOUGH_DNODES; } @@ -890,13 +891,13 @@ static SDbCfg mgmtGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) { return newCfg; } -static int32_t mgmtAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) { - SDbCfg newCfg = mgmtGetAlterDbOption(pDb, pAlter); +static int32_t mnodeAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) { + SDbCfg newCfg = mnodeGetAlterDbOption(pDb, pAlter); if (terrno != TSDB_CODE_SUCCESS) { return terrno; } - int32_t code = mgmtCheckDbCfg(&newCfg); + int32_t code = mnodeCheckDbCfg(&newCfg); if (code != TSDB_CODE_SUCCESS) { return code; } @@ -921,10 +922,10 @@ static int32_t mgmtAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) { void *pIter = NULL; while (1) { SVgObj *pVgroup = NULL; - pIter = mgmtGetNextVgroup(pIter, &pVgroup); + pIter = mnodeGetNextVgroup(pIter, &pVgroup); if (pVgroup == NULL) break; - mgmtSendCreateVgroupMsg(pVgroup, NULL); - mgmtDecVgroupRef(pVgroup); + mnodeSendCreateVgroupMsg(pVgroup, NULL); + mnodeDecVgroupRef(pVgroup); } sdbFreeIter(pIter); @@ -935,35 +936,27 @@ static int32_t mgmtAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) { return TSDB_CODE_SUCCESS; } -static void mgmtProcessAlterDbMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg) { SCMAlterDbMsg *pAlter = pMsg->pCont; mTrace("db:%s, alter db msg is received from thandle:%p", pAlter->db, pMsg->thandle); - if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) { - mError("db:%s, failed to alter, grant expired", pAlter->db); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_GRANT_EXPIRED); - return; - } - - if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDb(pAlter->db); + if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pAlter->db); if (pMsg->pDb == NULL) { mError("db:%s, failed to alter, invalid db", pAlter->db); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_DB); - return; + return TSDB_CODE_INVALID_DB; } - int32_t code = mgmtAlterDb(pMsg->pDb, pAlter); + int32_t code = mnodeAlterDb(pMsg->pDb, pAlter); if (code != TSDB_CODE_SUCCESS) { mError("db:%s, failed to alter, invalid db option", pAlter->db); - mgmtSendSimpleResp(pMsg->thandle, code); - return; + return code; } mTrace("db:%s, all vgroups is altered", pMsg->pDb->name); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SUCCESS); + return TSDB_CODE_SUCCESS; } -static void mgmtDropDb(SMnodeMsg *pMsg) { +static int32_t mnodeDropDb(SMnodeMsg *pMsg) { SDbObj *pDb = pMsg->pDb; mPrint("db:%s, drop db from sdb", pDb->name); @@ -977,64 +970,54 @@ static void mgmtDropDb(SMnodeMsg *pMsg) { code = TSDB_CODE_SDB_ERROR; } - mgmtSendSimpleResp(pMsg->thandle, code); + return code; } -static void mgmtProcessDropDbMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg) { SCMDropDbMsg *pDrop = pMsg->pCont; mTrace("db:%s, drop db msg is received from thandle:%p", pDrop->db, pMsg->thandle); - if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) { - mError("db:%s, failed to drop, grant expired", pDrop->db); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_GRANT_EXPIRED); - return; - } - - if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDb(pDrop->db); + if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pDrop->db); if (pMsg->pDb == NULL) { if (pDrop->ignoreNotExists) { mTrace("db:%s, db is not exist, think drop success", pDrop->db); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SUCCESS); - return; + return TSDB_CODE_SUCCESS; } else { mError("db:%s, failed to drop, invalid db", pDrop->db); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_DB); - return; + return TSDB_CODE_INVALID_DB; } } - if (mgmtCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) { + if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) { mError("db:%s, can't drop monitor database", pDrop->db); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_MONITOR_DB_FORBIDDEN); - return; + return TSDB_CODE_MONITOR_DB_FORBIDDEN; } - int32_t code = mgmtSetDbDropping(pMsg->pDb); + int32_t code = mnodeSetDbDropping(pMsg->pDb); if (code != TSDB_CODE_SUCCESS) { mError("db:%s, failed to drop, reason:%s", pDrop->db, tstrerror(code)); - mgmtSendSimpleResp(pMsg->thandle, code); - return; + return code; } #if 1 - mgmtDropAllDbVgroups(pMsg->pDb, true); + mnodeDropAllDbVgroups(pMsg->pDb, true); #else SVgObj *pVgroup = pMsg->pDb->pHead; if (pVgroup != NULL) { mPrint("vgId:%d, will be dropped", pVgroup->vgId); - SMnodeMsg *newMsg = mgmtCloneQueuedMsg(pMsg); + SMnodeMsg *newMsg = mnodeCloneMsg(pMsg); newMsg->ahandle = pVgroup; newMsg->expected = pVgroup->numOfVnodes; - mgmtDropVgroup(pVgroup, newMsg); + mnodeDropVgroup(pVgroup, newMsg); return; } #endif mTrace("db:%s, all vgroups is dropped", pMsg->pDb->name); - mgmtDropDb(pMsg); + return mnodeDropDb(pMsg); } -void mgmtDropAllDbs(SAcctObj *pAcct) { +void mnodeDropAllDbs(SAcctObj *pAcct) { int32_t numOfDbs = 0; SDbObj *pDb = NULL; void * pIter = NULL; @@ -1042,7 +1025,7 @@ void mgmtDropAllDbs(SAcctObj *pAcct) { mPrint("acct:%s, all dbs will be dropped from sdb", pAcct->user); while (1) { - pIter = mgmtGetNextDb(pIter, &pDb); + pIter = mnodeGetNextDb(pIter, &pDb); if (pDb == NULL) break; if (pDb->pAcct == pAcct) { @@ -1056,7 +1039,7 @@ void mgmtDropAllDbs(SAcctObj *pAcct) { sdbDeleteRow(&oper); numOfDbs++; } - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); } sdbFreeIter(pIter); diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c index 5715554935..57ce07dbcf 100644 --- a/src/mnode/src/mnodeDnode.c +++ b/src/mnode/src/mnodeDnode.c @@ -25,15 +25,18 @@ #include "tbalance.h" #include "tsync.h" #include "tdataformat.h" +#include "mnode.h" #include "dnode.h" #include "mnodeDef.h" #include "mnodeInt.h" #include "mnodeDnode.h" #include "mnodeMnode.h" #include "mnodeSdb.h" -#include "mnodeShell.h" +#include "mnodeShow.h" #include "mnodeUser.h" #include "mnodeVgroup.h" +#include "mnodeWrite.h" +#include "mnodePeer.h" int32_t tsAccessSquence = 0; static void *tsDnodeSdb = NULL; @@ -41,27 +44,27 @@ static int32_t tsDnodeUpdateSize = 0; extern void * tsMnodeSdb; extern void * tsVgroupSdb; -static int32_t mgmtCreateDnode(char *ep); -static void mgmtProcessCreateDnodeMsg(SMnodeMsg *pMsg); -static void mgmtProcessDropDnodeMsg(SMnodeMsg *pMsg); -static void mgmtProcessCfgDnodeMsg(SMnodeMsg *pMsg); -static void mgmtProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) ; -static void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg); -static int32_t mgmtGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static int32_t mgmtGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static int32_t mgmtGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static int32_t mgmtGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn); +static int32_t mnodeCreateDnode(char *ep); +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 *rpcMsg); +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 int32_t mgmtDnodeActionDestroy(SSdbOper *pOper) { +static int32_t mnodeDnodeActionDestroy(SSdbOper *pOper) { tfree(pOper->pObj); return TSDB_CODE_SUCCESS; } -static int32_t mgmtDnodeActionInsert(SSdbOper *pOper) { +static int32_t mnodeDnodeActionInsert(SSdbOper *pOper) { SDnodeObj *pDnode = pOper->pObj; if (pDnode->status != TAOS_DN_STATUS_DROPPING) { pDnode->status = TAOS_DN_STATUS_OFFLINE; @@ -70,38 +73,38 @@ static int32_t mgmtDnodeActionInsert(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtDnodeActionDelete(SSdbOper *pOper) { +static int32_t mnodeDnodeActionDelete(SSdbOper *pOper) { SDnodeObj *pDnode = pOper->pObj; #ifndef _SYNC - mgmtDropAllDnodeVgroups(pDnode); + mnodeDropAllDnodeVgroups(pDnode); #endif - mgmtDropMnodeLocal(pDnode->dnodeId); + mnodeDropMnodeLocal(pDnode->dnodeId); balanceNotify(); mTrace("dnode:%d, all vgroups is dropped from sdb", pDnode->dnodeId); return TSDB_CODE_SUCCESS; } -static int32_t mgmtDnodeActionUpdate(SSdbOper *pOper) { +static int32_t mnodeDnodeActionUpdate(SSdbOper *pOper) { SDnodeObj *pDnode = pOper->pObj; - SDnodeObj *pSaved = mgmtGetDnode(pDnode->dnodeId); + SDnodeObj *pSaved = mnodeGetDnode(pDnode->dnodeId); if (pDnode != pSaved) { memcpy(pSaved, pDnode, pOper->rowSize); free(pDnode); } - mgmtDecDnodeRef(pSaved); + mnodeDecDnodeRef(pSaved); return TSDB_CODE_SUCCESS; } -static int32_t mgmtDnodeActionEncode(SSdbOper *pOper) { +static int32_t mnodeDnodeActionEncode(SSdbOper *pOper) { SDnodeObj *pDnode = pOper->pObj; memcpy(pOper->rowData, pDnode, tsDnodeUpdateSize); pOper->rowSize = tsDnodeUpdateSize; return TSDB_CODE_SUCCESS; } -static int32_t mgmtDnodeActionDecode(SSdbOper *pOper) { +static int32_t mnodeDnodeActionDecode(SSdbOper *pOper) { SDnodeObj *pDnode = (SDnodeObj *) calloc(1, sizeof(SDnodeObj)); if (pDnode == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; @@ -110,19 +113,19 @@ static int32_t mgmtDnodeActionDecode(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtDnodeActionRestored() { +static int32_t mnodeDnodeActionRestored() { int32_t numOfRows = sdbGetNumOfRows(tsDnodeSdb); if (numOfRows <= 0 && dnodeIsFirstDeploy()) { - mgmtCreateDnode(tsLocalEp); - SDnodeObj *pDnode = mgmtGetDnodeByEp(tsLocalEp); - mgmtAddMnode(pDnode->dnodeId); - mgmtDecDnodeRef(pDnode); + mnodeCreateDnode(tsLocalEp); + SDnodeObj *pDnode = mnodeGetDnodeByEp(tsLocalEp); + mnodeAddMnode(pDnode->dnodeId); + mnodeDecDnodeRef(pDnode); } return TSDB_CODE_SUCCESS; } -int32_t mgmtInitDnodes() { +int32_t mnodeInitDnodes() { SDnodeObj tObj; tsDnodeUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj; @@ -133,13 +136,13 @@ int32_t mgmtInitDnodes() { .maxRowSize = tsDnodeUpdateSize, .refCountPos = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj, .keyType = SDB_KEY_AUTO, - .insertFp = mgmtDnodeActionInsert, - .deleteFp = mgmtDnodeActionDelete, - .updateFp = mgmtDnodeActionUpdate, - .encodeFp = mgmtDnodeActionEncode, - .decodeFp = mgmtDnodeActionDecode, - .destroyFp = mgmtDnodeActionDestroy, - .restoredFp = mgmtDnodeActionRestored + .insertFp = mnodeDnodeActionInsert, + .deleteFp = mnodeDnodeActionDelete, + .updateFp = mnodeDnodeActionUpdate, + .encodeFp = mnodeDnodeActionEncode, + .decodeFp = mnodeDnodeActionDecode, + .destroyFp = mnodeDnodeActionDestroy, + .restoredFp = mnodeDnodeActionRestored }; tsDnodeSdb = sdbOpenTable(&tableDesc); @@ -148,19 +151,19 @@ int32_t mgmtInitDnodes() { return -1; } - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_DNODE, mgmtProcessCreateDnodeMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_DROP_DNODE, mgmtProcessDropDnodeMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CONFIG_DNODE, mgmtProcessCfgDnodeMsg); - dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_CONFIG_DNODE_RSP, mgmtProcessCfgDnodeMsgRsp); - dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_STATUS, mgmtProcessDnodeStatusMsg); - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_MODULE, mgmtGetModuleMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_MODULE, mgmtRetrieveModules); - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_CONFIGS, mgmtGetConfigMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_CONFIGS, mgmtRetrieveConfigs); - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_VNODES, mgmtGetVnodeMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_VNODES, mgmtRetrieveVnodes); - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_DNODE, mgmtGetDnodeMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_DNODE, mgmtRetrieveDnodes); + 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_CONFIGS, mnodeGetConfigMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONFIGS, mnodeRetrieveConfigs); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VNODES, mnodeGetVnodeMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VNODES, mnodeRetrieveVnodes); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_DNODE, mnodeGetDnodeMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_DNODE, mnodeRetrieveDnodes); mTrace("table:dnodes table is created"); return 0; @@ -170,24 +173,24 @@ void mgmtCleanupDnodes() { sdbCloseTable(tsDnodeSdb); } -void *mgmtGetNextDnode(void *pIter, SDnodeObj **pDnode) { +void *mnodeGetNextDnode(void *pIter, SDnodeObj **pDnode) { return sdbFetchRow(tsDnodeSdb, pIter, (void **)pDnode); } -int32_t mgmtGetDnodesNum() { +int32_t mnodeGetDnodesNum() { return sdbGetNumOfRows(tsDnodeSdb); } -int32_t mgmtGetOnlinDnodesNum(char *ep) { +int32_t mnodeGetOnlinDnodesNum(char *ep) { SDnodeObj *pDnode = NULL; void * pIter = NULL; int32_t onlineDnodes = 0; while (1) { - pIter = mgmtGetNextDnode(pIter, &pDnode); + pIter = mnodeGetNextDnode(pIter, &pDnode); if (pDnode == NULL) break; if (pDnode->status != TAOS_DN_STATUS_OFFLINE) onlineDnodes++; - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); } sdbFreeIter(pIter); @@ -195,22 +198,22 @@ int32_t mgmtGetOnlinDnodesNum(char *ep) { return onlineDnodes; } -void *mgmtGetDnode(int32_t dnodeId) { +void *mnodeGetDnode(int32_t dnodeId) { return sdbGetRow(tsDnodeSdb, &dnodeId); } -void *mgmtGetDnodeByEp(char *ep) { +void *mnodeGetDnodeByEp(char *ep) { SDnodeObj *pDnode = NULL; void * pIter = NULL; while (1) { - pIter = mgmtGetNextDnode(pIter, &pDnode); + pIter = mnodeGetNextDnode(pIter, &pDnode); if (pDnode == NULL) break; if (strcmp(ep, pDnode->dnodeEp) == 0) { sdbFreeIter(pIter); return pDnode; } - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); } sdbFreeIter(pIter); @@ -218,15 +221,15 @@ void *mgmtGetDnodeByEp(char *ep) { return NULL; } -void mgmtIncDnodeRef(SDnodeObj *pDnode) { +void mnodeIncDnodeRef(SDnodeObj *pDnode) { sdbIncRef(tsDnodeSdb, pDnode); } -void mgmtDecDnodeRef(SDnodeObj *pDnode) { +void mnodeDecDnodeRef(SDnodeObj *pDnode) { sdbDecRef(tsDnodeSdb, pDnode); } -void mgmtUpdateDnode(SDnodeObj *pDnode) { +void mnodeUpdateDnode(SDnodeObj *pDnode) { SSdbOper oper = { .type = SDB_OPER_GLOBAL, .table = tsDnodeSdb, @@ -236,9 +239,7 @@ void mgmtUpdateDnode(SDnodeObj *pDnode) { sdbUpdateRow(&oper); } -void mgmtProcessCfgDnodeMsg(SMnodeMsg *pMsg) { - SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; - +static int32_t mnodeProcessCfgDnodeMsg(SMnodeMsg *pMsg) { SCMCfgDnodeMsg *pCmCfgDnode = pMsg->pCont; if (pCmCfgDnode->ep[0] == 0) { strcpy(pCmCfgDnode->ep, tsLocalEp); @@ -247,36 +248,34 @@ void mgmtProcessCfgDnodeMsg(SMnodeMsg *pMsg) { } if (strcmp(pMsg->pUser->user, "root") != 0) { - rpcRsp.code = TSDB_CODE_NO_RIGHTS; - } else { - SRpcIpSet ipSet = mgmtGetIpSetFromIp(pCmCfgDnode->ep); - SMDCfgDnodeMsg *pMdCfgDnode = rpcMallocCont(sizeof(SMDCfgDnodeMsg)); - strcpy(pMdCfgDnode->ep, pCmCfgDnode->ep); - strcpy(pMdCfgDnode->config, pCmCfgDnode->config); - SRpcMsg rpcMdCfgDnodeMsg = { - .handle = 0, - .code = 0, - .msgType = TSDB_MSG_TYPE_MD_CONFIG_DNODE, - .pCont = pMdCfgDnode, - .contLen = sizeof(SMDCfgDnodeMsg) - }; - dnodeSendMsgToDnode(&ipSet, &rpcMdCfgDnodeMsg); - rpcRsp.code = TSDB_CODE_SUCCESS; + return TSDB_CODE_NO_RIGHTS; } - if (rpcRsp.code == TSDB_CODE_SUCCESS) { - mPrint("dnode:%s, is configured by %s", pCmCfgDnode->ep, pMsg->pUser->user); - } + SRpcIpSet ipSet = mnodeGetIpSetFromIp(pCmCfgDnode->ep); + SMDCfgDnodeMsg *pMdCfgDnode = rpcMallocCont(sizeof(SMDCfgDnodeMsg)); + strcpy(pMdCfgDnode->ep, pCmCfgDnode->ep); + strcpy(pMdCfgDnode->config, pCmCfgDnode->config); - rpcSendResponse(&rpcRsp); + SRpcMsg rpcMdCfgDnodeMsg = { + .handle = 0, + .code = 0, + .msgType = TSDB_MSG_TYPE_MD_CONFIG_DNODE, + .pCont = pMdCfgDnode, + .contLen = sizeof(SMDCfgDnodeMsg) + }; + dnodeSendMsgToDnode(&ipSet, &rpcMdCfgDnodeMsg); + + mPrint("dnode:%s, is configured by %s", pCmCfgDnode->ep, pMsg->pUser->user); + + return TSDB_CODE_SUCCESS; } -static void mgmtProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) { +static void mnodeProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) { mPrint("cfg dnode rsp is received"); } -void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) { - SDMStatusMsg *pStatus = rpcMsg->pCont; +static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg) { + SDMStatusMsg *pStatus = pMsg->pCont; pStatus->dnodeId = htonl(pStatus->dnodeId); pStatus->moduleStatus = htonl(pStatus->moduleStatus); pStatus->lastReboot = htonl(pStatus->lastReboot); @@ -286,24 +285,21 @@ void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) { uint32_t version = htonl(pStatus->version); if (version != tsVersion) { mError("status msg version:%d not equal with mnode:%d", version, tsVersion); - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_INVALID_MSG_VERSION); - return ; + return TSDB_CODE_INVALID_MSG_VERSION; } SDnodeObj *pDnode = NULL; if (pStatus->dnodeId == 0) { - pDnode = mgmtGetDnodeByEp(pStatus->dnodeEp); + pDnode = mnodeGetDnodeByEp(pStatus->dnodeEp); if (pDnode == NULL) { mTrace("dnode %s not created", pStatus->dnodeEp); - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_DNODE_NOT_EXIST); - return; + return TSDB_CODE_DNODE_NOT_EXIST; } } else { - pDnode = mgmtGetDnode(pStatus->dnodeId); + pDnode = mnodeGetDnode(pStatus->dnodeId); if (pDnode == NULL) { mError("dnode id:%d, %s not exist", pStatus->dnodeId, pStatus->dnodeEp); - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_DNODE_NOT_EXIST); - return; + return TSDB_CODE_DNODE_NOT_EXIST; } } @@ -327,34 +323,33 @@ void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) { pVload->vgId = htonl(pVload->vgId); pVload->cfgVersion = htonl(pVload->cfgVersion); - SVgObj *pVgroup = mgmtGetVgroup(pVload->vgId); + SVgObj *pVgroup = mnodeGetVgroup(pVload->vgId); if (pVgroup == NULL) { - SRpcIpSet ipSet = mgmtGetIpSetFromIp(pDnode->dnodeEp); + SRpcIpSet ipSet = mnodeGetIpSetFromIp(pDnode->dnodeEp); mPrint("dnode:%d, vgId:%d not exist in mnode, drop it", pDnode->dnodeId, pVload->vgId); - mgmtSendDropVnodeMsg(pVload->vgId, &ipSet, NULL); + mnodeSendDropVnodeMsg(pVload->vgId, &ipSet, NULL); } else { - mgmtUpdateVgroupStatus(pVgroup, pDnode, pVload); - mgmtDecVgroupRef(pVgroup); + mnodeUpdateVgroupStatus(pVgroup, pDnode, pVload); + mnodeDecVgroupRef(pVgroup); } } if (pDnode->status == TAOS_DN_STATUS_OFFLINE) { mTrace("dnode:%d, from offline to online", pDnode->dnodeId); pDnode->status = TAOS_DN_STATUS_READY; - balanceUpdateMgmt(); + balanceUpdateMnode(); balanceNotify(); } - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); int32_t contLen = sizeof(SDMStatusRsp) + TSDB_MAX_VNODES * sizeof(SDMVgroupAccess); SDMStatusRsp *pRsp = rpcMallocCont(contLen); if (pRsp == NULL) { - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_SERV_OUT_OF_MEMORY); - return; + return TSDB_CODE_SERV_OUT_OF_MEMORY; } - mgmtGetMnodeInfos(&pRsp->mnodes); + mnodeGetMnodeInfos(&pRsp->mnodes); pRsp->dnodeCfg.dnodeId = htonl(pDnode->dnodeId); pRsp->dnodeCfg.moduleStatus = htonl((int32_t)pDnode->isMgmt); @@ -364,25 +359,21 @@ void mgmtProcessDnodeStatusMsg(SRpcMsg *rpcMsg) { //TODO: set vnode access - SRpcMsg rpcRsp = { - .handle = rpcMsg->handle, - .code = TSDB_CODE_SUCCESS, - .pCont = pRsp, - .contLen = contLen - }; + pMsg->rpcRsp.len = contLen; + pMsg->rpcRsp.rsp = pRsp; - rpcSendResponse(&rpcRsp); + return TSDB_CODE_SUCCESS; } -static int32_t mgmtCreateDnode(char *ep) { +static int32_t mnodeCreateDnode(char *ep) { int32_t grantCode = grantCheck(TSDB_GRANT_DNODE); if (grantCode != TSDB_CODE_SUCCESS) { return grantCode; } - SDnodeObj *pDnode = mgmtGetDnodeByEp(ep); + SDnodeObj *pDnode = mnodeGetDnodeByEp(ep); if (pDnode != NULL) { - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); mError("dnode:%d is alredy exist, %s:%d", pDnode->dnodeId, pDnode->dnodeFqdn, pDnode->dnodePort); return TSDB_CODE_DNODE_ALREADY_EXIST; } @@ -413,7 +404,7 @@ static int32_t mgmtCreateDnode(char *ep) { return code; } -int32_t mgmtDropDnode(SDnodeObj *pDnode) { +int32_t mnodeDropDnode(SDnodeObj *pDnode) { SSdbOper oper = { .type = SDB_OPER_GLOBAL, .table = tsDnodeSdb, @@ -429,15 +420,14 @@ int32_t mgmtDropDnode(SDnodeObj *pDnode) { return code; } -static int32_t mgmtDropDnodeByEp(char *ep) { - - SDnodeObj *pDnode = mgmtGetDnodeByEp(ep); +static int32_t mnodeDropDnodeByEp(char *ep) { + SDnodeObj *pDnode = mnodeGetDnodeByEp(ep); if (pDnode == NULL) { mError("dnode:%s, is not exist", ep); return TSDB_CODE_DNODE_NOT_EXIST; } - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); if (strcmp(pDnode->dnodeEp, dnodeGetMnodeMasterEp()) == 0) { mError("dnode:%d, can't drop dnode:%s which is master", pDnode->dnodeId, ep); return TSDB_CODE_NO_REMOVE_MASTER; @@ -445,58 +435,56 @@ static int32_t mgmtDropDnodeByEp(char *ep) { mPrint("dnode:%d, start to drop it", pDnode->dnodeId); #ifndef _SYNC - return mgmtDropDnode(pDnode); + return mnodeDropDnode(pDnode); #else return balanceDropDnode(pDnode); #endif } -static void mgmtProcessCreateDnodeMsg(SMnodeMsg *pMsg) { - SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; - +static int32_t mnodeProcessCreateDnodeMsg(SMnodeMsg *pMsg) { SCMCreateDnodeMsg *pCreate = pMsg->pCont; if (strcmp(pMsg->pUser->user, "root") != 0) { - rpcRsp.code = TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_NO_RIGHTS; } else { - rpcRsp.code = mgmtCreateDnode(pCreate->ep); - if (rpcRsp.code == TSDB_CODE_SUCCESS) { - SDnodeObj *pDnode = mgmtGetDnodeByEp(pCreate->ep); + int32_t code = mnodeCreateDnode(pCreate->ep); + + if (code == TSDB_CODE_SUCCESS) { + SDnodeObj *pDnode = mnodeGetDnodeByEp(pCreate->ep); mLPrint("dnode:%d, %s is created by %s", pDnode->dnodeId, pCreate->ep, pMsg->pUser->user); - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); } else { - mError("failed to create dnode:%s, reason:%s", pCreate->ep, tstrerror(rpcRsp.code)); + mError("failed to create dnode:%s, reason:%s", pCreate->ep, tstrerror(code)); } + + return code; } - rpcSendResponse(&rpcRsp); } - -static void mgmtProcessDropDnodeMsg(SMnodeMsg *pMsg) { - SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; - +static int32_t mnodeProcessDropDnodeMsg(SMnodeMsg *pMsg) { SCMDropDnodeMsg *pDrop = pMsg->pCont; if (strcmp(pMsg->pUser->user, "root") != 0) { - rpcRsp.code = TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_NO_RIGHTS; } else { - rpcRsp.code = mgmtDropDnodeByEp(pDrop->ep); - if (rpcRsp.code == TSDB_CODE_SUCCESS) { + int32_t code = mnodeDropDnodeByEp(pDrop->ep); + + if (code == TSDB_CODE_SUCCESS) { mLPrint("dnode:%s is dropped by %s", pDrop->ep, pMsg->pUser->user); } else { - mError("failed to drop dnode:%s, reason:%s", pDrop->ep, tstrerror(rpcRsp.code)); + mError("failed to drop dnode:%s, reason:%s", pDrop->ep, tstrerror(code)); } - } - rpcSendResponse(&rpcRsp); + return code; + } } -static int32_t mgmtGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { - SUserObj *pUser = mgmtGetUserFromConn(pConn); +static int32_t mnodeGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { + SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) return 0; if (strcmp(pUser->pAcct->user, "root") != 0) { - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return TSDB_CODE_NO_RIGHTS; } @@ -547,23 +535,23 @@ static int32_t mgmtGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCo pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1]; } - pShow->numOfRows = mgmtGetDnodesNum(); + pShow->numOfRows = mnodeGetDnodesNum(); pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; pShow->pIter = NULL; - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return 0; } -static int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +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 = mgmtGetNextDnode(pShow->pIter, &pDnode); + pShow->pIter = mnodeGetNextDnode(pShow->pIter, &pDnode); if (pDnode == NULL) break; cols = 0; @@ -586,7 +574,7 @@ static int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, voi pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - char* status = mgmtGetDnodeStatusStr(pDnode->status); + char* status = mnodeGetDnodeStatusStr(pDnode->status); STR_TO_VARSTR(pWrite, status); cols++; @@ -596,26 +584,26 @@ static int32_t mgmtRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, voi numOfRows++; - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); } pShow->numOfReads += numOfRows; return numOfRows; } -static bool mgmtCheckModuleInDnode(SDnodeObj *pDnode, int32_t moduleType) { +static bool mnodeCheckModuleInDnode(SDnodeObj *pDnode, int32_t moduleType) { uint32_t status = pDnode->moduleStatus & (1 << moduleType); return status > 0; } -static int32_t mgmtGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { +static int32_t mnodeGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { int32_t cols = 0; - SUserObj *pUser = mgmtGetUserFromConn(pConn); + SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) return 0; if (strcmp(pUser->user, "root") != 0) { - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return TSDB_CODE_NO_RIGHTS; } @@ -653,21 +641,21 @@ static int32_t mgmtGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pC pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1]; } - pShow->numOfRows = mgmtGetDnodesNum() * TSDB_MOD_MAX; + pShow->numOfRows = mnodeGetDnodesNum() * TSDB_MOD_MAX; pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; pShow->pIter = NULL; - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return 0; } -int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +int32_t mnodeRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn) { int32_t numOfRows = 0; char * pWrite; while (numOfRows < rows) { SDnodeObj *pDnode = NULL; - pShow->pIter = mgmtGetNextDnode(pShow->pIter, (SDnodeObj **)&pDnode); + pShow->pIter = mnodeGetNextDnode(pShow->pIter, (SDnodeObj **)&pDnode); if (pDnode == NULL) break; for (int32_t moduleType = 0; moduleType < TSDB_MOD_MAX; ++moduleType) { @@ -698,34 +686,34 @@ int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pCo cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - bool enable = mgmtCheckModuleInDnode(pDnode, moduleType); + bool enable = mnodeCheckModuleInDnode(pDnode, moduleType); strcpy(pWrite, enable ? "enable" : "disable"); cols++; numOfRows++; } - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); } pShow->numOfReads += numOfRows; return numOfRows; } -static bool mgmtCheckConfigShow(SGlobalCfg *cfg) { +static bool mnodeCheckConfigShow(SGlobalCfg *cfg) { if (!(cfg->cfgType & TSDB_CFG_CTYPE_B_SHOW)) return false; return true; } -static int32_t mgmtGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { +static int32_t mnodeGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { int32_t cols = 0; - SUserObj *pUser = mgmtGetUserFromConn(pConn); + SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) return 0; if (strcmp(pUser->user, "root") != 0) { - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return TSDB_CODE_NO_RIGHTS; } @@ -752,23 +740,23 @@ static int32_t mgmtGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pC pShow->numOfRows = 0; for (int32_t i = tsGlobalConfigNum - 1; i >= 0; --i) { SGlobalCfg *cfg = tsGlobalConfig + i; - if (!mgmtCheckConfigShow(cfg)) continue; + if (!mnodeCheckConfigShow(cfg)) continue; pShow->numOfRows++; } pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; pShow->pIter = NULL; - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return 0; } -static int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +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 (!mgmtCheckConfigShow(cfg)) continue; + if (!mnodeCheckConfigShow(cfg)) continue; char *pWrite; int32_t cols = 0; @@ -806,13 +794,13 @@ static int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, vo return numOfRows; } -static int32_t mgmtGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { +static int32_t mnodeGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { int32_t cols = 0; - SUserObj *pUser = mgmtGetUserFromConn(pConn); + SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) return 0; if (strcmp(pUser->user, "root") != 0) { - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return TSDB_CODE_NO_RIGHTS; } @@ -838,25 +826,25 @@ static int32_t mgmtGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCo SDnodeObj *pDnode = NULL; if (pShow->payloadLen > 0 ) { - pDnode = mgmtGetDnodeByEp(pShow->payload); + pDnode = mnodeGetDnodeByEp(pShow->payload); } else { - void *pIter = mgmtGetNextDnode(NULL, (SDnodeObj **)&pDnode); + void *pIter = mnodeGetNextDnode(NULL, (SDnodeObj **)&pDnode); sdbFreeIter(pIter); } if (pDnode != NULL) { pShow->numOfRows += pDnode->openVnodes; - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); } pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; pShow->pIter = pDnode; - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return 0; } -static int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +static int32_t mnodeRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) { int32_t numOfRows = 0; SDnodeObj *pDnode = NULL; char * pWrite; @@ -869,7 +857,7 @@ static int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, voi void *pIter = NULL; SVgObj *pVgroup; while (1) { - pIter = mgmtGetNextVgroup(pIter, &pVgroup); + pIter = mnodeGetNextVgroup(pIter, &pVgroup); if (pVgroup == NULL) break; for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) { @@ -882,12 +870,12 @@ static int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, voi cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - strcpy(pWrite, mgmtGetMnodeRoleStr(pVgid->role)); + strcpy(pWrite, mnodeGetMnodeRoleStr(pVgid->role)); cols++; } } - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); } sdbFreeIter(pIter); } else { @@ -898,7 +886,7 @@ static int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, voi return numOfRows; } -char* mgmtGetDnodeStatusStr(int32_t dnodeStatus) { +char* mnodeGetDnodeStatusStr(int32_t dnodeStatus) { switch (dnodeStatus) { case TAOS_DN_STATUS_OFFLINE: return "offline"; case TAOS_DN_STATUS_DROPPING: return "dropping"; diff --git a/src/mnode/src/mnodeInt.c b/src/mnode/src/mnodeInt.c new file mode 100644 index 0000000000..a701f1e1f4 --- /dev/null +++ b/src/mnode/src/mnodeInt.c @@ -0,0 +1,63 @@ +/* + * 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 "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" + +void mnodeCreateMsg(SMnodeMsg *pMsg, SRpcMsg *rpcMsg) { + pMsg->thandle = rpcMsg->handle; + pMsg->msgType = rpcMsg->msgType; + pMsg->contLen = rpcMsg->contLen; + pMsg->pCont = rpcMsg->pCont; +} + +int32_t mnodeInitMsg(SMnodeMsg *pMsg) { + pMsg->pUser = mnodeGetUserFromConn(pMsg->thandle); + if (pMsg->pUser == NULL) { + return TSDB_CODE_INVALID_USER; + } + + return TSDB_CODE_SUCCESS; +} + +void mnodeCleanupMsg(SMnodeMsg *pMsg) { + if (pMsg != NULL) { + if (pMsg->pCont) rpcFreeCont(pMsg->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->pAcct) mnodeDecAcctRef(pMsg->pAcct); + if (pMsg->pDnode) mnodeDecDnodeRef(pMsg->pDnode); + } +} diff --git a/src/mnode/src/mnodeMain.c b/src/mnode/src/mnodeMain.c index 563e679b34..6e3b3d24e9 100644 --- a/src/mnode/src/mnodeMain.c +++ b/src/mnode/src/mnodeMain.c @@ -24,7 +24,6 @@ #include "dnode.h" #include "mnodeDef.h" #include "mnodeInt.h" -#include "mnodeServer.h" #include "mnodeAcct.h" #include "mnodeDnode.h" #include "mnodeMnode.h" @@ -33,16 +32,16 @@ #include "mnodeVgroup.h" #include "mnodeUser.h" #include "mnodeTable.h" -#include "mnodeShell.h" +#include "mnodeShow.h" -static void *tsMgmtTmr; +void *tsMnodeTmr; static bool tsMgmtIsRunning = false; static void mnodeInitTimer(); static void mnodeCleanupTimer(); static bool mnodeNeedStart() ; -int32_t mgmtStartSystem() { +int32_t mnodeStartSystem() { if (tsMgmtIsRunning) { mPrint("TDengine mgmt module already started..."); return 0; @@ -54,37 +53,37 @@ int32_t mgmtStartSystem() { mkdir(tsMnodeDir, 0755); } - if (mgmtInitAccts() < 0) { + if (mnodeInitAccts() < 0) { mError("failed to init accts"); return -1; } - if (mgmtInitUsers() < 0) { + if (mnodeInitUsers() < 0) { mError("failed to init users"); return -1; } - if (mgmtInitDnodes() < 0) { + if (mnodeInitDnodes() < 0) { mError("failed to init dnodes"); return -1; } - if (mgmtInitDbs() < 0) { + if (mnodeInitDbs() < 0) { mError("failed to init dbs"); return -1; } - if (mgmtInitVgroups() < 0) { + if (mnodeInitVgroups() < 0) { mError("failed to init vgroups"); return -1; } - if (mgmtInitTables() < 0) { + if (mnodeInitTables() < 0) { mError("failed to init tables"); return -1; } - if (mgmtInitMnodes() < 0) { + if (mnodeInitMnodes() < 0) { mError("failed to init mnodes"); return -1; } @@ -103,7 +102,8 @@ int32_t mgmtStartSystem() { return -1; } - if (mnodeInitMgmt() < 0) { + if (mnodeInitShow() < 0) { + mError("failed to init show"); return -1; } @@ -115,39 +115,28 @@ int32_t mgmtStartSystem() { return 0; } -int32_t mgmtInitSystem() { +int32_t mnodeInitSystem() { mnodeInitTimer(); - mnodeInitRead(); - mnodeInitWrite(); - - if (mnodeNeedStart()) { - if (mgmtStartSystem() != 0) { - return -1; - } - } - - return 0; + if (!mnodeNeedStart()) return 0; + return mnodeStartSystem(); } -void mgmtCleanUpSystem() { +void mnodeCleanupSystem() { mPrint("starting to clean up mgmt"); tsMgmtIsRunning = false; mnodeCleanupTimer(); - mnodeCleanupRead(); - mnodeCleanupWrite(); - - mgmtCleanupMgmt(); + mnodeCleanUpShow(); grantCleanUp(); balanceCleanUp(); sdbCleanUp(); mgmtCleanupMnodes(); - mgmtCleanUpTables(); - mgmtCleanUpVgroups(); - mgmtCleanUpDbs(); + mnodeCleanupTables(); + mnodeCleanupVgroups(); + mnodeCleanupDbs(); mgmtCleanupDnodes(); - mgmtCleanUpUsers(); - mgmtCleanUpAccts(); + mnodeCleanupUsers(); + mnodeCleanupAccts(); mPrint("mgmt is cleaned up"); } @@ -157,31 +146,21 @@ void mgmtStopSystem() { return; } - - mgmtCleanUpSystem(); - + mnodeCleanupSystem(); mPrint("mgmt file is removed"); remove(tsMnodeDir); } - - -void* mnodeGetWqueue(int32_t vgId) { - -} - - - static void mnodeInitTimer() { - if (tsMgmtTmr != NULL) { - tsMgmtTmr = taosTmrInit((tsMaxShellConns)*3, 200, 3600000, "MND"); + if (tsMnodeTmr != NULL) { + tsMnodeTmr = taosTmrInit((tsMaxShellConns)*3, 200, 3600000, "MND"); } } static void mnodeCleanupTimer() { - if (tsMgmtTmr != NULL) { - taosTmrCleanUp(tsMgmtTmr); - tsMgmtTmr = NULL; + if (tsMnodeTmr != NULL) { + taosTmrCleanUp(tsMnodeTmr); + tsMnodeTmr = NULL; } } @@ -196,3 +175,7 @@ static bool mnodeNeedStart() { return false; } + +bool mnodeIsRunning() { + return tsMgmtIsRunning; +} \ No newline at end of file diff --git a/src/mnode/src/mnodeMnode.c b/src/mnode/src/mnodeMnode.c index f939dfb426..3fababf023 100644 --- a/src/mnode/src/mnodeMnode.c +++ b/src/mnode/src/mnodeMnode.c @@ -28,80 +28,80 @@ #include "mnodeMnode.h" #include "mnodeDnode.h" #include "mnodeSdb.h" -#include "mnodeShell.h" +#include "mnodeShow.h" #include "mnodeUser.h" -static void * tsMnodeSdb = NULL; -static int32_t tsMnodeUpdateSize = 0; -static int32_t mgmtGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static int32_t mgmtRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn); - -static SRpcIpSet tsMnodeRpcIpSet; +static void * tsMnodeSdb = NULL; +static int32_t tsMnodeUpdateSize = 0; +static SRpcIpSet tsMnodeRpcIpSetForShell; +static SRpcIpSet tsMnodeRpcIpSetForPeer; static SDMMnodeInfos tsMnodeInfos; +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 mgmtMnodeWrLock() pthread_rwlock_wrlock(&tsMnodeLock) - #define mgmtMnodeRdLock() pthread_rwlock_rdlock(&tsMnodeLock) - #define mgmtMnodeUnLock() pthread_rwlock_unlock(&tsMnodeLock) - #define mgmtMnodeInitLock() pthread_rwlock_init(&tsMnodeLock, NULL) - #define mgmtMnodeDestroyLock() pthread_rwlock_destroy(&tsMnodeLock) + 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 mgmtMnodeWrLock() pthread_mutex_lock(&tsMnodeLock) - #define mgmtMnodeRdLock() pthread_mutex_lock(&tsMnodeLock) - #define mgmtMnodeUnLock() pthread_mutex_unlock(&tsMnodeLock) - #define mgmtMnodeInitLock() pthread_mutex_init(&tsMnodeLock, NULL) - #define mgmtMnodeDestroyLock() pthread_mutex_destroy(&tsMnodeLock) + 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 mgmtMnodeActionDestroy(SSdbOper *pOper) { +static int32_t mnodeMnodeActionDestroy(SSdbOper *pOper) { tfree(pOper->pObj); return TSDB_CODE_SUCCESS; } -static int32_t mgmtMnodeActionInsert(SSdbOper *pOper) { +static int32_t mnodeMnodeActionInsert(SSdbOper *pOper) { SMnodeObj *pMnode = pOper->pObj; - SDnodeObj *pDnode = mgmtGetDnode(pMnode->mnodeId); + SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId); if (pDnode == NULL) return TSDB_CODE_DNODE_NOT_EXIST; pDnode->isMgmt = true; - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); return TSDB_CODE_SUCCESS; } -static int32_t mgmtMnodeActionDelete(SSdbOper *pOper) { +static int32_t mnodeMnodeActionDelete(SSdbOper *pOper) { SMnodeObj *pMnode = pOper->pObj; - SDnodeObj *pDnode = mgmtGetDnode(pMnode->mnodeId); + SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId); if (pDnode == NULL) return TSDB_CODE_DNODE_NOT_EXIST; pDnode->isMgmt = false; - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); mTrace("mnode:%d, is dropped from sdb", pMnode->mnodeId); return TSDB_CODE_SUCCESS; } -static int32_t mgmtMnodeActionUpdate(SSdbOper *pOper) { +static int32_t mnodeMnodeActionUpdate(SSdbOper *pOper) { SMnodeObj *pMnode = pOper->pObj; - SMnodeObj *pSaved = mgmtGetMnode(pMnode->mnodeId); + SMnodeObj *pSaved = mnodeGetMnode(pMnode->mnodeId); if (pMnode != pSaved) { memcpy(pSaved, pMnode, pOper->rowSize); free(pMnode); } - mgmtDecMnodeRef(pSaved); + mnodeDecMnodeRef(pSaved); return TSDB_CODE_SUCCESS; } -static int32_t mgmtMnodeActionEncode(SSdbOper *pOper) { +static int32_t mnodeMnodeActionEncode(SSdbOper *pOper) { SMnodeObj *pMnode = pOper->pObj; memcpy(pOper->rowData, pMnode, tsMnodeUpdateSize); pOper->rowSize = tsMnodeUpdateSize; return TSDB_CODE_SUCCESS; } -static int32_t mgmtMnodeActionDecode(SSdbOper *pOper) { +static int32_t mnodeMnodeActionDecode(SSdbOper *pOper) { SMnodeObj *pMnode = calloc(1, sizeof(SMnodeObj)); if (pMnode == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; @@ -110,24 +110,24 @@ static int32_t mgmtMnodeActionDecode(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtMnodeActionRestored() { - if (mgmtGetMnodesNum() == 1) { +static int32_t mnodeMnodeActionRestored() { + if (mnodeGetMnodesNum() == 1) { SMnodeObj *pMnode = NULL; - void *pIter = mgmtGetNextMnode(NULL, &pMnode); + void *pIter = mnodeGetNextMnode(NULL, &pMnode); if (pMnode != NULL) { pMnode->role = TAOS_SYNC_ROLE_MASTER; - mgmtDecMnodeRef(pMnode); + mnodeDecMnodeRef(pMnode); } sdbFreeIter(pIter); } - mgmtUpdateMnodeIpSet(); + mnodeUpdateMnodeIpSet(); return TSDB_CODE_SUCCESS; } -int32_t mgmtInitMnodes() { - mgmtMnodeInitLock(); +int32_t mnodeInitMnodes() { + mnodeMnodeInitLock(); SMnodeObj tObj; tsMnodeUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj; @@ -139,13 +139,13 @@ int32_t mgmtInitMnodes() { .maxRowSize = tsMnodeUpdateSize, .refCountPos = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj, .keyType = SDB_KEY_INT, - .insertFp = mgmtMnodeActionInsert, - .deleteFp = mgmtMnodeActionDelete, - .updateFp = mgmtMnodeActionUpdate, - .encodeFp = mgmtMnodeActionEncode, - .decodeFp = mgmtMnodeActionDecode, - .destroyFp = mgmtMnodeActionDestroy, - .restoredFp = mgmtMnodeActionRestored + .insertFp = mnodeMnodeActionInsert, + .deleteFp = mnodeMnodeActionDelete, + .updateFp = mnodeMnodeActionUpdate, + .encodeFp = mnodeMnodeActionEncode, + .decodeFp = mnodeMnodeActionDecode, + .destroyFp = mnodeMnodeActionDestroy, + .restoredFp = mnodeMnodeActionRestored }; tsMnodeSdb = sdbOpenTable(&tableDesc); @@ -154,8 +154,8 @@ int32_t mgmtInitMnodes() { return -1; } - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_MNODE, mgmtGetMnodeMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_MNODE, mgmtRetrieveMnodes); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_MNODE, mnodeGetMnodeMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_MNODE, mnodeRetrieveMnodes); mTrace("table:mnodes table is created"); return TSDB_CODE_SUCCESS; @@ -163,30 +163,30 @@ int32_t mgmtInitMnodes() { void mgmtCleanupMnodes() { sdbCloseTable(tsMnodeSdb); - mgmtMnodeDestroyLock(); + mnodeMnodeDestroyLock(); } -int32_t mgmtGetMnodesNum() { +int32_t mnodeGetMnodesNum() { return sdbGetNumOfRows(tsMnodeSdb); } -void *mgmtGetMnode(int32_t mnodeId) { +void *mnodeGetMnode(int32_t mnodeId) { return sdbGetRow(tsMnodeSdb, &mnodeId); } -void mgmtIncMnodeRef(SMnodeObj *pMnode) { +void mnodeIncMnodeRef(SMnodeObj *pMnode) { sdbIncRef(tsMnodeSdb, pMnode); } -void mgmtDecMnodeRef(SMnodeObj *pMnode) { +void mnodeDecMnodeRef(SMnodeObj *pMnode) { sdbDecRef(tsMnodeSdb, pMnode); } -void *mgmtGetNextMnode(void *pIter, SMnodeObj **pMnode) { +void *mnodeGetNextMnode(void *pIter, SMnodeObj **pMnode) { return sdbFetchRow(tsMnodeSdb, pIter, (void **)pMnode); } -char *mgmtGetMnodeRoleStr(int32_t role) { +char *mnodeGetMnodeRoleStr(int32_t role) { switch (role) { case TAOS_SYNC_ROLE_OFFLINE: return "offline"; @@ -201,68 +201,79 @@ char *mgmtGetMnodeRoleStr(int32_t role) { } } -void mgmtUpdateMnodeIpSet() { - SRpcIpSet *ipSet = &tsMnodeRpcIpSet; +void mnodeUpdateMnodeIpSet() { + SRpcIpSet *ipSetForShell = &tsMnodeRpcIpSetForShell; + SRpcIpSet *ipSetForPeer = &tsMnodeRpcIpSetForPeer; SDMMnodeInfos *mnodes = &tsMnodeInfos; - mPrint("update mnodes ipset, numOfIps:%d ", mgmtGetMnodesNum()); + mPrint("update mnodes ipset, numOfIps:%d ", mnodeGetMnodesNum()); - mgmtMnodeWrLock(); + mnodeMnodeWrLock(); - memset(ipSet, 0, sizeof(tsMnodeRpcIpSet)); + memset(ipSetForShell, 0, sizeof(SRpcIpSet)); + memset(ipSetForPeer, 0, sizeof(SRpcIpSet)); memset(mnodes, 0, sizeof(SDMMnodeInfos)); int32_t index = 0; void * pIter = NULL; while (1) { SMnodeObj *pMnode = NULL; - pIter = mgmtGetNextMnode(pIter, &pMnode); + pIter = mnodeGetNextMnode(pIter, &pMnode); if (pMnode == NULL) break; - SDnodeObj *pDnode = mgmtGetDnode(pMnode->mnodeId); + SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId); if (pDnode != NULL) { - strcpy(ipSet->fqdn[ipSet->numOfIps], pDnode->dnodeFqdn); - ipSet->port[ipSet->numOfIps] = htons(pDnode->dnodePort); + strcpy(ipSetForShell->fqdn[ipSetForShell->numOfIps], pDnode->dnodeFqdn); + ipSetForShell->port[ipSetForShell->numOfIps] = htons(pDnode->dnodePort); + + strcpy(ipSetForPeer->fqdn[ipSetForPeer->numOfIps], pDnode->dnodeFqdn); + ipSetForPeer->port[ipSetForPeer->numOfIps] = htons(pDnode->dnodePort + TSDB_PORT_DNODEDNODE); mnodes->nodeInfos[index].nodeId = htonl(pMnode->mnodeId); strcpy(mnodes->nodeInfos[index].nodeEp, pDnode->dnodeEp); if (pMnode->role == TAOS_SYNC_ROLE_MASTER) { - ipSet->inUse = ipSet->numOfIps; + ipSetForShell->inUse = index; + ipSetForPeer->inUse = index; mnodes->inUse = index; } - mPrint("mnode:%d, ep:%s %s", index, pDnode->dnodeEp, - pMnode->role == TAOS_SYNC_ROLE_MASTER ? "master" : ""); - - ipSet->numOfIps++; + mPrint("mnode:%d, ep:%s %s", index, pDnode->dnodeEp, pMnode->role == TAOS_SYNC_ROLE_MASTER ? "master" : ""); index++; } - mgmtDecDnodeRef(pDnode); - mgmtDecMnodeRef(pMnode); + mnodeDecDnodeRef(pDnode); + mnodeDecMnodeRef(pMnode); } mnodes->nodeNum = index; + ipSetForPeer->numOfIps = index; + ipSetForPeer->numOfIps = index; sdbFreeIter(pIter); - mgmtMnodeUnLock(); + mnodeMnodeUnLock(); } -void mgmtGetMnodeIpSet(SRpcIpSet *ipSet) { - mgmtMnodeRdLock(); - *ipSet = tsMnodeRpcIpSet; - mgmtMnodeUnLock(); +void mnodeGetMnodeIpSetForPeer(SRpcIpSet *ipSet) { + mnodeMnodeRdLock(); + *ipSet = tsMnodeRpcIpSetForShell; + mnodeMnodeUnLock(); } -void mgmtGetMnodeInfos(void *mnodeInfos) { - mgmtMnodeRdLock(); +void mnodeGetMnodeIpSetForShell(SRpcIpSet *ipSet) { + mnodeMnodeRdLock(); + *ipSet = tsMnodeRpcIpSetForShell; + mnodeMnodeUnLock(); +} + +void mnodeGetMnodeInfos(void *mnodeInfos) { + mnodeMnodeRdLock(); *(SDMMnodeInfos *)mnodeInfos = tsMnodeInfos; - mgmtMnodeUnLock(); + mnodeMnodeUnLock(); } -int32_t mgmtAddMnode(int32_t dnodeId) { +int32_t mnodeAddMnode(int32_t dnodeId) { SMnodeObj *pMnode = calloc(1, sizeof(SMnodeObj)); pMnode->mnodeId = dnodeId; pMnode->createdTime = taosGetTimestampMs(); @@ -279,24 +290,24 @@ int32_t mgmtAddMnode(int32_t dnodeId) { code = TSDB_CODE_SDB_ERROR; } - mgmtUpdateMnodeIpSet(); + mnodeUpdateMnodeIpSet(); return code; } -void mgmtDropMnodeLocal(int32_t dnodeId) { - SMnodeObj *pMnode = mgmtGetMnode(dnodeId); +void mnodeDropMnodeLocal(int32_t dnodeId) { + SMnodeObj *pMnode = mnodeGetMnode(dnodeId); if (pMnode != NULL) { SSdbOper oper = {.type = SDB_OPER_LOCAL, .table = tsMnodeSdb, .pObj = pMnode}; sdbDeleteRow(&oper); - mgmtDecMnodeRef(pMnode); + mnodeDecMnodeRef(pMnode); } - mgmtUpdateMnodeIpSet(); + mnodeUpdateMnodeIpSet(); } -int32_t mgmtDropMnode(int32_t dnodeId) { - SMnodeObj *pMnode = mgmtGetMnode(dnodeId); +int32_t mnodeDropMnode(int32_t dnodeId) { + SMnodeObj *pMnode = mnodeGetMnode(dnodeId); if (pMnode == NULL) { return TSDB_CODE_DNODE_NOT_EXIST; } @@ -314,18 +325,18 @@ int32_t mgmtDropMnode(int32_t dnodeId) { sdbDecRef(tsMnodeSdb, pMnode); - mgmtUpdateMnodeIpSet(); + mnodeUpdateMnodeIpSet(); return code; } -static int32_t mgmtGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { +static int32_t mnodeGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { sdbUpdateMnodeRoles(); - SUserObj *pUser = mgmtGetUserFromConn(pConn); + SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) return 0; if (strcmp(pUser->pAcct->user, "root") != 0) { - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return TSDB_CODE_NO_RIGHTS; } @@ -364,22 +375,22 @@ static int32_t mgmtGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCo pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1]; } - pShow->numOfRows = mgmtGetMnodesNum(); + pShow->numOfRows = mnodeGetMnodesNum(); pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; pShow->pIter = NULL; - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return 0; } -static int32_t mgmtRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +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 = mgmtGetNextMnode(pShow->pIter, &pMnode); + pShow->pIter = mnodeGetNextMnode(pShow->pIter, &pMnode); if (pMnode == NULL) break; cols = 0; @@ -390,18 +401,18 @@ static int32_t mgmtRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, voi pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - SDnodeObj *pDnode = mgmtGetDnode(pMnode->mnodeId); + SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId); if (pDnode != NULL) { STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDnode->dnodeEp, pShow->bytes[cols] - VARSTR_HEADER_SIZE); } else { STR_WITH_MAXSIZE_TO_VARSTR(pWrite, "invalid ep", pShow->bytes[cols] - VARSTR_HEADER_SIZE); } - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - char* roles = mgmtGetMnodeRoleStr(pMnode->role); + char* roles = mnodeGetMnodeRoleStr(pMnode->role); STR_TO_VARSTR(pWrite, roles); cols++; @@ -411,7 +422,7 @@ static int32_t mgmtRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, voi numOfRows++; - mgmtDecMnodeRef(pMnode); + mnodeDecMnodeRef(pMnode); } pShow->numOfReads += numOfRows; diff --git a/src/mnode/src/mnodeMgmt.c b/src/mnode/src/mnodePeer.c similarity index 56% rename from src/mnode/src/mnodeMgmt.c rename to src/mnode/src/mnodePeer.c index 49f4c90fa5..a4bb28b02c 100644 --- a/src/mnode/src/mnodeMgmt.c +++ b/src/mnode/src/mnodePeer.c @@ -23,38 +23,43 @@ #include "tgrant.h" #include "tbalance.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 "mnodeShell.h" +#include "mnodeShow.h" #include "mnodeSdb.h" #include "mnodeTable.h" #include "mnodeVgroup.h" -static void (*tsMnodeProcessMgmtMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *); +static int32_t (*tsMnodeProcessPeerMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *); +static void (*tsMnodeProcessPeerRspFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *); -void mnodeAddMgmtMsgHandle(uint8_t msgType, void (*fp)(SMnodeMsg *pMsg)) { - tsMnodeProcessMgmtMsgFp[msgType] = fp; +void mnodeAddPeerMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg)) { + tsMnodeProcessPeerMsgFp[msgType] = fp; } -int32_t mnodeProcessMgmt(SMnodeMsg *pMsg) { - SRpcMsg *rpcMsg = &pMsg->rpcMsg; - if (rpcMsg->pCont == NULL) { - mError("%p, msg:%s content is null", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); +void mnodeAddPeerRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)) { + tsMnodeProcessPeerRspFp[msgType] = fp; +} + +int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg) { + if (pMsg->pCont == NULL) { + mError("msg:%s content is null", taosMsg[pMsg->msgType]); return TSDB_CODE_INVALID_MSG_LEN; } if (!sdbIsMaster()) { SMnodeRsp *rpcRsp = &pMsg->rpcRsp; SRpcIpSet *ipSet = rpcMallocCont(sizeof(SRpcIpSet)); - mgmtGetMnodeIpSetForPeer(ipSet); + mnodeGetMnodeIpSetForPeer(ipSet); rpcRsp->rsp = ipSet; rpcRsp->len = sizeof(SRpcIpSet); - mTrace("%p, msg:%s will be redireced, inUse:%d", rpcMsg->ahandle, taosMsg[rpcMsg->msgType], ipSet->inUse); + mTrace("msg:%s will be redireced, inUse:%d", taosMsg[pMsg->msgType], ipSet->inUse); for (int32_t i = 0; i < ipSet->numOfIps; ++i) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } @@ -62,10 +67,20 @@ int32_t mnodeProcessMgmt(SMnodeMsg *pMsg) { return TSDB_CODE_REDIRECT; } - if (tsMnodeProcessMgmtMsgFp[rpcMsg->msgType] == NULL) { - mError("%p, msg:%s not processed, no handle exist", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + if (tsMnodeProcessPeerMsgFp[pMsg->msgType] == NULL) { + mError("msg:%s not processed, no handle exist", taosMsg[pMsg->msgType]); return TSDB_CODE_MSG_NOT_PROCESSED; } - return (*tsMnodeProcessMgmtMsgFp[rpcMsg->msgType])(rpcMsg, ); + return (*tsMnodeProcessPeerMsgFp[pMsg->msgType])(pMsg); +} + +void mnodeProcessPeerRsp(SRpcMsg *pMsg) { + if (tsMnodeProcessPeerRspFp[pMsg->msgType]) { + (*tsMnodeProcessPeerRspFp[pMsg->msgType])(pMsg); + } else { + mError("msg:%s is not processed", pMsg->handle, taosMsg[pMsg->msgType]); + } + + rpcFreeCont(pMsg->pCont); } diff --git a/src/mnode/src/mnodeProfile.c b/src/mnode/src/mnodeProfile.c index 3236197c83..4cb560e066 100644 --- a/src/mnode/src/mnodeProfile.c +++ b/src/mnode/src/mnodeProfile.c @@ -18,6 +18,7 @@ #include "taosmsg.h" #include "taoserror.h" #include "tutil.h" +#include "mnode.h" #include "mnodeDef.h" #include "mnodeInt.h" #include "mnodeAcct.h" @@ -25,16 +26,17 @@ #include "mnodeDb.h" #include "mnodeMnode.h" #include "mnodeProfile.h" -#include "mnodeShell.h" +#include "mnodeShow.h" #include "mnodeTable.h" #include "mnodeUser.h" #include "mnodeVgroup.h" +#include "mnodeWrite.h" -int32_t mgmtSaveQueryStreamList(SCMHeartBeatMsg *pHBMsg); +int32_t mnodeSaveQueryStreamList(SCMHeartBeatMsg *pHBMsg); -int32_t mgmtKillQuery(char *qidstr, void *pConn); -int32_t mgmtKillStream(char *qidstr, void *pConn); -int32_t mgmtKillConnection(char *qidstr, void *pConn); +int32_t mnodeKillQuery(char *qidstr, void *pConn); +int32_t mnodeKillStream(char *qidstr, void *pConn); +int32_t mnodeKillConnection(char *qidstr, void *pConn); typedef struct { char user[TSDB_TABLE_ID_LEN + 1]; @@ -98,7 +100,7 @@ int32_t mgmtSaveQueryStreamList(SCMHeartBeatMsg *pHBMsg) { return TSDB_CODE_SUCCESS; } -int32_t mgmtGetQueries(SShowObj *pShow, void *pConn) { +int32_t mnodeGetQueries(SShowObj *pShow, void *pConn) { // SAcctObj * pAcct = pConn->pAcct; // SQueryShow *pQueryShow; // @@ -145,7 +147,7 @@ int32_t mgmtGetQueries(SShowObj *pShow, void *pConn) { return 0; } -int32_t mgmtGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { +int32_t mnodeGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { int32_t cols = 0; SSchema *pSchema = pMeta->schema; @@ -190,11 +192,11 @@ int32_t mgmtGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { pShow->pIter = NULL; pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; - mgmtGetQueries(pShow, pConn); + mnodeGetQueries(pShow, pConn); return 0; } -int32_t mgmtKillQuery(char *qidstr, void *pConn) { +int32_t mnodeKillQuery(char *qidstr, void *pConn) { // char *temp, *chr, idstr[64]; // strcpy(idstr, qidstr); // @@ -247,7 +249,7 @@ int32_t mgmtKillQuery(char *qidstr, void *pConn) { return TSDB_CODE_INVALID_QUERY_ID; } -int32_t mgmtRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +int32_t mnodeRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pConn) { int32_t numOfRows = 0; char *pWrite; int32_t cols = 0; @@ -297,7 +299,7 @@ int32_t mgmtRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, void *pCo return numOfRows; } -int32_t mgmtGetStreams(SShowObj *pShow, void *pConn) { +int32_t mnodeGetStreams(SShowObj *pShow, void *pConn) { // SAcctObj * pAcct = pConn->pAcct; // SStreamShow *pStreamShow; // @@ -344,7 +346,7 @@ int32_t mgmtGetStreams(SShowObj *pShow, void *pConn) { return 0; } -int32_t mgmtGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { +int32_t mnodeGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { int32_t cols = 0; SSchema *pSchema = pMeta->schema; @@ -400,11 +402,11 @@ int32_t mgmtGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { pShow->pIter = NULL; pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; - mgmtGetStreams(pShow, pConn); + mnodeGetStreams(pShow, pConn); return 0; } -int32_t mgmtRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +int32_t mnodeRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn) { int32_t numOfRows = 0; char *pWrite; int32_t cols = 0; @@ -462,7 +464,7 @@ int32_t mgmtRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pCo return numOfRows; } -int32_t mgmtKillStream(char *qidstr, void *pConn) { +int32_t mnodeKillStream(char *qidstr, void *pConn) { // char *temp, *chr, idstr[64]; // strcpy(idstr, qidstr); // @@ -515,7 +517,7 @@ int32_t mgmtKillStream(char *qidstr, void *pConn) { return TSDB_CODE_INVALID_STREAM_ID; } -int32_t mgmtKillConnection(char *qidstr, void *pConn) { +int32_t mnodeKillConnection(char *qidstr, void *pConn) { // void *pConn1 = NULL; // char * temp, *chr, idstr[64]; // strcpy(idstr, qidstr); @@ -562,7 +564,7 @@ int32_t mgmtKillConnection(char *qidstr, void *pConn) { } -int mgmtGetConns(SShowObj *pShow, void *pConn) { +int mnodeGetConns(SShowObj *pShow, void *pConn) { // SAcctObj * pAcct = pConn->pAcct; // SConnShow *pConnShow; // @@ -597,7 +599,7 @@ int mgmtGetConns(SShowObj *pShow, void *pConn) { return 0; } -int32_t mgmtGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { +int32_t mnodeGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { int32_t cols = 0; pShow->bytes[cols] = TSDB_TABLE_NAME_LEN; @@ -630,11 +632,11 @@ int32_t mgmtGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { pShow->pIter = NULL; pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; - mgmtGetConns(pShow, pConn); + mnodeGetConns(pShow, pConn); return 0; } -int32_t mgmtRetrieveConns(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +int32_t mnodeRetrieveConns(SShowObj *pShow, char *data, int32_t rows, void *pConn) { int32_t numOfRows = 0; char *pWrite; int32_t cols = 0; @@ -672,91 +674,94 @@ int32_t mgmtRetrieveConns(SShowObj *pShow, char *data, int32_t rows, void *pConn return numOfRows; } -void mgmtProcessKillQueryMsg(SMnodeMsg *pMsg) { - SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; +int32_t mnodeProcessKillQueryMsg(SMnodeMsg *pMsg) { + // SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; - SUserObj *pUser = mgmtGetUserFromConn(pMsg->thandle); - if (pUser == NULL) { - rpcRsp.code = TSDB_CODE_INVALID_USER; - rpcSendResponse(&rpcRsp); - return; - } + // SUserObj *pUser = mnodeGetUserFromConn(pMsg->thandle); + // if (pUser == NULL) { + // rpcRsp.code = TSDB_CODE_INVALID_USER; + // rpcSendResponse(&rpcRsp); + // return; + // } - SCMKillQueryMsg *pKill = pMsg->pCont; - int32_t code; + // SCMKillQueryMsg *pKill = pMsg->pCont; + // int32_t code; - if (!pUser->writeAuth) { - code = TSDB_CODE_NO_RIGHTS; - } else { - code = mgmtKillQuery(pKill->queryId, pMsg->thandle); - } + // if (!pUser->writeAuth) { + // code = TSDB_CODE_NO_RIGHTS; + // } else { + // code = mgmtKillQuery(pKill->queryId, pMsg->thandle); + // } - rpcRsp.code = code; - rpcSendResponse(&rpcRsp); - mgmtDecUserRef(pUser); + // rpcRsp.code = code; + // rpcSendResponse(&rpcRsp); + // mnodeDecUserRef(pUser); + return TSDB_CODE_SUCCESS; } -void mgmtProcessKillStreamMsg(SMnodeMsg *pMsg) { - SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; +int32_t mnodeProcessKillStreamMsg(SMnodeMsg *pMsg) { + // SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; - SUserObj *pUser = mgmtGetUserFromConn(pMsg->thandle); - if (pUser == NULL) { - rpcRsp.code = TSDB_CODE_INVALID_USER; - rpcSendResponse(&rpcRsp); - return; - } + // SUserObj *pUser = mnodeGetUserFromConn(pMsg->thandle); + // if (pUser == NULL) { + // rpcRsp.code = TSDB_CODE_INVALID_USER; + // rpcSendResponse(&rpcRsp); + // return; + // } - SCMKillStreamMsg *pKill = pMsg->pCont; - int32_t code; + // SCMKillStreamMsg *pKill = pMsg->pCont; + // int32_t code; - if (!pUser->writeAuth) { - code = TSDB_CODE_NO_RIGHTS; - } else { - code = mgmtKillStream(pKill->queryId, pMsg->thandle); - } + // if (!pUser->writeAuth) { + // code = TSDB_CODE_NO_RIGHTS; + // } else { + // code = mgmtKillStream(pKill->queryId, pMsg->thandle); + // } - rpcRsp.code = code; - rpcSendResponse(&rpcRsp); - mgmtDecUserRef(pUser); + // rpcRsp.code = code; + // rpcSendResponse(&rpcRsp); + // mnodeDecUserRef(pUser); + return TSDB_CODE_SUCCESS; } -void mgmtProcessKillConnectionMsg(SMnodeMsg *pMsg) { - SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; +int32_t mnodeProcessKillConnectionMsg(SMnodeMsg *pMsg) { + // SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; - SUserObj *pUser = mgmtGetUserFromConn(pMsg->thandle); - if (pUser == NULL) { - rpcRsp.code = TSDB_CODE_INVALID_USER; - rpcSendResponse(&rpcRsp); - return; - } + // SUserObj *pUser = mnodeGetUserFromConn(pMsg->thandle); + // if (pUser == NULL) { + // rpcRsp.code = TSDB_CODE_INVALID_USER; + // rpcSendResponse(&rpcRsp); + // return; + // } - SCMKillConnMsg *pKill = pMsg->pCont; - int32_t code; + // SCMKillConnMsg *pKill = pMsg->pCont; + // int32_t code; - if (!pUser->writeAuth) { - code = TSDB_CODE_NO_RIGHTS; - } else { - code = mgmtKillConnection(pKill->queryId, pMsg->thandle); - } + // if (!pUser->writeAuth) { + // code = TSDB_CODE_NO_RIGHTS; + // } else { + // code = mgmtKillConnection(pKill->queryId, pMsg->thandle); + // } - rpcRsp.code = code; - rpcSendResponse(&rpcRsp); - mgmtDecUserRef(pUser); + // rpcRsp.code = code; + // rpcSendResponse(&rpcRsp); + // mnodeDecUserRef(pUser); + return TSDB_CODE_SUCCESS; } -int32_t mgmtInitProfile() { - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_QUERIES, mgmtGetQueryMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_QUERIES, mgmtRetrieveQueries); - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_CONNS, mgmtGetConnsMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_CONNS, mgmtRetrieveConns); - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_STREAMS, mgmtGetStreamMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_STREAMS, mgmtRetrieveStreams); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mgmtProcessKillQueryMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mgmtProcessKillStreamMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_KILL_CONN, mgmtProcessKillConnectionMsg); +int32_t mnodeInitProfile() { + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mnodeGetQueryMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mnodeRetrieveQueries); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mnodeGetConnsMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mnodeRetrieveConns); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_STREAMS, mnodeGetStreamMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMS, mnodeRetrieveStreams); + mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mnodeProcessKillQueryMsg); + mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mnodeProcessKillStreamMsg); + mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_CONN, mnodeProcessKillConnectionMsg); return 0; } -void mgmtCleanUpProfile() { +void mnodeCleanupProfile() { } diff --git a/src/mnode/src/mnodeRead.c b/src/mnode/src/mnodeRead.c index c8983bf1e7..32790af03f 100644 --- a/src/mnode/src/mnodeRead.c +++ b/src/mnode/src/mnodeRead.c @@ -24,39 +24,37 @@ #include "mnode.h" #include "dnode.h" #include "mnodeDef.h" -#include "mgmtInt.h" -#include "mgmtServer.h" +#include "mnodeInt.h" #include "mnodeAcct.h" -#include "mgmtDnode.h" -#include "mgmtMnode.h" +#include "mnodeDnode.h" +#include "mnodeMnode.h" #include "mnodeDb.h" -#include "mgmtSdb.h" -#include "mgmtVgroup.h" -#include "mgmtUser.h" -#include "mgmtTable.h" -#include "mgmtShell.h" +#include "mnodeSdb.h" +#include "mnodeVgroup.h" +#include "mnodeUser.h" +#include "mnodeTable.h" +#include "mnodeShow.h" -static void (*tsMnodeProcessReadMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *); +static int32_t (*tsMnodeProcessReadMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *); -void mnodeAddReadMsgHandle(uint8_t msgType, void (*fp)(SMnodeMsg *pMsg)) { +void mnodeAddReadMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *pMsg)) { tsMnodeProcessReadMsgFp[msgType] = fp; } int32_t mnodeProcessRead(SMnodeMsg *pMsg) { - SRpcMsg *rpcMsg = &pMsg->rpcMsg; - if (rpcMsg->pCont == NULL) { - mError("%p, msg:%s content is null", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + if (pMsg->pCont == NULL) { + mError("msg:%s content is null", taosMsg[pMsg->msgType]); return TSDB_CODE_INVALID_MSG_LEN; } if (!sdbIsMaster()) { SMnodeRsp *rpcRsp = &pMsg->rpcRsp; SRpcIpSet *ipSet = rpcMallocCont(sizeof(SRpcIpSet)); - mgmtGetMnodeIpSetForShell(ipSet); + mnodeGetMnodeIpSetForShell(ipSet); rpcRsp->rsp = ipSet; rpcRsp->len = sizeof(SRpcIpSet); - mTrace("%p, msg:%s will be redireced, inUse:%d", rpcMsg->ahandle, taosMsg[rpcMsg->msgType], ipSet->inUse); + mTrace("msg:%s will be redireced, inUse:%d", taosMsg[pMsg->msgType], ipSet->inUse); for (int32_t i = 0; i < ipSet->numOfIps; ++i) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } @@ -64,20 +62,15 @@ int32_t mnodeProcessRead(SMnodeMsg *pMsg) { return TSDB_CODE_REDIRECT; } - if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) { - mError("%p, msg:%s not processed, grant time expired", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); - return TSDB_CODE_GRANT_EXPIRED; - } - - if (tsMnodeProcessReadMsgFp[rpcMsg->msgType] == NULL) { - mError("%p, msg:%s not processed, no handle exist", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + if (tsMnodeProcessReadMsgFp[pMsg->msgType] == NULL) { + mError("msg:%s not processed, no handle exist", taosMsg[pMsg->msgType]); return TSDB_CODE_MSG_NOT_PROCESSED; } if (!mnodeInitMsg(pMsg)) { - mError("%p, msg:%s not processed, reason:%s", rpcMsg->ahandle, taosMsg[rpcMsg->msgType], tstrerror(terrno)); + mError("msg:%s not processed, reason:%s", taosMsg[pMsg->msgType], tstrerror(terrno)); return terrno; } - return (*tsMgmtProcessShellMsgFp[rpcMsg->msgType])(pMsg); + return (*tsMnodeProcessReadMsgFp[pMsg->msgType])(pMsg); } diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c index e873c0b573..3b04be1ea6 100644 --- a/src/mnode/src/mnodeSdb.c +++ b/src/mnode/src/mnodeSdb.c @@ -189,16 +189,16 @@ void sdbUpdateMnodeRoles() { sdbPrint("update mnodes:%d sync roles", tsSdbObj.cfg.replica); for (int32_t i = 0; i < tsSdbObj.cfg.replica; ++i) { - SMnodeObj *pMnode = mgmtGetMnode(roles.nodeId[i]); + SMnodeObj *pMnode = mnodeGetMnode(roles.nodeId[i]); if (pMnode != NULL) { pMnode->role = roles.role[i]; - sdbPrint("mnode:%d, role:%s", pMnode->mnodeId, mgmtGetMnodeRoleStr(pMnode->role)); + sdbPrint("mnode:%d, role:%s", pMnode->mnodeId, mnodeGetMnodeRoleStr(pMnode->role)); if (pMnode->mnodeId == dnodeGetDnodeId()) tsSdbObj.role = pMnode->role; - mgmtDecMnodeRef(pMnode); + mnodeDecMnodeRef(pMnode); } } - mgmtUpdateMnodeIpSet(); + mnodeUpdateMnodeIpSet(); } static uint32_t sdbGetFileInfo(void *ahandle, char *name, uint32_t *index, int32_t *size, uint64_t *fversion) { @@ -211,7 +211,7 @@ static int sdbGetWalInfo(void *ahandle, char *name, uint32_t *index) { } static void sdbNotifyRole(void *ahandle, int8_t role) { - sdbPrint("mnode role changed from %s to %s", mgmtGetMnodeRoleStr(tsSdbObj.role), mgmtGetMnodeRoleStr(role)); + sdbPrint("mnode role changed from %s to %s", mnodeGetMnodeRoleStr(tsSdbObj.role), mnodeGetMnodeRoleStr(role)); if (role == TAOS_SYNC_ROLE_MASTER && tsSdbObj.role != TAOS_SYNC_ROLE_MASTER) { balanceReset(); @@ -256,20 +256,20 @@ void sdbUpdateSync() { void *pIter = NULL; while (1) { SMnodeObj *pMnode = NULL; - pIter = mgmtGetNextMnode(pIter, &pMnode); + pIter = mnodeGetNextMnode(pIter, &pMnode); if (pMnode == NULL) break; syncCfg.nodeInfo[index].nodeId = pMnode->mnodeId; - SDnodeObj *pDnode = mgmtGetDnode(pMnode->mnodeId); + SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId); if (pDnode != NULL) { syncCfg.nodeInfo[index].nodePort = pDnode->dnodePort + TSDB_PORT_SYNC; strcpy(syncCfg.nodeInfo[index].nodeFqdn, pDnode->dnodeEp); index++; } - mgmtDecDnodeRef(pDnode); - mgmtDecMnodeRef(pMnode); + mnodeDecDnodeRef(pDnode); + mnodeDecMnodeRef(pMnode); } sdbFreeIter(pIter); } @@ -324,7 +324,7 @@ int32_t sdbInit() { sdbRestoreTables(); - if (mgmtGetMnodesNum() == 1) { + if (mnodeGetMnodesNum() == 1) { tsSdbObj.role = TAOS_SYNC_ROLE_MASTER; } diff --git a/src/mnode/src/mnodeShow.c b/src/mnode/src/mnodeShow.c index a629d02fdd..37bcd075a5 100644 --- a/src/mnode/src/mnodeShow.c +++ b/src/mnode/src/mnodeShow.c @@ -24,6 +24,7 @@ #include "tgrant.h" #include "tglobal.h" #include "tcache.h" +#include "mnode.h" #include "dnode.h" #include "mnodeDef.h" #include "mnodeInt.h" @@ -33,33 +34,38 @@ #include "mnodeMnode.h" #include "mnodeProfile.h" #include "mnodeSdb.h" -#include "mnodeShell.h" +#include "mnodeShow.h" #include "mnodeTable.h" #include "mnodeUser.h" #include "mnodeVgroup.h" +#include "mnodeWrite.h" +#include "mnodeRead.h" -typedef int32_t (*SShowMetaFp)(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -typedef int32_t (*SShowRetrieveFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn); +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 mnodeProcessShowMsg(SMnodeMsg *queuedMsg); -static void mnodeProcessRetrieveMsg(SMnodeMsg *queuedMsg); -static void mnodeProcessHeartBeatMsg(SMnodeMsg *queuedMsg); -static void mnodeProcessConnectMsg(SMnodeMsg *queuedMsg); -static void mnodeProcessUseMsg(SMnodeMsg *queuedMsg); -static void mnodeFreeShowObj(void *data); +static void mnodeFreeShowObj(void *data); +static bool mnodeCheckQhandle(uint64_t qhandle); +static void *mnodeSaveQhandle(void *qhandle, int32_t size); +static void mnodeFreeQhandle(void *qhandle, bool forceRemove); +extern void *tsMnodeTmr; static void *tsQhandleCache = NULL; -static SShowMetaFp tsMnodeShowMetaFp[TSDB_MNODE_TABLE_MAX] = {0}; -static SShowRetrieveFp tsMnodeShowRetrieveFp[TSDB_MNODE_TABLE_MAX] = {0}; +static SShowMetaFp tsMnodeShowMetaFp[TSDB_MGMT_TABLE_MAX] = {0}; +static SShowRetrieveFp tsMnodeShowRetrieveFp[TSDB_MGMT_TABLE_MAX] = {0}; -void mnodeInitShow() { +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); - tsQhandleCache = taosCacheInitWithCb(tsMgmtTmr, 10, mnodeFreeShowObj); + tsQhandleCache = taosCacheInitWithCb(tsMnodeTmr, 10, mnodeFreeShowObj); + return 0; } void mnodeCleanUpShow() { @@ -77,46 +83,43 @@ void mnodeAddShowRetrieveHandle(uint8_t msgType, SShowRetrieveFp fp) { tsMnodeShowRetrieveFp[msgType] = fp; } -char *mnodeGetShowType(int32_t showType) { +static char *mnodeGetShowType(int32_t showType) { switch (showType) { - case TSDB_MNODE_TABLE_ACCT: return "show accounts"; - case TSDB_MNODE_TABLE_USER: return "show users"; - case TSDB_MNODE_TABLE_DB: return "show databases"; - case TSDB_MNODE_TABLE_TABLE: return "show tables"; - case TSDB_MNODE_TABLE_DNODE: return "show dnodes"; - case TSDB_MNODE_TABLE_MNODE: return "show mnodes"; - case TSDB_MNODE_TABLE_VGROUP: return "show vgroups"; - case TSDB_MNODE_TABLE_METRIC: return "show stables"; - case TSDB_MNODE_TABLE_MODULE: return "show modules"; - case TSDB_MNODE_TABLE_QUERIES: return "show queries"; - case TSDB_MNODE_TABLE_STREAMS: return "show streams"; - case TSDB_MNODE_TABLE_CONFIGS: return "show configs"; - case TSDB_MNODE_TABLE_CONNS: return "show connections"; - case TSDB_MNODE_TABLE_SCORES: return "show scores"; - case TSDB_MNODE_TABLE_GRANTS: return "show grants"; - case TSDB_MNODE_TABLE_VNODES: return "show vnodes"; + 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_CONFIGS: 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"; default: return "undefined"; } } -static void mnodeProcessShowMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessShowMsg(SMnodeMsg *pMsg) { SCMShowMsg *pShowMsg = pMsg->pCont; - if (pShowMsg->type >= TSDB_MNODE_TABLE_MAX) { - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_MSG_TYPE); - return; + if (pShowMsg->type >= TSDB_MGMT_TABLE_MAX) { + return TSDB_CODE_INVALID_MSG_TYPE; } if (!tsMnodeShowMetaFp[pShowMsg->type] || !tsMnodeShowRetrieveFp[pShowMsg->type]) { mError("show type:%s is not support", mnodeGetShowType(pShowMsg->type)); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_OPS_NOT_SUPPORT); - return; + return TSDB_CODE_OPS_NOT_SUPPORT; } int32_t size = sizeof(SCMShowRsp) + sizeof(SSchema) * TSDB_MAX_COLUMNS + TSDB_EXTRA_PAYLOAD_SIZE; SCMShowRsp *pShowRsp = rpcMallocCont(size); if (pShowRsp == NULL) { - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY); - return; + return TSDB_CODE_SERV_OUT_OF_MEMORY; } int32_t showObjSize = sizeof(SShowObj) + htons(pShowMsg->payloadLen); @@ -127,31 +130,23 @@ static void mnodeProcessShowMsg(SMnodeMsg *pMsg) { strcpy(pShow->db, pShowMsg->db); memcpy(pShow->payload, pShowMsg->payload, pShow->payloadLen); - pShow = mgmtSaveQhandle(pShow, showObjSize); + pShow = mnodeSaveQhandle(pShow, showObjSize); pShowRsp->qhandle = htobe64((uint64_t) pShow); mTrace("show:%p, type:%s, start to get meta", pShow, mnodeGetShowType(pShowMsg->type)); int32_t code = (*tsMnodeShowMetaFp[pShowMsg->type])(&pShowRsp->tableMeta, pShow, pMsg->thandle); if (code == 0) { - SRpcMsg rpcRsp = { - .handle = pMsg->thandle, - .pCont = pShowRsp, - .contLen = sizeof(SCMShowRsp) + sizeof(SSchema) * pShow->numOfColumns, - .code = code - }; - rpcSendResponse(&rpcRsp); + pMsg->rpcRsp.rsp = pShowRsp; + pMsg->rpcRsp.len = sizeof(SCMShowRsp) + sizeof(SSchema) * pShow->numOfColumns; + return TSDB_CODE_SUCCESS; } else { mError("show:%p, type:%s, failed to get meta, reason:%s", pShow, mnodeGetShowType(pShowMsg->type), tstrerror(code)); - mgmtFreeQhandle(pShow, false); - SRpcMsg rpcRsp = { - .handle = pMsg->thandle, - .code = code - }; - rpcSendResponse(&rpcRsp); + mnodeFreeQhandle(pShow, true); + return code; } } -static void mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { int32_t rowsToRead = 0; int32_t size = 0; int32_t rowsRead = 0; @@ -162,10 +157,9 @@ static void mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { * in case of server restart, apps may hold qhandle created by server before * restart, which is actually invalid, therefore, signature check is required. */ - if (!mgmtCheckQhandle(pRetrieve->qhandle)) { + if (!mnodeCheckQhandle(pRetrieve->qhandle)) { mError("retrieve:%p, qhandle:%p is invalid", pRetrieve, pRetrieve->qhandle); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_QHANDLE); - return; + return TSDB_CODE_INVALID_QHANDLE; } SShowObj *pShow = (SShowObj *)pRetrieve->qhandle; @@ -192,41 +186,37 @@ static void mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) rowsRead = (*tsMnodeShowRetrieveFp[pShow->type])(pShow, pRsp->data, rowsToRead, pMsg->thandle); - if (rowsRead < 0) { // TSDB_CODE_ACTION_IN_PROGRESS; + if (rowsRead < 0) { rpcFreeCont(pRsp); - mgmtFreeQhandle(pShow, false); - return; + mnodeFreeQhandle(pShow, false); + assert(false); + return TSDB_CODE_ACTION_IN_PROGRESS; } pRsp->numOfRows = htonl(rowsRead); pRsp->precision = htonl(TSDB_TIME_PRECISION_MILLI); // millisecond time precision - SRpcMsg rpcRsp = { - .handle = pMsg->thandle, - .pCont = pRsp, - .contLen = size, - .code = 0, - .msgType = 0 - }; - rpcSendResponse(&rpcRsp); + pMsg->rpcRsp.rsp = pRsp; + pMsg->rpcRsp.len = size; if (rowsToRead == 0) { - mgmtFreeQhandle(pShow, true); + mnodeFreeQhandle(pShow, true); } else { - mgmtFreeQhandle(pShow, false); + mnodeFreeQhandle(pShow, false); } + + return TSDB_CODE_SUCCESS; } -static void mnodeProcessHeartBeatMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessHeartBeatMsg(SMnodeMsg *pMsg) { SCMHeartBeatRsp *pHBRsp = (SCMHeartBeatRsp *) rpcMallocCont(sizeof(SCMHeartBeatRsp)); if (pHBRsp == NULL) { - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY); - return; + return TSDB_CODE_SERV_OUT_OF_MEMORY; } - pHBRsp->onlineDnodes = htonl(mgmtGetOnlinDnodesNum()); - pHBRsp->totalDnodes = htonl(mgmtGetDnodesNum()); - mgmtGetMnodeIpSet(&pHBRsp->ipList); + pHBRsp->onlineDnodes = htonl(mnodeGetOnlinDnodesNum()); + pHBRsp->totalDnodes = htonl(mnodeGetDnodesNum()); + mnodeGetMnodeIpSetForShell(&pHBRsp->ipList); /* * TODO @@ -236,29 +226,20 @@ static void mnodeProcessHeartBeatMsg(SMnodeMsg *pMsg) { pHBRsp->streamId = 0; pHBRsp->killConnection = 0; - SRpcMsg rpcRsp = { - .handle = pMsg->thandle, - .pCont = pHBRsp, - .contLen = sizeof(SCMHeartBeatRsp), - .code = 0, - .msgType = 0 - }; - rpcSendResponse(&rpcRsp); + pMsg->rpcRsp.rsp = pHBRsp; + pMsg->rpcRsp.len = sizeof(SCMHeartBeatRsp); + + return TSDB_CODE_SUCCESS; } -static void mnodeProcessConnectMsg(SMnodeMsg *pMsg) { - SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; +static int32_t mnodeProcessConnectMsg(SMnodeMsg *pMsg) { SCMConnectMsg *pConnectMsg = pMsg->pCont; + int32_t code = TSDB_CODE_SUCCESS; SRpcConnInfo connInfo; if (rpcGetConnInfo(pMsg->thandle, &connInfo) != 0) { mError("thandle:%p is already released while process connect msg", pMsg->thandle); - return; - } - - int32_t code; - if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) { - code = TSDB_CODE_GRANT_EXPIRED; + code = TSDB_CODE_INVALID_MSG_CONTENT; goto connect_over; } @@ -273,12 +254,12 @@ static void mnodeProcessConnectMsg(SMnodeMsg *pMsg) { if (pConnectMsg->db[0]) { char dbName[TSDB_TABLE_ID_LEN * 3] = {0}; sprintf(dbName, "%x%s%s", pAcct->acctId, TS_PATH_DELIMITER, pConnectMsg->db); - SDbObj *pDb = mgmtGetDb(dbName); + SDbObj *pDb = mnodeGetDb(dbName); if (pDb == NULL) { code = TSDB_CODE_INVALID_DB; goto connect_over; } - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); } SCMConnectRsp *pConnectRsp = rpcMallocCont(sizeof(SCMConnectRsp)); @@ -292,92 +273,33 @@ static void mnodeProcessConnectMsg(SMnodeMsg *pMsg) { pConnectRsp->writeAuth = pUser->writeAuth; pConnectRsp->superAuth = pUser->superAuth; - mgmtGetMnodeIpSet(&pConnectRsp->ipList); - + mnodeGetMnodeIpSetForShell(&pConnectRsp->ipList); + connect_over: - rpcRsp.code = code; if (code != TSDB_CODE_SUCCESS) { mLError("user:%s login from %s, result:%s", connInfo.user, taosIpStr(connInfo.clientIp), tstrerror(code)); } else { mLPrint("user:%s login from %s, result:%s", connInfo.user, taosIpStr(connInfo.clientIp), tstrerror(code)); - rpcRsp.pCont = pConnectRsp; - rpcRsp.contLen = sizeof(SCMConnectRsp); + pMsg->rpcRsp.rsp = pConnectRsp; + pMsg->rpcRsp.len = sizeof(SCMConnectRsp); } - rpcSendResponse(&rpcRsp); + + return code; } -static void mnodeProcessUseMsg(SMnodeMsg *pMsg) { - SRpcMsg rpcRsp = {.handle = pMsg->thandle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; - +static int32_t mnodeProcessUseMsg(SMnodeMsg *pMsg) { SCMUseDbMsg *pUseDbMsg = pMsg->pCont; - - // todo check for priority of current user + int32_t code = TSDB_CODE_SUCCESS; - if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDb(pUseDbMsg->db); + if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pUseDbMsg->db); if (pMsg->pDb == NULL) { code = TSDB_CODE_INVALID_DB; } - - rpcRsp.code = code; - rpcSendResponse(&rpcRsp); + + return code; } -/** - * check if we need to add mgmtProcessTableMetaMsg into tranQueue, which will be executed one-by-one. - */ -static bool mgmtCheckTableMetaMsgReadOnly(SMnodeMsg *pMsg) { - SCMTableInfoMsg *pInfo = pMsg->pCont; - if (pMsg->pTable == NULL) pMsg->pTable = mgmtGetTable(pInfo->tableId); - if (pMsg->pTable != NULL) return true; - - // If table does not exists and autoCreate flag is set, we add the handler into task queue - int16_t autoCreate = htons(pInfo->createFlag); - if (autoCreate == 1) { - mTrace("table:%s auto created task added", pInfo->tableId); - return false; - } - - return true; -} - -static bool mgmtCheckMsgReadOnly(SMnodeMsg *pMsg) { - if (pMsg->msgType == TSDB_MSG_TYPE_CM_TABLE_META) { - return mgmtCheckTableMetaMsgReadOnly(pMsg); - } - - if (pMsg->msgType == TSDB_MSG_TYPE_CM_STABLE_VGROUP || pMsg->msgType == TSDB_MSG_TYPE_CM_RETRIEVE || - pMsg->msgType == TSDB_MSG_TYPE_CM_SHOW || pMsg->msgType == TSDB_MSG_TYPE_CM_TABLES_META || - pMsg->msgType == TSDB_MSG_TYPE_CM_CONNECT) { - return true; - } - - return false; -} - -static void mgmtProcessUnSupportMsg(SRpcMsg *rpcMsg) { - mError("%s is not processed in mnode shell", taosMsg[rpcMsg->msgType]); - SRpcMsg rpcRsp = { - .msgType = 0, - .pCont = 0, - .contLen = 0, - .code = TSDB_CODE_OPS_NOT_SUPPORT, - .handle = rpcMsg->handle - }; - rpcSendResponse(&rpcRsp); -} - -void mgmtSendSimpleResp(void *thandle, int32_t code) { - SRpcMsg rpcRsp = { - .msgType = 0, - .pCont = 0, - .contLen = 0, - .code = code, - .handle = thandle - }; - rpcSendResponse(&rpcRsp); -} - -bool mgmtCheckQhandle(uint64_t qhandle) { +static bool mnodeCheckQhandle(uint64_t qhandle) { void *pSaved = taosCacheAcquireByData(tsQhandleCache, (void *)qhandle); if (pSaved == (void *)qhandle) { mTrace("show:%p, is retrieved", qhandle); @@ -388,17 +310,17 @@ bool mgmtCheckQhandle(uint64_t qhandle) { } } -void* mgmtSaveQhandle(void *qhandle, int32_t size) { +static void *mnodeSaveQhandle(void *qhandle, int32_t size) { if (tsQhandleCache != NULL) { char key[24]; sprintf(key, "show:%p", qhandle); void *newQhandle = taosCachePut(tsQhandleCache, key, qhandle, size, 60); free(qhandle); - + mTrace("show:%p, is saved", newQhandle); return newQhandle; } - + return NULL; } @@ -408,60 +330,7 @@ static void mnodeFreeShowObj(void *data) { mTrace("show:%p, is destroyed", pShow); } -void mgmtFreeQhandle(void *qhandle, bool forceRemove) { +static void mnodeFreeQhandle(void *qhandle, bool forceRemove) { mTrace("show:%p, is released, force:%s", qhandle, forceRemove ? "true" : "false"); taosCacheRelease(tsQhandleCache, &qhandle, forceRemove); } - -void *mgmtMallocQueuedMsg(SRpcMsg *rpcMsg, SRspRet *pRet) { - SUserObj *pUser = mgmtGetUserFromConn(rpcMsg->handle); - if (pUser == NULL) { - terrno = TSDB_CODE_INVALID_USER; - return NULL; - } - - SMnodeMsg *pMsg = calloc(1, sizeof(SMnodeMsg)); - if (pMsg == NULL) { - terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; - return NULL; - } - - pMsg->thandle = rpcMsg->handle; - pMsg->msgType = rpcMsg->msgType; - pMsg->contLen = rpcMsg->contLen; - pMsg->pCont = rpcMsg->pCont; - pMsg->pUser = pUser; - pMsg->pRet = pRet; - - return pMsg; -} - -void mgmtFreeQueuedMsg(SMnodeMsg *pMsg) { - if (pMsg != NULL) { - rpcFreeCont(pMsg->pCont); - if (pMsg->pUser) mgmtDecUserRef(pMsg->pUser); - if (pMsg->pDb) mgmtDecDbRef(pMsg->pDb); - if (pMsg->pVgroup) mgmtDecVgroupRef(pMsg->pVgroup); - if (pMsg->pTable) mgmtDecTableRef(pMsg->pTable); - if (pMsg->pAcct) mgmtDecAcctRef(pMsg->pAcct); - if (pMsg->pDnode) mgmtDecDnodeRef(pMsg->pDnode); - free(pMsg); - } -} - -void* mgmtCloneQueuedMsg(SMnodeMsg *pSrcMsg) { - SMnodeMsg *pDestMsg = calloc(1, sizeof(SMnodeMsg)); - - pDestMsg->thandle = pSrcMsg->thandle; - pDestMsg->msgType = pSrcMsg->msgType; - pDestMsg->pCont = pSrcMsg->pCont; - pDestMsg->contLen = pSrcMsg->contLen; - pDestMsg->retry = pSrcMsg->retry; - pDestMsg->maxRetry= pSrcMsg->maxRetry; - pDestMsg->pUser = pSrcMsg->pUser; - - pSrcMsg->pCont = NULL; - pSrcMsg->pUser = NULL; - - return pDestMsg; -} diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c index 51161372fb..9399c29be8 100644 --- a/src/mnode/src/mnodeTable.c +++ b/src/mnode/src/mnodeTable.c @@ -24,64 +24,68 @@ #include "tname.h" #include "tidpool.h" #include "tglobal.h" +#include "tcompare.h" +#include "tdataformat.h" +#include "tgrant.h" #include "hash.h" +#include "mnode.h" #include "dnode.h" #include "mnodeDef.h" #include "mnodeInt.h" #include "mnodeAcct.h" #include "mnodeDb.h" #include "mnodeDnode.h" -#include "tgrant.h" #include "mnodeMnode.h" #include "mnodeProfile.h" #include "mnodeSdb.h" -#include "mnodeShell.h" +#include "mnodeShow.h" #include "mnodeTable.h" #include "mnodeUser.h" #include "mnodeVgroup.h" -#include "tcompare.h" -#include "tdataformat.h" +#include "mnodeWrite.h" +#include "mnodeRead.h" +#include "mnodePeer.h" static void * tsChildTableSdb; static void * tsSuperTableSdb; static int32_t tsChildTableUpdateSize; static int32_t tsSuperTableUpdateSize; -static void * mgmtGetChildTable(char *tableId); -static void * mgmtGetSuperTable(char *tableId); -static void * mgmtGetSuperTableByUid(uint64_t uid); -static void mgmtDropAllChildTablesInStable(SSuperTableObj *pStable); -static void mgmtAddTableIntoStable(SSuperTableObj *pStable, SChildTableObj *pCtable); -static void mgmtRemoveTableFromStable(SSuperTableObj *pStable, SChildTableObj *pCtable); +static void * mnodeGetChildTable(char *tableId); +static void * mnodeGetSuperTable(char *tableId); +static void * mnodeGetSuperTableByUid(uint64_t uid); +static void mnodeDropAllChildTablesInStable(SSuperTableObj *pStable); +static void mnodeAddTableIntoStable(SSuperTableObj *pStable, SChildTableObj *pCtable); +static void mnodeRemoveTableFromStable(SSuperTableObj *pStable, SChildTableObj *pCtable); -static int32_t mgmtGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static int32_t mgmtRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static int32_t mgmtRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static int32_t mgmtGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); +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 mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn); +static int32_t mnodeGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static void mgmtProcessCreateTableMsg(SMnodeMsg *queueMsg); -static void mgmtProcessCreateSuperTableMsg(SMnodeMsg *pMsg); -static void mgmtProcessCreateChildTableMsg(SMnodeMsg *pMsg); -static void mgmtProcessCreateChildTableRsp(SRpcMsg *rpcMsg); +static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *mnodeMsg); +static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg); +static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg); +static void mnodeProcessCreateChildTableRsp(SRpcMsg *rpcMsg); -static void mgmtProcessDropTableMsg(SMnodeMsg *queueMsg); -static void mgmtProcessDropSuperTableMsg(SMnodeMsg *pMsg); -static void mgmtProcessDropSuperTableRsp(SRpcMsg *rpcMsg); -static void mgmtProcessDropChildTableMsg(SMnodeMsg *pMsg); -static void mgmtProcessDropChildTableRsp(SRpcMsg *rpcMsg); +static int32_t mnodeProcessDropTableMsg(SMnodeMsg *mnodeMsg); +static int32_t mnodeProcessDropSuperTableMsg(SMnodeMsg *pMsg); +static void mnodeProcessDropSuperTableRsp(SRpcMsg *rpcMsg); +static int32_t mnodeProcessDropChildTableMsg(SMnodeMsg *pMsg); +static void mnodeProcessDropChildTableRsp(SRpcMsg *rpcMsg); -static void mgmtProcessSuperTableVgroupMsg(SMnodeMsg *queueMsg); -static void mgmtProcessMultiTableMetaMsg(SMnodeMsg *queueMsg); -static void mgmtProcessTableCfgMsg(SRpcMsg *rpcMsg); +static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *mnodeMsg); +static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *mnodeMsg); +static int32_t mnodeProcessTableCfgMsg(SMnodeMsg *mnodeMsg); -static void mgmtProcessTableMetaMsg(SMnodeMsg *queueMsg); -static void mgmtGetSuperTableMeta(SMnodeMsg *pMsg); -static void mgmtGetChildTableMeta(SMnodeMsg *pMsg); -static void mgmtAutoCreateChildTable(SMnodeMsg *pMsg); +static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *mnodeMsg); +static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg); +static int32_t mnodeGetChildTableMeta(SMnodeMsg *pMsg); +static int32_t mgmtAutoCreateChildTable(SMnodeMsg *pMsg); -static void mgmtProcessAlterTableMsg(SMnodeMsg *queueMsg); -static void mgmtProcessAlterTableRsp(SRpcMsg *rpcMsg); +static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *mnodeMsg); +static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg); -static int32_t mgmtFindSuperTableColumnIndex(SSuperTableObj *pStable, char *colName); +static int32_t mnodeFindSuperTableColumnIndex(SSuperTableObj *pStable, char *colName); static void mgmtDestroyChildTable(SChildTableObj *pTable) { tfree(pTable->info.tableId); @@ -90,39 +94,39 @@ static void mgmtDestroyChildTable(SChildTableObj *pTable) { tfree(pTable); } -static int32_t mgmtChildTableActionDestroy(SSdbOper *pOper) { +static int32_t mnodeChildTableActionDestroy(SSdbOper *pOper) { mgmtDestroyChildTable(pOper->pObj); return TSDB_CODE_SUCCESS; } -static int32_t mgmtChildTableActionInsert(SSdbOper *pOper) { +static int32_t mnodeChildTableActionInsert(SSdbOper *pOper) { SChildTableObj *pTable = pOper->pObj; - SVgObj *pVgroup = mgmtGetVgroup(pTable->vgId); + SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId); if (pVgroup == NULL) { mError("ctable:%s, not in vgId:%d", pTable->info.tableId, pTable->vgId); return TSDB_CODE_INVALID_VGROUP_ID; } - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); - SDbObj *pDb = mgmtGetDb(pVgroup->dbName); + SDbObj *pDb = mnodeGetDb(pVgroup->dbName); if (pDb == NULL) { mError("ctable:%s, vgId:%d not in db:%s", pTable->info.tableId, pVgroup->vgId, pVgroup->dbName); return TSDB_CODE_INVALID_DB; } - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); - SAcctObj *pAcct = mgmtGetAcct(pDb->acct); + SAcctObj *pAcct = mnodeGetAcct(pDb->acct); if (pAcct == NULL) { mError("ctable:%s, acct:%s not exists", pTable->info.tableId, pDb->acct); return TSDB_CODE_INVALID_ACCT; } - mgmtDecAcctRef(pAcct); + mnodeDecAcctRef(pAcct); if (pTable->info.type == TSDB_CHILD_TABLE) { // add ref - pTable->superTable = mgmtGetSuperTableByUid(pTable->suid); - mgmtAddTableIntoStable(pTable->superTable, pTable); + pTable->superTable = mnodeGetSuperTableByUid(pTable->suid); + mnodeAddTableIntoStable(pTable->superTable, pTable); grantAdd(TSDB_GRANT_TIMESERIES, pTable->superTable->numOfColumns - 1); pAcct->acctInfo.numOfTimeSeries += (pTable->superTable->numOfColumns - 1); } else { @@ -130,56 +134,56 @@ static int32_t mgmtChildTableActionInsert(SSdbOper *pOper) { pAcct->acctInfo.numOfTimeSeries += (pTable->numOfColumns - 1); } - mgmtAddTableIntoDb(pDb); - mgmtAddTableIntoVgroup(pVgroup, pTable); + mnodeAddTableIntoDb(pDb); + mnodeAddTableIntoVgroup(pVgroup, pTable); return TSDB_CODE_SUCCESS; } -static int32_t mgmtChildTableActionDelete(SSdbOper *pOper) { +static int32_t mnodeChildTableActionDelete(SSdbOper *pOper) { SChildTableObj *pTable = pOper->pObj; if (pTable->vgId == 0) { return TSDB_CODE_INVALID_VGROUP_ID; } - SVgObj *pVgroup = mgmtGetVgroup(pTable->vgId); + SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId); if (pVgroup == NULL) { return TSDB_CODE_INVALID_VGROUP_ID; } - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); - SDbObj *pDb = mgmtGetDb(pVgroup->dbName); + SDbObj *pDb = mnodeGetDb(pVgroup->dbName); if (pDb == NULL) { mError("ctable:%s, vgId:%d not in DB:%s", pTable->info.tableId, pVgroup->vgId, pVgroup->dbName); return TSDB_CODE_INVALID_DB; } - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); - SAcctObj *pAcct = mgmtGetAcct(pDb->acct); + SAcctObj *pAcct = mnodeGetAcct(pDb->acct); if (pAcct == NULL) { mError("ctable:%s, acct:%s not exists", pTable->info.tableId, pDb->acct); return TSDB_CODE_INVALID_ACCT; } - mgmtDecAcctRef(pAcct); + mnodeDecAcctRef(pAcct); if (pTable->info.type == TSDB_CHILD_TABLE) { grantRestore(TSDB_GRANT_TIMESERIES, pTable->superTable->numOfColumns - 1); pAcct->acctInfo.numOfTimeSeries -= (pTable->superTable->numOfColumns - 1); - mgmtRemoveTableFromStable(pTable->superTable, pTable); - mgmtDecTableRef(pTable->superTable); + mnodeRemoveTableFromStable(pTable->superTable, pTable); + mnodeDecTableRef(pTable->superTable); } else { grantRestore(TSDB_GRANT_TIMESERIES, pTable->numOfColumns - 1); pAcct->acctInfo.numOfTimeSeries -= (pTable->numOfColumns - 1); } - mgmtRemoveTableFromDb(pDb); - mgmtRemoveTableFromVgroup(pVgroup, pTable); + mnodeRemoveTableFromDb(pDb); + mnodeRemoveTableFromVgroup(pVgroup, pTable); return TSDB_CODE_SUCCESS; } -static int32_t mgmtChildTableActionUpdate(SSdbOper *pOper) { +static int32_t mnodeChildTableActionUpdate(SSdbOper *pOper) { SChildTableObj *pNew = pOper->pObj; - SChildTableObj *pTable = mgmtGetChildTable(pNew->info.tableId); + SChildTableObj *pTable = mnodeGetChildTable(pNew->info.tableId); if (pTable != pNew) { void *oldTableId = pTable->info.tableId; void *oldSql = pTable->sql; @@ -192,12 +196,12 @@ static int32_t mgmtChildTableActionUpdate(SSdbOper *pOper) { free(oldSchema); free(oldTableId); } - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); return TSDB_CODE_SUCCESS; } -static int32_t mgmtChildTableActionEncode(SSdbOper *pOper) { +static int32_t mnodeChildTableActionEncode(SSdbOper *pOper) { SChildTableObj *pTable = pOper->pObj; assert(pTable != NULL && pOper->rowData != NULL); @@ -227,7 +231,7 @@ static int32_t mgmtChildTableActionEncode(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtChildTableActionDecode(SSdbOper *pOper) { +static int32_t mnodeChildTableActionDecode(SSdbOper *pOper) { assert(pOper->rowData != NULL); SChildTableObj *pTable = calloc(1, sizeof(SChildTableObj)); if (pTable == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; @@ -264,34 +268,34 @@ static int32_t mgmtChildTableActionDecode(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtChildTableActionRestored() { +static int32_t mnodeChildTableActionRestored() { void *pIter = NULL; SChildTableObj *pTable = NULL; while (1) { - pIter = mgmtGetNextChildTable(pIter, &pTable); + pIter = mnodeGetNextChildTable(pIter, &pTable); if (pTable == NULL) break; - SDbObj *pDb = mgmtGetDbByTableId(pTable->info.tableId); + SDbObj *pDb = mnodeGetDbByTableId(pTable->info.tableId); if (pDb == NULL) { mError("ctable:%s, failed to get db, discard it", pTable->info.tableId); SSdbOper desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .table = tsChildTableSdb}; sdbDeleteRow(&desc); - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); continue; } - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); - SVgObj *pVgroup = mgmtGetVgroup(pTable->vgId); + SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId); if (pVgroup == NULL) { mError("ctable:%s, failed to get vgId:%d sid:%d, discard it", pTable->info.tableId, pTable->vgId, pTable->sid); pTable->vgId = 0; SSdbOper desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .table = tsChildTableSdb}; sdbDeleteRow(&desc); - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); continue; } - mgmtDecVgroupRef(pVgroup); + 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", @@ -299,7 +303,7 @@ static int32_t mgmtChildTableActionRestored() { pTable->vgId = 0; SSdbOper desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .table = tsChildTableSdb}; sdbDeleteRow(&desc); - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); continue; } @@ -308,24 +312,24 @@ static int32_t mgmtChildTableActionRestored() { pTable->vgId = 0; SSdbOper desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .table = tsChildTableSdb}; sdbDeleteRow(&desc); - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); continue; } if (pTable->info.type == TSDB_CHILD_TABLE) { - SSuperTableObj *pSuperTable = mgmtGetSuperTableByUid(pTable->suid); + SSuperTableObj *pSuperTable = mnodeGetSuperTableByUid(pTable->suid); if (pSuperTable == NULL) { mError("ctable:%s, stable:%" PRIu64 " not exist", pTable->info.tableId, pTable->suid); pTable->vgId = 0; SSdbOper desc = {.type = SDB_OPER_LOCAL, .pObj = pTable, .table = tsChildTableSdb}; sdbDeleteRow(&desc); - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); continue; } - mgmtDecTableRef(pSuperTable); + mnodeDecTableRef(pSuperTable); } - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); } sdbFreeIter(pIter); @@ -333,7 +337,7 @@ static int32_t mgmtChildTableActionRestored() { return 0; } -static int32_t mgmtInitChildTables() { +static int32_t mnodeInitChildTables() { SChildTableObj tObj; tsChildTableUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj.info.type; @@ -344,13 +348,13 @@ static int32_t mgmtInitChildTables() { .maxRowSize = sizeof(SChildTableObj) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16) + TSDB_TABLE_ID_LEN + TSDB_CQ_SQL_SIZE, .refCountPos = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj, .keyType = SDB_KEY_VAR_STRING, - .insertFp = mgmtChildTableActionInsert, - .deleteFp = mgmtChildTableActionDelete, - .updateFp = mgmtChildTableActionUpdate, - .encodeFp = mgmtChildTableActionEncode, - .decodeFp = mgmtChildTableActionDecode, - .destroyFp = mgmtChildTableActionDestroy, - .restoredFp = mgmtChildTableActionRestored + .insertFp = mnodeChildTableActionInsert, + .deleteFp = mnodeChildTableActionDelete, + .updateFp = mnodeChildTableActionUpdate, + .encodeFp = mnodeChildTableActionEncode, + .decodeFp = mnodeChildTableActionDecode, + .destroyFp = mnodeChildTableActionDestroy, + .restoredFp = mnodeChildTableActionRestored }; tsChildTableSdb = sdbOpenTable(&tableDesc); @@ -363,11 +367,11 @@ static int32_t mgmtInitChildTables() { return 0; } -static void mgmtCleanUpChildTables() { +static void mnodeCleanupChildTables() { sdbCloseTable(tsChildTableSdb); } -static void mgmtAddTableIntoStable(SSuperTableObj *pStable, SChildTableObj *pCtable) { +static void mnodeAddTableIntoStable(SSuperTableObj *pStable, SChildTableObj *pCtable) { pStable->numOfTables++; if (pStable->vgHash == NULL) { @@ -379,16 +383,16 @@ static void mgmtAddTableIntoStable(SSuperTableObj *pStable, SChildTableObj *pCta } } -static void mgmtRemoveTableFromStable(SSuperTableObj *pStable, SChildTableObj *pCtable) { +static void mnodeRemoveTableFromStable(SSuperTableObj *pStable, SChildTableObj *pCtable) { pStable->numOfTables--; if (pStable->vgHash == NULL) return; - SVgObj *pVgroup = mgmtGetVgroup(pCtable->vgId); + SVgObj *pVgroup = mnodeGetVgroup(pCtable->vgId); if (pVgroup == NULL) { taosHashRemove(pStable->vgHash, (char *)&pCtable->vgId, sizeof(pCtable->vgId)); } - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); } static void mgmtDestroySuperTable(SSuperTableObj *pStable) { @@ -401,37 +405,37 @@ static void mgmtDestroySuperTable(SSuperTableObj *pStable) { tfree(pStable); } -static int32_t mgmtSuperTableActionDestroy(SSdbOper *pOper) { +static int32_t mnodeSuperTableActionDestroy(SSdbOper *pOper) { mgmtDestroySuperTable(pOper->pObj); return TSDB_CODE_SUCCESS; } -static int32_t mgmtSuperTableActionInsert(SSdbOper *pOper) { +static int32_t mnodeSuperTableActionInsert(SSdbOper *pOper) { SSuperTableObj *pStable = pOper->pObj; - SDbObj *pDb = mgmtGetDbByTableId(pStable->info.tableId); + SDbObj *pDb = mnodeGetDbByTableId(pStable->info.tableId); if (pDb != NULL) { - mgmtAddSuperTableIntoDb(pDb); + mnodeAddSuperTableIntoDb(pDb); } - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); return TSDB_CODE_SUCCESS; } -static int32_t mgmtSuperTableActionDelete(SSdbOper *pOper) { +static int32_t mnodeSuperTableActionDelete(SSdbOper *pOper) { SSuperTableObj *pStable = pOper->pObj; - SDbObj *pDb = mgmtGetDbByTableId(pStable->info.tableId); + SDbObj *pDb = mnodeGetDbByTableId(pStable->info.tableId); if (pDb != NULL) { - mgmtRemoveSuperTableFromDb(pDb); - mgmtDropAllChildTablesInStable((SSuperTableObj *)pStable); + mnodeRemoveSuperTableFromDb(pDb); + mnodeDropAllChildTablesInStable((SSuperTableObj *)pStable); } - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); return TSDB_CODE_SUCCESS; } -static int32_t mgmtSuperTableActionUpdate(SSdbOper *pOper) { +static int32_t mnodeSuperTableActionUpdate(SSdbOper *pOper) { SSuperTableObj *pNew = pOper->pObj; - SSuperTableObj *pTable = mgmtGetSuperTable(pNew->info.tableId); + SSuperTableObj *pTable = mnodeGetSuperTable(pNew->info.tableId); if (pTable != pNew) { void *oldTableId = pTable->info.tableId; void *oldSchema = pTable->schema; @@ -442,11 +446,11 @@ static int32_t mgmtSuperTableActionUpdate(SSdbOper *pOper) { free(oldTableId); free(oldSchema); } - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); return TSDB_CODE_SUCCESS; } -static int32_t mgmtSuperTableActionEncode(SSdbOper *pOper) { +static int32_t mnodeSuperTableActionEncode(SSdbOper *pOper) { SSuperTableObj *pStable = pOper->pObj; assert(pOper->pObj != NULL && pOper->rowData != NULL); @@ -469,7 +473,7 @@ static int32_t mgmtSuperTableActionEncode(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtSuperTableActionDecode(SSdbOper *pOper) { +static int32_t mnodeSuperTableActionDecode(SSdbOper *pOper) { assert(pOper->rowData != NULL); SSuperTableObj *pStable = (SSuperTableObj *) calloc(1, sizeof(SSuperTableObj)); if (pStable == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; @@ -496,11 +500,11 @@ static int32_t mgmtSuperTableActionDecode(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtSuperTableActionRestored() { +static int32_t mnodeSuperTableActionRestored() { return 0; } -static int32_t mgmtInitSuperTables() { +static int32_t mnodeInitSuperTables() { SSuperTableObj tObj; tsSuperTableUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj.info.type; @@ -511,13 +515,13 @@ static int32_t mgmtInitSuperTables() { .maxRowSize = sizeof(SSuperTableObj) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16) + TSDB_TABLE_ID_LEN, .refCountPos = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj, .keyType = SDB_KEY_VAR_STRING, - .insertFp = mgmtSuperTableActionInsert, - .deleteFp = mgmtSuperTableActionDelete, - .updateFp = mgmtSuperTableActionUpdate, - .encodeFp = mgmtSuperTableActionEncode, - .decodeFp = mgmtSuperTableActionDecode, - .destroyFp = mgmtSuperTableActionDestroy, - .restoredFp = mgmtSuperTableActionRestored + .insertFp = mnodeSuperTableActionInsert, + .deleteFp = mnodeSuperTableActionDelete, + .updateFp = mnodeSuperTableActionUpdate, + .encodeFp = mnodeSuperTableActionEncode, + .decodeFp = mnodeSuperTableActionDecode, + .destroyFp = mnodeSuperTableActionDestroy, + .restoredFp = mnodeSuperTableActionRestored }; tsSuperTableSdb = sdbOpenTable(&tableDesc); @@ -530,63 +534,63 @@ static int32_t mgmtInitSuperTables() { return 0; } -static void mgmtCleanUpSuperTables() { +static void mnodeCleanupSuperTables() { sdbCloseTable(tsSuperTableSdb); } -int32_t mgmtInitTables() { - int32_t code = mgmtInitSuperTables(); +int32_t mnodeInitTables() { + int32_t code = mnodeInitSuperTables(); if (code != TSDB_CODE_SUCCESS) { return code; } - code = mgmtInitChildTables(); + code = mnodeInitChildTables(); if (code != TSDB_CODE_SUCCESS) { return code; } - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_TABLES_META, mgmtProcessMultiTableMetaMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_TABLE, mgmtProcessCreateTableMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_DROP_TABLE, mgmtProcessDropTableMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_ALTER_TABLE, mgmtProcessAlterTableMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_TABLE_META, mgmtProcessTableMetaMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_STABLE_VGROUP, mgmtProcessSuperTableVgroupMsg); + 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); - dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_CREATE_TABLE_RSP, mgmtProcessCreateChildTableRsp); - dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_DROP_TABLE_RSP, mgmtProcessDropChildTableRsp); - dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_DROP_STABLE_RSP, mgmtProcessDropSuperTableRsp); - dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_ALTER_TABLE_RSP, mgmtProcessAlterTableRsp); + 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); - dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_TABLE, mgmtProcessTableCfgMsg); + mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_TABLE, mnodeProcessTableCfgMsg); - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_TABLE, mgmtGetShowTableMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_TABLE, mgmtRetrieveShowTables); - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_METRIC, mgmtGetShowSuperTableMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_METRIC, mgmtRetrieveShowSuperTables); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_TABLE, mnodeGetShowTableMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_TABLE, mnodeRetrieveShowTables); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_METRIC, mnodeGetShowSuperTableMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_METRIC, mnodeRetrieveShowSuperTables); return TSDB_CODE_SUCCESS; } -static void *mgmtGetChildTable(char *tableId) { +static void *mnodeGetChildTable(char *tableId) { return sdbGetRow(tsChildTableSdb, tableId); } -static void *mgmtGetSuperTable(char *tableId) { +static void *mnodeGetSuperTable(char *tableId) { return sdbGetRow(tsSuperTableSdb, tableId); } -static void *mgmtGetSuperTableByUid(uint64_t uid) { +static void *mnodeGetSuperTableByUid(uint64_t uid) { SSuperTableObj *pStable = NULL; void *pIter = NULL; while (1) { - pIter = mgmtGetNextSuperTable(pIter, &pStable); + pIter = mnodeGetNextSuperTable(pIter, &pStable); if (pStable == NULL) break; if (pStable->uid == uid) { sdbFreeIter(pIter); return pStable; } - mgmtDecTableRef(pStable); + mnodeDecTableRef(pStable); } sdbFreeIter(pIter); @@ -594,13 +598,13 @@ static void *mgmtGetSuperTableByUid(uint64_t uid) { return NULL; } -void *mgmtGetTable(char *tableId) { - void *pTable = mgmtGetSuperTable(tableId); +void *mnodeGetTable(char *tableId) { + void *pTable = mnodeGetSuperTable(tableId); if (pTable != NULL) { return pTable; } - pTable = mgmtGetChildTable(tableId); + pTable = mnodeGetChildTable(tableId); if (pTable != NULL) { return pTable; } @@ -608,15 +612,15 @@ void *mgmtGetTable(char *tableId) { return NULL; } -void *mgmtGetNextChildTable(void *pIter, SChildTableObj **pTable) { +void *mnodeGetNextChildTable(void *pIter, SChildTableObj **pTable) { return sdbFetchRow(tsChildTableSdb, pIter, (void **)pTable); } -void *mgmtGetNextSuperTable(void *pIter, SSuperTableObj **pTable) { +void *mnodeGetNextSuperTable(void *pIter, SSuperTableObj **pTable) { return sdbFetchRow(tsSuperTableSdb, pIter, (void **)pTable); } -void mgmtIncTableRef(void *p1) { +void mnodeIncTableRef(void *p1) { STableObj *pTable = (STableObj *)p1; if (pTable->type == TSDB_SUPER_TABLE) { sdbIncRef(tsSuperTableSdb, pTable); @@ -625,7 +629,7 @@ void mgmtIncTableRef(void *p1) { } } -void mgmtDecTableRef(void *p1) { +void mnodeDecTableRef(void *p1) { if (p1 == NULL) return; STableObj *pTable = (STableObj *)p1; @@ -636,9 +640,9 @@ void mgmtDecTableRef(void *p1) { } } -void mgmtCleanUpTables() { - mgmtCleanUpChildTables(); - mgmtCleanUpSuperTables(); +void mnodeCleanupTables() { + mnodeCleanupChildTables(); + mnodeCleanupSuperTables(); } // todo move to name.h, add length of table name @@ -655,113 +659,105 @@ static void mgmtExtractTableName(char* tableId, char* name) { } } -static void mgmtProcessCreateTableMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) { SCMCreateTableMsg *pCreate = pMsg->pCont; - if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDb(pCreate->db); + if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pCreate->db); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { mError("table:%s, failed to create, db not selected", pCreate->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_DB_NOT_SELECTED); - return; + return TSDB_CODE_DB_NOT_SELECTED; } - if (pMsg->pTable == NULL) pMsg->pTable = mgmtGetTable(pCreate->tableId); + if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pCreate->tableId); if (pMsg->pTable != NULL && pMsg->retry == 0) { if (pCreate->getMeta) { mTrace("table:%s, continue to get meta", pCreate->tableId); - mgmtGetChildTableMeta(pMsg); + return mnodeGetChildTableMeta(pMsg); } else if (pCreate->igExists) { mTrace("table:%s, is already exist", pCreate->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SUCCESS); + return TSDB_CODE_SUCCESS; } else { mError("table:%s, failed to create, table already exist", pCreate->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_TABLE_ALREADY_EXIST); + return TSDB_CODE_TABLE_ALREADY_EXIST; } - return; } if (pCreate->numOfTags != 0) { mTrace("table:%s, create msg is received from thandle:%p", pCreate->tableId, pMsg->thandle); - mgmtProcessCreateSuperTableMsg(pMsg); + return mnodeProcessCreateSuperTableMsg(pMsg); } else { mTrace("table:%s, create msg is received from thandle:%p", pCreate->tableId, pMsg->thandle); - mgmtProcessCreateChildTableMsg(pMsg); + return mnodeProcessCreateChildTableMsg(pMsg); } } -static void mgmtProcessDropTableMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessDropTableMsg(SMnodeMsg *pMsg) { SCMDropTableMsg *pDrop = pMsg->pCont; - if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDbByTableId(pDrop->tableId); + if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableId(pDrop->tableId); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { mError("table:%s, failed to drop table, db not selected", pDrop->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_DB_NOT_SELECTED); - return; + return TSDB_CODE_DB_NOT_SELECTED; } - if (mgmtCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) { + if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) { mError("table:%s, failed to drop table, in monitor database", pDrop->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_MONITOR_DB_FORBIDDEN); - return; + return TSDB_CODE_MONITOR_DB_FORBIDDEN; } - if (pMsg->pTable == NULL) pMsg->pTable = mgmtGetTable(pDrop->tableId); + if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pDrop->tableId); if (pMsg->pTable == NULL) { if (pDrop->igNotExists) { mTrace("table:%s, table is not exist, think drop success", pDrop->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SUCCESS); - return; + return TSDB_CODE_SUCCESS; } else { mError("table:%s, failed to drop table, table not exist", pDrop->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_TABLE); - return; + return TSDB_CODE_INVALID_TABLE; } } if (pMsg->pTable->type == TSDB_SUPER_TABLE) { mPrint("table:%s, start to drop stable", pDrop->tableId); - mgmtProcessDropSuperTableMsg(pMsg); + return mnodeProcessDropSuperTableMsg(pMsg); } else { mPrint("table:%s, start to drop ctable", pDrop->tableId); - mgmtProcessDropChildTableMsg(pMsg); + return mnodeProcessDropChildTableMsg(pMsg); } } -static void mgmtProcessTableMetaMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *pMsg) { SCMTableInfoMsg *pInfo = pMsg->pCont; pInfo->createFlag = htons(pInfo->createFlag); mTrace("table:%s, table meta msg is received from thandle:%p, createFlag:%d", pInfo->tableId, pMsg->thandle, pInfo->createFlag); - if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDbByTableId(pInfo->tableId); + if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableId(pInfo->tableId); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { mError("table:%s, failed to get table meta, db not selected", pInfo->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_DB_NOT_SELECTED); - return; + return TSDB_CODE_DB_NOT_SELECTED; } - if (pMsg->pTable == NULL) pMsg->pTable = mgmtGetTable(pInfo->tableId); + if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pInfo->tableId); if (pMsg->pTable == NULL) { if (!pInfo->createFlag) { mError("table:%s, failed to get table meta, table not exist", pInfo->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_TABLE); + return TSDB_CODE_INVALID_TABLE; } else { - mgmtAutoCreateChildTable(pMsg); + return mgmtAutoCreateChildTable(pMsg); } } else { if (pMsg->pTable->type != TSDB_SUPER_TABLE) { - mgmtGetChildTableMeta(pMsg); + return mnodeGetChildTableMeta(pMsg); } else { - mgmtGetSuperTableMeta(pMsg); + return mnodeGetSuperTableMeta(pMsg); } } } -static void mgmtProcessCreateSuperTableMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) { SCMCreateTableMsg *pCreate = pMsg->pCont; SSuperTableObj *pStable = calloc(1, sizeof(SSuperTableObj)); if (pStable == NULL) { mError("table:%s, failed to create, no enough memory", pCreate->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY); - return; + return TSDB_CODE_SERV_OUT_OF_MEMORY; } pStable->info.tableId = strdup(pCreate->tableId); @@ -779,8 +775,7 @@ static void mgmtProcessCreateSuperTableMsg(SMnodeMsg *pMsg) { if (pStable->schema == NULL) { free(pStable); mError("table:%s, failed to create, no schema input", pCreate->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_TABLE); - return; + return TSDB_CODE_INVALID_TABLE; } memcpy(pStable->schema, pCreate->schema, numOfCols * sizeof(SSchema)); @@ -805,20 +800,20 @@ static void mgmtProcessCreateSuperTableMsg(SMnodeMsg *pMsg) { if (code != TSDB_CODE_SUCCESS) { mgmtDestroySuperTable(pStable); mError("table:%s, failed to create, sdb error", pCreate->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SDB_ERROR); + return TSDB_CODE_SDB_ERROR; } else { mLPrint("table:%s, is created, tags:%d fields:%d", pStable->info.tableId, pStable->numOfTags, pStable->numOfColumns); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SUCCESS); + return TSDB_CODE_SUCCESS; } } -static void mgmtProcessDropSuperTableMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessDropSuperTableMsg(SMnodeMsg *pMsg) { SSuperTableObj *pStable = (SSuperTableObj *)pMsg->pTable; if (pStable->numOfTables != 0) { SHashMutableIterator *pIter = taosHashCreateIter(pStable->vgHash); while (taosHashIterNext(pIter)) { int32_t *pVgId = taosHashIterGet(pIter); - SVgObj *pVgroup = mgmtGetVgroup(*pVgId); + SVgObj *pVgroup = mnodeGetVgroup(*pVgId); if (pVgroup == NULL) break; SMDDropSTableMsg *pDrop = rpcMallocCont(sizeof(SMDDropSTableMsg)); @@ -828,14 +823,14 @@ static void mgmtProcessDropSuperTableMsg(SMnodeMsg *pMsg) { mgmtExtractTableName(pStable->info.tableId, pDrop->tableId); mPrint("stable:%s, send drop stable msg to vgId:%d", pStable->info.tableId, pVgroup->vgId); - SRpcIpSet ipSet = mgmtGetIpSetFromVgroup(pVgroup); + SRpcIpSet ipSet = mnodeGetIpSetFromVgroup(pVgroup); SRpcMsg rpcMsg = {.pCont = pDrop, .contLen = sizeof(SMDDropSTableMsg), .msgType = TSDB_MSG_TYPE_MD_DROP_STABLE}; dnodeSendMsgToDnode(&ipSet, &rpcMsg); - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); } taosHashDestroyIter(pIter); - mgmtDropAllChildTablesInStable(pStable); + mnodeDropAllChildTablesInStable(pStable); } SSdbOper oper = { @@ -846,10 +841,10 @@ static void mgmtProcessDropSuperTableMsg(SMnodeMsg *pMsg) { int32_t code = sdbDeleteRow(&oper); mLPrint("stable:%s, is dropped from sdb, result:%s", pStable->info.tableId, tstrerror(code)); - mgmtSendSimpleResp(pMsg->thandle, code); + return code; } -static int32_t mgmtFindSuperTableTagIndex(SSuperTableObj *pStable, const char *tagName) { +static int32_t mnodeFindSuperTableTagIndex(SSuperTableObj *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) { @@ -860,19 +855,19 @@ static int32_t mgmtFindSuperTableTagIndex(SSuperTableObj *pStable, const char *t return -1; } -static int32_t mgmtAddSuperTableTag(SSuperTableObj *pStable, SSchema schema[], int32_t ntags) { +static int32_t mnodeAddSuperTableTag(SSuperTableObj *pStable, SSchema schema[], int32_t ntags) { if (pStable->numOfTags + ntags > TSDB_MAX_TAGS) { mError("stable:%s, add tag, too many tags", pStable->info.tableId); return TSDB_CODE_TOO_MANY_TAGS; } for (int32_t i = 0; i < ntags; i++) { - if (mgmtFindSuperTableColumnIndex(pStable, schema[i].name) > 0) { + if (mnodeFindSuperTableColumnIndex(pStable, schema[i].name) > 0) { mError("stable:%s, add tag, column:%s already exist", pStable->info.tableId, schema[i].name); return TSDB_CODE_TAG_ALREAY_EXIST; } - if (mgmtFindSuperTableTagIndex(pStable, schema[i].name) > 0) { + if (mnodeFindSuperTableTagIndex(pStable, schema[i].name) > 0) { mError("stable:%s, add tag, tag:%s already exist", pStable->info.tableId, schema[i].name); return TSDB_CODE_FIELD_ALREAY_EXIST; } @@ -906,8 +901,8 @@ static int32_t mgmtAddSuperTableTag(SSuperTableObj *pStable, SSchema schema[], i return TSDB_CODE_SUCCESS; } -static int32_t mgmtDropSuperTableTag(SSuperTableObj *pStable, char *tagName) { - int32_t col = mgmtFindSuperTableTagIndex(pStable, tagName); +static int32_t mnodeDropSuperTableTag(SSuperTableObj *pStable, char *tagName) { + int32_t col = mnodeFindSuperTableTagIndex(pStable, tagName); if (col < 0) { mError("stable:%s, drop tag, tag:%s not exist", pStable->info.tableId, tagName); return TSDB_CODE_TAG_NOT_EXIST; @@ -933,8 +928,8 @@ static int32_t mgmtDropSuperTableTag(SSuperTableObj *pStable, char *tagName) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtModifySuperTableTagName(SSuperTableObj *pStable, char *oldTagName, char *newTagName) { - int32_t col = mgmtFindSuperTableTagIndex(pStable, oldTagName); +static int32_t mnodeModifySuperTableTagName(SSuperTableObj *pStable, char *oldTagName, char *newTagName) { + int32_t col = mnodeFindSuperTableTagIndex(pStable, oldTagName); if (col < 0) { mError("stable:%s, failed to modify table tag, oldName: %s, newName: %s", pStable->info.tableId, oldTagName, newTagName); return TSDB_CODE_TAG_NOT_EXIST; @@ -946,7 +941,7 @@ static int32_t mgmtModifySuperTableTagName(SSuperTableObj *pStable, char *oldTag return TSDB_CODE_COL_NAME_TOO_LONG; } - if (mgmtFindSuperTableTagIndex(pStable, newTagName) >= 0) { + if (mnodeFindSuperTableTagIndex(pStable, newTagName) >= 0) { return TSDB_CODE_TAG_ALREAY_EXIST; } @@ -969,7 +964,7 @@ static int32_t mgmtModifySuperTableTagName(SSuperTableObj *pStable, char *oldTag return TSDB_CODE_SUCCESS; } -static int32_t mgmtFindSuperTableColumnIndex(SSuperTableObj *pStable, char *colName) { +static int32_t mnodeFindSuperTableColumnIndex(SSuperTableObj *pStable, char *colName) { SSchema *schema = (SSchema *) pStable->schema; for (int32_t col = 0; col < pStable->numOfColumns; col++) { if (strcasecmp(schema[col].name, colName) == 0) { @@ -980,19 +975,19 @@ static int32_t mgmtFindSuperTableColumnIndex(SSuperTableObj *pStable, char *colN return -1; } -static int32_t mgmtAddSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, SSchema schema[], int32_t ncols) { +static int32_t mnodeAddSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, SSchema schema[], int32_t ncols) { if (ncols <= 0) { mError("stable:%s, add column, ncols:%d <= 0", pStable->info.tableId); return TSDB_CODE_APP_ERROR; } for (int32_t i = 0; i < ncols; i++) { - if (mgmtFindSuperTableColumnIndex(pStable, schema[i].name) > 0) { + if (mnodeFindSuperTableColumnIndex(pStable, schema[i].name) > 0) { mError("stable:%s, add column, column:%s already exist", pStable->info.tableId, schema[i].name); return TSDB_CODE_FIELD_ALREAY_EXIST; } - if (mgmtFindSuperTableTagIndex(pStable, schema[i].name) > 0) { + if (mnodeFindSuperTableTagIndex(pStable, schema[i].name) > 0) { mError("stable:%s, add column, tag:%s already exist", pStable->info.tableId, schema[i].name); return TSDB_CODE_TAG_ALREAY_EXIST; } @@ -1013,10 +1008,10 @@ static int32_t mgmtAddSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, SSc pStable->numOfColumns += ncols; pStable->sversion++; - SAcctObj *pAcct = mgmtGetAcct(pDb->acct); + SAcctObj *pAcct = mnodeGetAcct(pDb->acct); if (pAcct != NULL) { pAcct->acctInfo.numOfTimeSeries += (ncols * pStable->numOfTables); - mgmtDecAcctRef(pAcct); + mnodeDecAcctRef(pAcct); } SSdbOper oper = { @@ -1034,8 +1029,8 @@ static int32_t mgmtAddSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, SSc return TSDB_CODE_SUCCESS; } -static int32_t mgmtDropSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, char *colName) { - int32_t col = mgmtFindSuperTableColumnIndex(pStable, colName); +static int32_t mnodeDropSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, char *colName) { + int32_t col = mnodeFindSuperTableColumnIndex(pStable, colName); if (col <= 0) { mError("stable:%s, drop column, column:%s not exist", pStable->info.tableId, colName); return TSDB_CODE_FIELD_NOT_EXIST; @@ -1050,10 +1045,10 @@ static int32_t mgmtDropSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, ch int32_t schemaSize = sizeof(SSchema) * (pStable->numOfTags + pStable->numOfColumns); pStable->schema = realloc(pStable->schema, schemaSize); - SAcctObj *pAcct = mgmtGetAcct(pDb->acct); + SAcctObj *pAcct = mnodeGetAcct(pDb->acct); if (pAcct != NULL) { pAcct->acctInfo.numOfTimeSeries -= pStable->numOfTables; - mgmtDecAcctRef(pAcct); + mnodeDecAcctRef(pAcct); } SSdbOper oper = { @@ -1072,8 +1067,8 @@ static int32_t mgmtDropSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, ch } // show super tables -static int32_t mgmtGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { - SDbObj *pDb = mgmtGetDb(pShow->db); +static int32_t mnodeGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { + SDbObj *pDb = mnodeGetDb(pShow->db); if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED; int32_t cols = 0; @@ -1118,12 +1113,12 @@ static int32_t mgmtGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, pShow->numOfRows = pDb->numOfSuperTables; pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); return 0; } // retrieve super tables -int32_t mgmtRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) { int32_t numOfRows = 0; char * pWrite; int32_t cols = 0; @@ -1131,7 +1126,7 @@ int32_t mgmtRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, v char prefix[20] = {0}; int32_t prefixLen; - SDbObj *pDb = mgmtGetDb(pShow->db); + SDbObj *pDb = mnodeGetDb(pShow->db); if (pDb == NULL) return 0; strcpy(prefix, pDb->name); @@ -1142,10 +1137,10 @@ int32_t mgmtRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, v char stableName[TSDB_TABLE_NAME_LEN + 1] = {0}; while (numOfRows < rows) { - pShow->pIter = mgmtGetNextSuperTable(pShow->pIter, &pTable); + pShow->pIter = mnodeGetNextSuperTable(pShow->pIter, &pTable); if (pTable == NULL) break; if (strncmp(pTable->info.tableId, prefix, prefixLen)) { - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); continue; } @@ -1153,7 +1148,7 @@ int32_t mgmtRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, v mgmtExtractTableName(pTable->info.tableId, stableName); if (pShow->payloadLen > 0 && patternMatch(pShow->payload, stableName, TSDB_TABLE_NAME_LEN, &info) != TSDB_PATTERN_MATCH) { - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); continue; } @@ -1185,16 +1180,16 @@ int32_t mgmtRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, v cols++; numOfRows++; - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); } pShow->numOfReads += numOfRows; - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); return numOfRows; } -void mgmtDropAllSuperTables(SDbObj *pDropDb) { +void mnodeDropAllSuperTables(SDbObj *pDropDb) { void * pIter= NULL; int32_t numOfTables = 0; int32_t dbNameLen = strlen(pDropDb->name); @@ -1203,7 +1198,7 @@ void mgmtDropAllSuperTables(SDbObj *pDropDb) { mPrint("db:%s, all super tables will be dropped from sdb", pDropDb->name); while (1) { - pIter = mgmtGetNextSuperTable(pIter, &pTable); + pIter = mnodeGetNextSuperTable(pIter, &pTable); if (pTable == NULL) break; if (strncmp(pDropDb->name, pTable->info.tableId, dbNameLen) == 0) { @@ -1216,7 +1211,7 @@ void mgmtDropAllSuperTables(SDbObj *pDropDb) { numOfTables ++; } - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); } sdbFreeIter(pIter); @@ -1224,7 +1219,7 @@ void mgmtDropAllSuperTables(SDbObj *pDropDb) { mPrint("db:%s, all super tables:%d is dropped from sdb", pDropDb->name, numOfTables); } -static int32_t mgmtSetSchemaFromSuperTable(SSchema *pSchema, SSuperTableObj *pTable) { +static int32_t mnodeSetSchemaFromSuperTable(SSchema *pSchema, SSuperTableObj *pTable) { int32_t numOfCols = pTable->numOfColumns + pTable->numOfTags; assert(numOfCols <= TSDB_MAX_COLUMNS); @@ -1239,7 +1234,7 @@ static int32_t mgmtSetSchemaFromSuperTable(SSchema *pSchema, SSuperTableObj *pTa return (pTable->numOfColumns + pTable->numOfTags) * sizeof(SSchema); } -static void mgmtGetSuperTableMeta(SMnodeMsg *pMsg) { +static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) { SSuperTableObj *pTable = (SSuperTableObj *)pMsg->pTable; STableMetaMsg *pMeta = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16)); pMeta->uid = htobe64(pTable->uid); @@ -1249,21 +1244,19 @@ static void mgmtGetSuperTableMeta(SMnodeMsg *pMsg) { pMeta->numOfTags = (uint8_t)pTable->numOfTags; pMeta->numOfColumns = htons((int16_t)pTable->numOfColumns); pMeta->tableType = pTable->info.type; - pMeta->contLen = sizeof(STableMetaMsg) + mgmtSetSchemaFromSuperTable(pMeta->schema, pTable); + pMeta->contLen = sizeof(STableMetaMsg) + mnodeSetSchemaFromSuperTable(pMeta->schema, pTable); strncpy(pMeta->tableId, pTable->info.tableId, TSDB_TABLE_ID_LEN); - SRpcMsg rpcRsp = { - .handle = pMsg->thandle, - .pCont = pMeta, - .contLen = pMeta->contLen, - }; pMeta->contLen = htons(pMeta->contLen); - rpcSendResponse(&rpcRsp); + pMsg->rpcRsp.rsp = pMeta; + pMsg->rpcRsp.len = pMeta->contLen; + mTrace("stable:%s, uid:%" PRIu64 " table meta is retrieved", pTable->info.tableId, pTable->uid); + return TSDB_CODE_SUCCESS; } -static void mgmtProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) { SCMSTableVgroupMsg *pInfo = pMsg->pCont; int32_t numOfTable = htonl(pInfo->numOfTables); @@ -1271,17 +1264,16 @@ static void mgmtProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) { int32_t contLen = sizeof(SCMSTableVgroupRspMsg) + 32 * sizeof(SCMVgroupInfo) + sizeof(SVgroupsInfo); for (int32_t i = 0; i < numOfTable; ++i) { char *stableName = (char*)pInfo + sizeof(SCMSTableVgroupMsg) + (TSDB_TABLE_ID_LEN) * i; - SSuperTableObj *pTable = mgmtGetSuperTable(stableName); + SSuperTableObj *pTable = mnodeGetSuperTable(stableName); if (pTable->vgHash != NULL) { contLen += (taosHashGetSize(pTable->vgHash) * sizeof(SCMVgroupInfo) + sizeof(SVgroupsInfo)); } - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); } SCMSTableVgroupRspMsg *pRsp = rpcMallocCont(contLen); if (pRsp == NULL) { - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY); - return; + return TSDB_CODE_SERV_OUT_OF_MEMORY; } pRsp->numOfTables = htonl(numOfTable); @@ -1289,14 +1281,14 @@ static void mgmtProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) { for (int32_t i = 0; i < numOfTable; ++i) { char *stableName = (char*)pInfo + sizeof(SCMSTableVgroupMsg) + (TSDB_TABLE_ID_LEN) * i; - SSuperTableObj *pTable = mgmtGetSuperTable(stableName); + SSuperTableObj *pTable = mnodeGetSuperTable(stableName); SVgroupsInfo *pVgroupInfo = (SVgroupsInfo *)msg; SHashMutableIterator *pIter = taosHashCreateIter(pTable->vgHash); int32_t vgSize = 0; while (taosHashIterNext(pIter)) { int32_t *pVgId = taosHashIterGet(pIter); - SVgObj * pVgroup = mgmtGetVgroup(*pVgId); + SVgObj * pVgroup = mnodeGetVgroup(*pVgId); if (pVgroup == NULL) continue; pVgroupInfo->vgroups[vgSize].vgId = htonl(pVgroup->vgId); @@ -1311,7 +1303,7 @@ static void mgmtProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) { } vgSize++; - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); } taosHashDestroyIter(pIter); @@ -1322,14 +1314,13 @@ static void mgmtProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) { msg += sizeof(SVgroupsInfo) + vgSize * sizeof(SCMVgroupInfo); } - SRpcMsg rpcRsp = {0}; - rpcRsp.handle = pMsg->thandle; - rpcRsp.pCont = pRsp; - rpcRsp.contLen = msg - (char*) pRsp; - rpcSendResponse(&rpcRsp); + pMsg->rpcRsp.rsp = pRsp; + pMsg->rpcRsp.len = msg - (char *)pRsp; + + return TSDB_CODE_SUCCESS; } -static void mgmtProcessDropSuperTableRsp(SRpcMsg *rpcMsg) { +static void mnodeProcessDropSuperTableRsp(SRpcMsg *rpcMsg) { mPrint("drop stable rsp received, result:%s", tstrerror(rpcMsg->code)); } @@ -1400,7 +1391,7 @@ static void *mgmtBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SChildTableOb return pCreate; } -static SChildTableObj* mgmtDoCreateChildTable(SCMCreateTableMsg *pCreate, SVgObj *pVgroup, int32_t tid) { +static SChildTableObj* mnodeDoCreateChildTable(SCMCreateTableMsg *pCreate, SVgObj *pVgroup, int32_t tid) { SChildTableObj *pTable = calloc(1, sizeof(SChildTableObj)); if (pTable == NULL) { mError("table:%s, failed to alloc memory", pCreate->tableId); @@ -1421,14 +1412,14 @@ static SChildTableObj* mgmtDoCreateChildTable(SCMCreateTableMsg *pCreate, SVgObj if (pTable->info.type == TSDB_CHILD_TABLE) { STagData *pTagData = (STagData *) pCreate->schema; // it is a tag key - SSuperTableObj *pSuperTable = mgmtGetSuperTable(pTagData->name); + SSuperTableObj *pSuperTable = mnodeGetSuperTable(pTagData->name); if (pSuperTable == NULL) { mError("table:%s, corresponding super table:%s does not exist", pCreate->tableId, pTagData->name); free(pTable); terrno = TSDB_CODE_INVALID_TABLE; return NULL; } - mgmtDecTableRef(pSuperTable); + mnodeDecTableRef(pSuperTable); pTable->suid = pSuperTable->uid; pTable->uid = (((uint64_t)pTable->vgId) << 40) + ((((uint64_t)pTable->sid) & ((1ul << 24) - 1ul)) << 16) + @@ -1487,20 +1478,18 @@ static SChildTableObj* mgmtDoCreateChildTable(SCMCreateTableMsg *pCreate, SVgObj return pTable; } -static void mgmtProcessCreateChildTableMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) { SCMCreateTableMsg *pCreate = pMsg->pCont; int32_t code = grantCheck(TSDB_GRANT_TIMESERIES); if (code != TSDB_CODE_SUCCESS) { mError("table:%s, failed to create, grant timeseries failed", pCreate->tableId); - mgmtSendSimpleResp(pMsg->thandle, code); - return; + return code; } - SVgObj *pVgroup = mgmtGetAvailableVgroup(pMsg->pDb); + SVgObj *pVgroup = mnodeGetAvailableVgroup(pMsg->pDb); if (pVgroup == NULL) { mTrace("table:%s, start to create a new vgroup", pCreate->tableId); - mgmtCreateVgroup(mgmtCloneQueuedMsg(pMsg), pMsg->pDb); - return; + return mnodeCreateVgroup(pMsg, pMsg->pDb); } if (pMsg->retry == 0) { @@ -1508,39 +1497,34 @@ static void mgmtProcessCreateChildTableMsg(SMnodeMsg *pMsg) { int32_t sid = taosAllocateId(pVgroup->idPool); if (sid <= 0) { mTrace("tables:%s, no enough sid in vgId:%d", pCreate->tableId, pVgroup->vgId); - mgmtCreateVgroup(mgmtCloneQueuedMsg(pMsg), pMsg->pDb); - return; + return mnodeCreateVgroup(pMsg, pMsg->pDb); } - pMsg->pTable = (STableObj *)mgmtDoCreateChildTable(pCreate, pVgroup, sid); + pMsg->pTable = (STableObj *)mnodeDoCreateChildTable(pCreate, pVgroup, sid); if (pMsg->pTable == NULL) { - mgmtSendSimpleResp(pMsg->thandle, terrno); - return; + return terrno; } - mgmtIncTableRef(pMsg->pTable); + mnodeIncTableRef(pMsg->pTable); } } else { - if (pMsg->pTable == NULL) pMsg->pTable = mgmtGetTable(pCreate->tableId); + if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pCreate->tableId); } if (pMsg->pTable == NULL) { - mgmtSendSimpleResp(pMsg->thandle, terrno); - return; + return terrno; } SMDCreateTableMsg *pMDCreate = mgmtBuildCreateChildTableMsg(pCreate, (SChildTableObj *) pMsg->pTable); if (pMDCreate == NULL) { - mgmtSendSimpleResp(pMsg->thandle, terrno); - return; + return terrno; } - SRpcIpSet ipSet = mgmtGetIpSetFromVgroup(pVgroup); - SMnodeMsg *newMsg = mgmtCloneQueuedMsg(pMsg); - newMsg->ahandle = pMsg->pTable; - newMsg->maxRetry = 10; + SRpcIpSet ipSet = mnodeGetIpSetFromVgroup(pVgroup); + pMsg->ahandle = pMsg->pTable; + pMsg->maxRetry = 10; SRpcMsg rpcMsg = { - .handle = newMsg, + .handle = pMsg, .pCont = pMDCreate, .contLen = htonl(pMDCreate->contLen), .code = 0, @@ -1548,22 +1532,22 @@ static void mgmtProcessCreateChildTableMsg(SMnodeMsg *pMsg) { }; dnodeSendMsgToDnode(&ipSet, &rpcMsg); + + return TSDB_CODE_ACTION_IN_PROGRESS; } -static void mgmtProcessDropChildTableMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessDropChildTableMsg(SMnodeMsg *pMsg) { SChildTableObj *pTable = (SChildTableObj *)pMsg->pTable; - if (pMsg->pVgroup == NULL) pMsg->pVgroup = mgmtGetVgroup(pTable->vgId); + if (pMsg->pVgroup == NULL) pMsg->pVgroup = mnodeGetVgroup(pTable->vgId); if (pMsg->pVgroup == NULL) { mError("table:%s, failed to drop ctable, vgroup not exist", pTable->info.tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_OTHERS); - return; + return TSDB_CODE_OTHERS; } SMDDropTableMsg *pDrop = rpcMallocCont(sizeof(SMDDropTableMsg)); if (pDrop == NULL) { mError("table:%s, failed to drop ctable, no enough memory", pTable->info.tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY); - return; + return TSDB_CODE_SERV_OUT_OF_MEMORY; } strcpy(pDrop->tableId, pTable->info.tableId); @@ -1572,13 +1556,12 @@ static void mgmtProcessDropChildTableMsg(SMnodeMsg *pMsg) { pDrop->sid = htonl(pTable->sid); pDrop->uid = htobe64(pTable->uid); - SRpcIpSet ipSet = mgmtGetIpSetFromVgroup(pMsg->pVgroup); + SRpcIpSet ipSet = mnodeGetIpSetFromVgroup(pMsg->pVgroup); mPrint("table:%s, send drop ctable msg", pDrop->tableId); - SMnodeMsg *newMsg = mgmtCloneQueuedMsg(pMsg); - newMsg->ahandle = pMsg->pTable; + pMsg->ahandle = pMsg->pTable; SRpcMsg rpcMsg = { - .handle = newMsg, + .handle = pMsg, .pCont = pDrop, .contLen = sizeof(SMDDropTableMsg), .code = 0, @@ -1586,13 +1569,15 @@ static void mgmtProcessDropChildTableMsg(SMnodeMsg *pMsg) { }; dnodeSendMsgToDnode(&ipSet, &rpcMsg); + + return TSDB_CODE_ACTION_IN_PROGRESS; } -static int32_t mgmtModifyChildTableTagValue(SChildTableObj *pTable, char *tagName, char *nContent) { +static int32_t mnodeModifyChildTableTagValue(SChildTableObj *pTable, char *tagName, char *nContent) { return TSDB_CODE_OPS_NOT_SUPPORT; } -static int32_t mgmtFindNormalTableColumnIndex(SChildTableObj *pTable, char *colName) { +static int32_t mnodeFindNormalTableColumnIndex(SChildTableObj *pTable, char *colName) { SSchema *schema = (SSchema *) pTable->schema; for (int32_t col = 0; col < pTable->numOfColumns; col++) { if (strcasecmp(schema[col].name, colName) == 0) { @@ -1603,14 +1588,14 @@ static int32_t mgmtFindNormalTableColumnIndex(SChildTableObj *pTable, char *colN return -1; } -static int32_t mgmtAddNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, SSchema schema[], int32_t ncols) { +static int32_t mnodeAddNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, SSchema schema[], int32_t ncols) { if (ncols <= 0) { mError("table:%s, add column, ncols:%d <= 0", pTable->info.tableId); return TSDB_CODE_APP_ERROR; } for (int32_t i = 0; i < ncols; i++) { - if (mgmtFindNormalTableColumnIndex(pTable, schema[i].name) > 0) { + if (mnodeFindNormalTableColumnIndex(pTable, schema[i].name) > 0) { mError("table:%s, add column, column:%s already exist", pTable->info.tableId, schema[i].name); return TSDB_CODE_FIELD_ALREAY_EXIST; } @@ -1629,10 +1614,10 @@ static int32_t mgmtAddNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, SSc pTable->numOfColumns += ncols; pTable->sversion++; - SAcctObj *pAcct = mgmtGetAcct(pDb->acct); + SAcctObj *pAcct = mnodeGetAcct(pDb->acct); if (pAcct != NULL) { pAcct->acctInfo.numOfTimeSeries += ncols; - mgmtDecAcctRef(pAcct); + mnodeDecAcctRef(pAcct); } SSdbOper oper = { @@ -1650,8 +1635,8 @@ static int32_t mgmtAddNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, SSc return TSDB_CODE_SUCCESS; } -static int32_t mgmtDropNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, char *colName) { - int32_t col = mgmtFindNormalTableColumnIndex(pTable, colName); +static int32_t mnodeDropNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, char *colName) { + int32_t col = mnodeFindNormalTableColumnIndex(pTable, colName); if (col <= 0) { mError("table:%s, drop column, column:%s not exist", pTable->info.tableId, colName); return TSDB_CODE_FIELD_NOT_EXIST; @@ -1661,10 +1646,10 @@ static int32_t mgmtDropNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, ch pTable->numOfColumns--; pTable->sversion++; - SAcctObj *pAcct = mgmtGetAcct(pDb->acct); + SAcctObj *pAcct = mnodeGetAcct(pDb->acct); if (pAcct != NULL) { pAcct->acctInfo.numOfTimeSeries--; - mgmtDecAcctRef(pAcct); + mnodeDecAcctRef(pAcct); } SSdbOper oper = { @@ -1682,7 +1667,7 @@ static int32_t mgmtDropNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, ch return TSDB_CODE_SUCCESS; } -static int32_t mgmtSetSchemaFromNormalTable(SSchema *pSchema, SChildTableObj *pTable) { +static int32_t mnodeSetSchemaFromNormalTable(SSchema *pSchema, SChildTableObj *pTable) { int32_t numOfCols = pTable->numOfColumns; for (int32_t i = 0; i < numOfCols; ++i) { strcpy(pSchema->name, pTable->schema[i].name); @@ -1695,7 +1680,7 @@ static int32_t mgmtSetSchemaFromNormalTable(SSchema *pSchema, SChildTableObj *pT return numOfCols * sizeof(SSchema); } -static int32_t mgmtDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) { +static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) { SDbObj *pDb = pMsg->pDb; SChildTableObj *pTable = (SChildTableObj *)pMsg->pTable; @@ -1710,28 +1695,28 @@ static int32_t mgmtDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) { 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) + mgmtSetSchemaFromSuperTable(pMeta->schema, pTable->superTable); + 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) + mgmtSetSchemaFromNormalTable(pMeta->schema, pTable); + pMeta->contLen = sizeof(STableMetaMsg) + mnodeSetSchemaFromNormalTable(pMeta->schema, pTable); } - if (pMsg->pVgroup == NULL) pMsg->pVgroup = mgmtGetVgroup(pTable->vgId); + if (pMsg->pVgroup == NULL) pMsg->pVgroup = mnodeGetVgroup(pTable->vgId); if (pMsg->pVgroup == NULL) { mError("table:%s, failed to get table meta, db not selected", pTable->info.tableId); return TSDB_CODE_INVALID_VGROUP_ID; } for (int32_t i = 0; i < pMsg->pVgroup->numOfVnodes; ++i) { - SDnodeObj *pDnode = mgmtGetDnode(pMsg->pVgroup->vnodeGid[i].dnodeId); + SDnodeObj *pDnode = mnodeGetDnode(pMsg->pVgroup->vnodeGid[i].dnodeId); if (pDnode == NULL) break; strcpy(pMeta->vgroup.ipAddr[i].fqdn, pDnode->dnodeFqdn); pMeta->vgroup.ipAddr[i].port = htons(pDnode->dnodePort + TSDB_PORT_DNODESHELL); pMeta->vgroup.numOfIps++; - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); } pMeta->vgroup.vgId = htonl(pMsg->pVgroup->vgId); @@ -1740,7 +1725,7 @@ static int32_t mgmtDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) { return TSDB_CODE_SUCCESS; } -static void mgmtAutoCreateChildTable(SMnodeMsg *pMsg) { +static int32_t mgmtAutoCreateChildTable(SMnodeMsg *pMsg) { SCMTableInfoMsg *pInfo = pMsg->pCont; STagData* pTag = (STagData*)pInfo->tags; @@ -1748,8 +1733,7 @@ static void mgmtAutoCreateChildTable(SMnodeMsg *pMsg) { SCMCreateTableMsg *pCreateMsg = rpcMallocCont(contLen); if (pCreateMsg == NULL) { mError("table:%s, failed to create table while get meta info, no enough memory", pInfo->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY); - return; + return TSDB_CODE_SERV_OUT_OF_MEMORY; } strncpy(pCreateMsg->tableId, pInfo->tableId, tListLen(pInfo->tableId)); @@ -1760,34 +1744,33 @@ static void mgmtAutoCreateChildTable(SMnodeMsg *pMsg) { memcpy(pCreateMsg->schema, pInfo->tags, contLen - sizeof(SCMCreateTableMsg)); - SMnodeMsg *newMsg = mgmtCloneQueuedMsg(pMsg); - newMsg->msgType = TSDB_MSG_TYPE_CM_CREATE_TABLE; - newMsg->pCont = pCreateMsg; + pMsg->msgType = TSDB_MSG_TYPE_CM_CREATE_TABLE; + rpcFreeCont(pMsg->pCont); + pMsg->pCont = pCreateMsg; + pMsg->contLen = contLen; mTrace("table:%s, start to create on demand, stable:%s", pInfo->tableId, pInfo->tags); - mgmtAddToShellQueue(newMsg); + + return TSDB_CODE_ACTION_NEED_REPROCESSED; } -static void mgmtGetChildTableMeta(SMnodeMsg *pMsg) { +static int32_t mnodeGetChildTableMeta(SMnodeMsg *pMsg) { STableMetaMsg *pMeta = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16)); if (pMeta == NULL) { mError("table:%s, failed to get table meta, no enough memory", pMsg->pTable->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY); - return; + return TSDB_CODE_SERV_OUT_OF_MEMORY; } - mgmtDoGetChildTableMeta(pMsg, pMeta); + mnodeDoGetChildTableMeta(pMsg, pMeta); - SRpcMsg rpcRsp = { - .handle = pMsg->thandle, - .pCont = pMeta, - .contLen = pMeta->contLen, - }; + pMsg->rpcRsp.len = pMeta->contLen; + pMsg->rpcRsp.rsp = pMeta; pMeta->contLen = htons(pMeta->contLen); - rpcSendResponse(&rpcRsp); + + return TSDB_CODE_SUCCESS; } -void mgmtDropAllChildTablesInVgroups(SVgObj *pVgroup) { +void mnodeDropAllChildTablesInVgroups(SVgObj *pVgroup) { void * pIter = NULL; int32_t numOfTables = 0; SChildTableObj *pTable = NULL; @@ -1795,7 +1778,7 @@ void mgmtDropAllChildTablesInVgroups(SVgObj *pVgroup) { mPrint("vgId:%d, all child tables will be dropped from sdb", pVgroup->vgId); while (1) { - pIter = mgmtGetNextChildTable(pIter, &pTable); + pIter = mnodeGetNextChildTable(pIter, &pTable); if (pTable == NULL) break; if (pTable->vgId == pVgroup->vgId) { @@ -1807,7 +1790,7 @@ void mgmtDropAllChildTablesInVgroups(SVgObj *pVgroup) { sdbDeleteRow(&oper); numOfTables++; } - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); } sdbFreeIter(pIter); @@ -1815,7 +1798,7 @@ void mgmtDropAllChildTablesInVgroups(SVgObj *pVgroup) { mPrint("vgId:%d, all child tables is dropped from sdb", pVgroup->vgId); } -void mgmtDropAllChildTables(SDbObj *pDropDb) { +void mnodeDropAllChildTables(SDbObj *pDropDb) { void * pIter = NULL; int32_t numOfTables = 0; int32_t dbNameLen = strlen(pDropDb->name); @@ -1824,7 +1807,7 @@ void mgmtDropAllChildTables(SDbObj *pDropDb) { mPrint("db:%s, all child tables will be dropped from sdb", pDropDb->name); while (1) { - pIter = mgmtGetNextChildTable(pIter, &pTable); + pIter = mnodeGetNextChildTable(pIter, &pTable); if (pTable == NULL) break; if (strncmp(pDropDb->name, pTable->info.tableId, dbNameLen) == 0) { @@ -1836,7 +1819,7 @@ void mgmtDropAllChildTables(SDbObj *pDropDb) { sdbDeleteRow(&oper); numOfTables++; } - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); } sdbFreeIter(pIter); @@ -1844,7 +1827,7 @@ void mgmtDropAllChildTables(SDbObj *pDropDb) { mPrint("db:%s, all child tables:%d is dropped from sdb", pDropDb->name, numOfTables); } -static void mgmtDropAllChildTablesInStable(SSuperTableObj *pStable) { +static void mnodeDropAllChildTablesInStable(SSuperTableObj *pStable) { void * pIter = NULL; int32_t numOfTables = 0; SChildTableObj *pTable = NULL; @@ -1852,7 +1835,7 @@ static void mgmtDropAllChildTablesInStable(SSuperTableObj *pStable) { mPrint("stable:%s, all child tables will dropped from sdb", pStable->info.tableId, numOfTables); while (1) { - pIter = mgmtGetNextChildTable(pIter, &pTable); + pIter = mnodeGetNextChildTable(pIter, &pTable); if (pTable == NULL) break; if (pTable->superTable == pStable) { @@ -1865,7 +1848,7 @@ static void mgmtDropAllChildTablesInStable(SSuperTableObj *pStable) { numOfTables++; } - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); } sdbFreeIter(pIter); @@ -1873,42 +1856,39 @@ static void mgmtDropAllChildTablesInStable(SSuperTableObj *pStable) { mPrint("stable:%s, all child tables:%d is dropped from sdb", pStable->info.tableId, numOfTables); } -static SChildTableObj* mgmtGetTableByPos(int32_t vnode, int32_t sid) { - SVgObj *pVgroup = mgmtGetVgroup(vnode); +static SChildTableObj* mnodeGetTableByPos(int32_t vnode, int32_t sid) { + SVgObj *pVgroup = mnodeGetVgroup(vnode); if (pVgroup == NULL) return NULL; SChildTableObj *pTable = pVgroup->tableList[sid - 1]; - mgmtIncTableRef((STableObj *)pTable); + mnodeIncTableRef((STableObj *)pTable); - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); return pTable; } -static void mgmtProcessTableCfgMsg(SRpcMsg *rpcMsg) { - SDMConfigTableMsg *pCfg = (SDMConfigTableMsg *) rpcMsg->pCont; +static int32_t mnodeProcessTableCfgMsg(SMnodeMsg *pMsg) { + SDMConfigTableMsg *pCfg = (SDMConfigTableMsg *) pMsg->pCont; pCfg->dnode = htonl(pCfg->dnode); pCfg->vnode = htonl(pCfg->vnode); pCfg->sid = htonl(pCfg->sid); mTrace("dnode:%s, vnode:%d, sid:%d, receive table config msg", taosIpStr(pCfg->dnode), pCfg->vnode, pCfg->sid); - SChildTableObj *pTable = mgmtGetTableByPos(pCfg->vnode, pCfg->sid); + SChildTableObj *pTable = mnodeGetTableByPos(pCfg->vnode, pCfg->sid); if (pTable == NULL) { mError("dnode:%s, vnode:%d, sid:%d, table not found", taosIpStr(pCfg->dnode), pCfg->vnode, pCfg->sid); - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_NOT_ACTIVE_TABLE); - return; + return TSDB_CODE_NOT_ACTIVE_TABLE; } - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_SUCCESS); - SMDCreateTableMsg *pMDCreate = NULL; pMDCreate = mgmtBuildCreateChildTableMsg(NULL, (SChildTableObj *) pTable); if (pMDCreate == NULL) { - mgmtDecTableRef(pTable); - return; + mnodeDecTableRef(pTable); + return terrno; } - SDnodeObj *pDnode = mgmtGetDnode(pCfg->dnode); - SRpcIpSet ipSet = mgmtGetIpSetFromIp(pDnode->dnodeEp); + SDnodeObj *pDnode = mnodeGetDnode(pCfg->dnode); + SRpcIpSet ipSet = mnodeGetIpSetFromIp(pDnode->dnodeEp); SRpcMsg rpcRsp = { .handle = NULL, .pCont = pMDCreate, @@ -1918,32 +1898,33 @@ static void mgmtProcessTableCfgMsg(SRpcMsg *rpcMsg) { }; dnodeSendMsgToDnode(&ipSet, &rpcRsp); - mgmtDecTableRef(pTable); - mgmtDecDnodeRef(pDnode); + mnodeDecTableRef(pTable); + mnodeDecDnodeRef(pDnode); + + return TSDB_CODE_SUCCESS; } // handle drop child response -static void mgmtProcessDropChildTableRsp(SRpcMsg *rpcMsg) { +static void mnodeProcessDropChildTableRsp(SRpcMsg *rpcMsg) { if (rpcMsg->handle == NULL) return; - SMnodeMsg *queueMsg = rpcMsg->handle; - queueMsg->received++; + SMnodeMsg *mnodeMsg = rpcMsg->handle; + mnodeMsg->received++; - SChildTableObj *pTable = queueMsg->ahandle; - mPrint("table:%s, drop table rsp received, thandle:%p result:%s", pTable->info.tableId, queueMsg->thandle, tstrerror(rpcMsg->code)); + SChildTableObj *pTable = mnodeMsg->ahandle; + mPrint("table:%s, drop table rsp received, thandle:%p result:%s", pTable->info.tableId, mnodeMsg->thandle, tstrerror(rpcMsg->code)); if (rpcMsg->code != TSDB_CODE_SUCCESS) { mError("table:%s, failed to drop in dnode, reason:%s", pTable->info.tableId, tstrerror(rpcMsg->code)); - mgmtSendSimpleResp(queueMsg->thandle, rpcMsg->code); - free(queueMsg); - mgmtDecTableRef(pTable); + dnodeSendRpcMnodeWriteRsp(mnodeMsg, rpcMsg->code); + mnodeDecTableRef(pTable); return; } - if (queueMsg->pVgroup == NULL) queueMsg->pVgroup = mgmtGetVgroup(pTable->vgId); - if (queueMsg->pVgroup == NULL) { + if (mnodeMsg->pVgroup == NULL) mnodeMsg->pVgroup = mnodeGetVgroup(pTable->vgId); + if (mnodeMsg->pVgroup == NULL) { mError("table:%s, failed to get vgroup", pTable->info.tableId); - mgmtSendSimpleResp(queueMsg->thandle, TSDB_CODE_INVALID_VGROUP_ID); + dnodeSendRpcMnodeWriteRsp(mnodeMsg, TSDB_CODE_INVALID_VGROUP_ID); return; } @@ -1956,39 +1937,38 @@ static void mgmtProcessDropChildTableRsp(SRpcMsg *rpcMsg) { int32_t code = sdbDeleteRow(&oper); if (code != TSDB_CODE_SUCCESS) { mError("table:%s, update ctables sdb error", pTable->info.tableId); - mgmtSendSimpleResp(queueMsg->thandle, TSDB_CODE_SDB_ERROR); + dnodeSendRpcMnodeWriteRsp(mnodeMsg, TSDB_CODE_SDB_ERROR); return; } - if (queueMsg->pVgroup->numOfTables <= 0) { - mPrint("vgId:%d, all tables is dropped, drop vgroup", queueMsg->pVgroup->vgId); - mgmtDropVgroup(queueMsg->pVgroup, NULL); + if (mnodeMsg->pVgroup->numOfTables <= 0) { + mPrint("vgId:%d, all tables is dropped, drop vgroup", mnodeMsg->pVgroup->vgId); + mnodeDropVgroup(mnodeMsg->pVgroup, NULL); } - mgmtSendSimpleResp(queueMsg->thandle, TSDB_CODE_SUCCESS); - mgmtFreeQueuedMsg(queueMsg); + dnodeSendRpcMnodeWriteRsp(mnodeMsg, TSDB_CODE_SUCCESS); } // handle create table response from dnode // if failed, drop the table cached -static void mgmtProcessCreateChildTableRsp(SRpcMsg *rpcMsg) { +static void mnodeProcessCreateChildTableRsp(SRpcMsg *rpcMsg) { if (rpcMsg->handle == NULL) return; - SMnodeMsg *queueMsg = rpcMsg->handle; - queueMsg->received++; + SMnodeMsg *mnodeMsg = rpcMsg->handle; + mnodeMsg->received++; - SChildTableObj *pTable = queueMsg->ahandle; - mTrace("table:%s, create table rsp received, thandle:%p result:%s", pTable->info.tableId, queueMsg->thandle, + SChildTableObj *pTable = mnodeMsg->ahandle; + mTrace("table:%s, create table rsp received, thandle:%p result:%s", pTable->info.tableId, mnodeMsg->thandle, tstrerror(rpcMsg->code)); if (rpcMsg->code != TSDB_CODE_SUCCESS) { - if (queueMsg->retry++ < queueMsg->maxRetry) { + if (mnodeMsg->retry++ < mnodeMsg->maxRetry) { mTrace("table:%s, create table rsp received, retry:%d thandle:%p result:%s", pTable->info.tableId, - queueMsg->retry, queueMsg->thandle, tstrerror(rpcMsg->code)); - mgmtDealyedAddToShellQueue(queueMsg); + mnodeMsg->retry, mnodeMsg->thandle, tstrerror(rpcMsg->code)); + dnodeDelayReprocessMnodeWriteMsg(mnodeMsg); } else { mError("table:%s, failed to create in dnode, thandle:%p result:%s", pTable->info.tableId, - queueMsg->thandle, tstrerror(rpcMsg->code)); + mnodeMsg->thandle, tstrerror(rpcMsg->code)); SSdbOper oper = { .type = SDB_OPER_GLOBAL, @@ -1997,38 +1977,35 @@ static void mgmtProcessCreateChildTableRsp(SRpcMsg *rpcMsg) { }; sdbDeleteRow(&oper); - mgmtSendSimpleResp(queueMsg->thandle, rpcMsg->code); - mgmtFreeQueuedMsg(queueMsg); + dnodeSendRpcMnodeWriteRsp(mnodeMsg, rpcMsg->code); } } else { - mTrace("table:%s, created in dnode, thandle:%p result:%s", pTable->info.tableId, queueMsg->thandle, + mTrace("table:%s, created in dnode, thandle:%p result:%s", pTable->info.tableId, mnodeMsg->thandle, tstrerror(rpcMsg->code)); - SCMCreateTableMsg *pCreate = queueMsg->pCont; + SCMCreateTableMsg *pCreate = mnodeMsg->pCont; if (pCreate->getMeta) { mTrace("table:%s, continue to get meta", pTable->info.tableId); - queueMsg->retry = 0; - mgmtAddToShellQueue(queueMsg); + mnodeMsg->retry = 0; + dnodeReprocessMnodeWriteMsg(mnodeMsg); } else { - mgmtSendSimpleResp(queueMsg->thandle, rpcMsg->code); - mgmtFreeQueuedMsg(queueMsg); + dnodeSendRpcMnodeWriteRsp(mnodeMsg, rpcMsg->code); } } } // not implemented yet -static void mgmtProcessAlterTableRsp(SRpcMsg *rpcMsg) { +static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg) { mTrace("alter table rsp received, handle:%p code:%s", rpcMsg->handle, tstrerror(rpcMsg->code)); } -static void mgmtProcessMultiTableMetaMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) { SCMMultiTableInfoMsg *pInfo = pMsg->pCont; pInfo->numOfTables = htonl(pInfo->numOfTables); int32_t totalMallocLen = 4 * 1024 * 1024; // first malloc 4 MB, subsequent reallocation as twice SMultiTableMeta *pMultiMeta = rpcMallocCont(totalMallocLen); if (pMultiMeta == NULL) { - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY); - return; + return TSDB_CODE_SERV_OUT_OF_MEMORY; } pMultiMeta->contLen = sizeof(SMultiTableMeta); @@ -2036,12 +2013,12 @@ static void mgmtProcessMultiTableMetaMsg(SMnodeMsg *pMsg) { for (int32_t t = 0; t < pInfo->numOfTables; ++t) { char * tableId = (char *)(pInfo->tableIds + t * TSDB_TABLE_ID_LEN + 1); - SChildTableObj *pTable = mgmtGetChildTable(tableId); + SChildTableObj *pTable = mnodeGetChildTable(tableId); if (pTable == NULL) continue; - if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDbByTableId(tableId); + if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableId(tableId); if (pMsg->pDb == NULL) { - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); continue; } @@ -2050,35 +2027,33 @@ static void mgmtProcessMultiTableMetaMsg(SMnodeMsg *pMsg) { totalMallocLen *= 2; pMultiMeta = rpcReallocCont(pMultiMeta, totalMallocLen); if (pMultiMeta == NULL) { - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SERV_OUT_OF_MEMORY); - mgmtDecTableRef(pTable); - return; + mnodeDecTableRef(pTable); + return TSDB_CODE_SERV_OUT_OF_MEMORY; } else { t--; - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); continue; } } STableMetaMsg *pMeta = (STableMetaMsg *)(pMultiMeta->metas + pMultiMeta->contLen); - int32_t code = mgmtDoGetChildTableMeta(pMsg, pMeta); + int32_t code = mnodeDoGetChildTableMeta(pMsg, pMeta); if (code == TSDB_CODE_SUCCESS) { pMultiMeta->numOfTables ++; pMultiMeta->contLen += pMeta->contLen; } - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); } - SRpcMsg rpcRsp = {0}; - rpcRsp.handle = pMsg->thandle; - rpcRsp.pCont = pMultiMeta; - rpcRsp.contLen = pMultiMeta->contLen; - rpcSendResponse(&rpcRsp); + pMsg->rpcRsp.rsp = pMultiMeta; + pMsg->rpcRsp.len = pMultiMeta->contLen; + + return TSDB_CODE_SUCCESS; } -static int32_t mgmtGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { - SDbObj *pDb = mgmtGetDb(pShow->db); +static int32_t mnodeGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { + SDbObj *pDb = mnodeGetDb(pShow->db); if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED; int32_t cols = 0; @@ -2119,7 +2094,7 @@ static int32_t mgmtGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void pShow->numOfRows = pDb->numOfTables; pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); return 0; } @@ -2131,8 +2106,8 @@ static void mgmtVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_ } } -static int32_t mgmtRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) { - SDbObj *pDb = mgmtGetDb(pShow->db); +static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, void *pConn) { + SDbObj *pDb = mnodeGetDb(pShow->db); if (pDb == NULL) return 0; int32_t numOfRows = 0; @@ -2145,12 +2120,12 @@ static int32_t mgmtRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, int32_t prefixLen = strlen(prefix); while (numOfRows < rows) { - pShow->pIter = mgmtGetNextChildTable(pShow->pIter, &pTable); + pShow->pIter = mnodeGetNextChildTable(pShow->pIter, &pTable); if (pTable == NULL) break; // not belong to current db if (strncmp(pTable->info.tableId, prefix, prefixLen)) { - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); continue; } @@ -2160,7 +2135,7 @@ static int32_t mgmtRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, mgmtExtractTableName(pTable->info.tableId, tableName); if (pShow->payloadLen > 0 && patternMatch(pShow->payload, tableName, TSDB_TABLE_NAME_LEN, &info) != TSDB_PATTERN_MATCH) { - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); continue; } @@ -2195,40 +2170,37 @@ static int32_t mgmtRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, cols++; numOfRows++; - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); } pShow->numOfReads += numOfRows; const int32_t NUM_OF_COLUMNS = 4; mgmtVacuumResult(data, NUM_OF_COLUMNS, numOfRows, rows, pShow); - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); return numOfRows; } -static void mgmtProcessAlterTableMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg) { SCMAlterTableMsg *pAlter = pMsg->pCont; mTrace("table:%s, alter table msg is received from thandle:%p", pAlter->tableId, pMsg->thandle); - if (pMsg->pDb == NULL) pMsg->pDb = mgmtGetDbByTableId(pAlter->tableId); + if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableId(pAlter->tableId); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { mError("table:%s, failed to alter table, db not selected", pAlter->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_DB_NOT_SELECTED); - return; + return TSDB_CODE_DB_NOT_SELECTED; } - if (mgmtCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) { + if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) { mError("table:%s, failed to alter table, its log db", pAlter->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_MONITOR_DB_FORBIDDEN); - return; + return TSDB_CODE_MONITOR_DB_FORBIDDEN; } - if (pMsg->pTable == NULL) pMsg->pTable = mgmtGetTable(pAlter->tableId); + if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pAlter->tableId); if (pMsg->pTable == NULL) { mError("table:%s, failed to alter table, table not exist", pMsg->pTable->tableId); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_TABLE); - return; + return TSDB_CODE_INVALID_TABLE; } pAlter->type = htons(pAlter->type); @@ -2237,8 +2209,7 @@ static void mgmtProcessAlterTableMsg(SMnodeMsg *pMsg) { if (pAlter->numOfCols > 2) { mError("table:%s, error numOfCols:%d in alter table", pAlter->tableId, pAlter->numOfCols); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_APP_ERROR); - return; + return TSDB_CODE_APP_ERROR; } for (int32_t i = 0; i < pAlter->numOfCols; ++i) { @@ -2250,15 +2221,15 @@ static void mgmtProcessAlterTableMsg(SMnodeMsg *pMsg) { SSuperTableObj *pTable = (SSuperTableObj *)pMsg->pTable; mTrace("table:%s, start to alter stable", pAlter->tableId); if (pAlter->type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN) { - code = mgmtAddSuperTableTag(pTable, pAlter->schema, 1); + code = mnodeAddSuperTableTag(pTable, pAlter->schema, 1); } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_TAG_COLUMN) { - code = mgmtDropSuperTableTag(pTable, pAlter->schema[0].name); + code = mnodeDropSuperTableTag(pTable, pAlter->schema[0].name); } else if (pAlter->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN) { - code = mgmtModifySuperTableTagName(pTable, pAlter->schema[0].name, pAlter->schema[1].name); + code = mnodeModifySuperTableTagName(pTable, pAlter->schema[0].name, pAlter->schema[1].name); } else if (pAlter->type == TSDB_ALTER_TABLE_ADD_COLUMN) { - code = mgmtAddSuperTableColumn(pMsg->pDb, pTable, pAlter->schema, 1); + code = mnodeAddSuperTableColumn(pMsg->pDb, pTable, pAlter->schema, 1); } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_COLUMN) { - code = mgmtDropSuperTableColumn(pMsg->pDb, pTable, pAlter->schema[0].name); + code = mnodeDropSuperTableColumn(pMsg->pDb, pTable, pAlter->schema[0].name); } else { } } else { @@ -2266,14 +2237,14 @@ static void mgmtProcessAlterTableMsg(SMnodeMsg *pMsg) { SChildTableObj *pTable = (SChildTableObj *)pMsg->pTable; if (pAlter->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) { char *tagVal = (char*)(pAlter->schema + pAlter->numOfCols); - code = mgmtModifyChildTableTagValue(pTable, pAlter->schema[0].name, tagVal); + code = mnodeModifyChildTableTagValue(pTable, pAlter->schema[0].name, tagVal); } else if (pAlter->type == TSDB_ALTER_TABLE_ADD_COLUMN) { - code = mgmtAddNormalTableColumn(pMsg->pDb, pTable, pAlter->schema, 1); + code = mnodeAddNormalTableColumn(pMsg->pDb, pTable, pAlter->schema, 1); } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_COLUMN) { - code = mgmtDropNormalTableColumn(pMsg->pDb, pTable, pAlter->schema[0].name); + code = mnodeDropNormalTableColumn(pMsg->pDb, pTable, pAlter->schema[0].name); } else { } } - mgmtSendSimpleResp(pMsg->thandle, code); + return code; } diff --git a/src/mnode/src/mnodeUser.c b/src/mnode/src/mnodeUser.c index 2a686d05ee..ad6370302a 100644 --- a/src/mnode/src/mnodeUser.c +++ b/src/mnode/src/mnodeUser.c @@ -21,36 +21,39 @@ #include "tglobal.h" #include "tgrant.h" #include "tdataformat.h" +#include "mnode.h" #include "dnode.h" #include "mnodeDef.h" #include "mnodeInt.h" #include "mnodeAcct.h" #include "mnodeMnode.h" #include "mnodeSdb.h" -#include "mnodeShell.h" +#include "mnodeShow.h" #include "mnodeUser.h" +#include "mnodeWrite.h" +#include "mnodePeer.h" static void * tsUserSdb = NULL; static int32_t tsUserUpdateSize = 0; -static int32_t mgmtGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static void mgmtProcessCreateUserMsg(SMnodeMsg *pMsg); -static void mgmtProcessAlterUserMsg(SMnodeMsg *pMsg); -static void mgmtProcessDropUserMsg(SMnodeMsg *pMsg); -static void mgmtProcessAuthMsg(SRpcMsg *rpcMsg); +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 mgmtUserActionDestroy(SSdbOper *pOper) { +static int32_t mnodeUserActionDestroy(SSdbOper *pOper) { tfree(pOper->pObj); return TSDB_CODE_SUCCESS; } -static int32_t mgmtUserActionInsert(SSdbOper *pOper) { +static int32_t mnodeUserActionInsert(SSdbOper *pOper) { SUserObj *pUser = pOper->pObj; - SAcctObj *pAcct = mgmtGetAcct(pUser->acct); + SAcctObj *pAcct = mnodeGetAcct(pUser->acct); if (pAcct != NULL) { - mgmtAddUserToAcct(pAcct, pUser); - mgmtDecAcctRef(pAcct); + mnodeAddUserToAcct(pAcct, pUser); + mnodeDecAcctRef(pAcct); } else { mError("user:%s, acct:%s info not exist in sdb", pUser->user, pUser->acct); return TSDB_CODE_INVALID_ACCT; @@ -59,37 +62,37 @@ static int32_t mgmtUserActionInsert(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtUserActionDelete(SSdbOper *pOper) { +static int32_t mnodeUserActionDelete(SSdbOper *pOper) { SUserObj *pUser = pOper->pObj; - SAcctObj *pAcct = mgmtGetAcct(pUser->acct); + SAcctObj *pAcct = mnodeGetAcct(pUser->acct); if (pAcct != NULL) { - mgmtDropUserFromAcct(pAcct, pUser); - mgmtDecAcctRef(pAcct); + mnodeDropUserFromAcct(pAcct, pUser); + mnodeDecAcctRef(pAcct); } return TSDB_CODE_SUCCESS; } -static int32_t mgmtUserActionUpdate(SSdbOper *pOper) { +static int32_t mnodeUserActionUpdate(SSdbOper *pOper) { SUserObj *pUser = pOper->pObj; - SUserObj *pSaved = mgmtGetUser(pUser->user); + SUserObj *pSaved = mnodeGetUser(pUser->user); if (pUser != pSaved) { memcpy(pSaved, pUser, tsUserUpdateSize); free(pUser); } - mgmtDecUserRef(pSaved); + mnodeDecUserRef(pSaved); return TSDB_CODE_SUCCESS; } -static int32_t mgmtUserActionEncode(SSdbOper *pOper) { +static int32_t mnodeUserActionEncode(SSdbOper *pOper) { SUserObj *pUser = pOper->pObj; memcpy(pOper->rowData, pUser, tsUserUpdateSize); pOper->rowSize = tsUserUpdateSize; return TSDB_CODE_SUCCESS; } -static int32_t mgmtUserActionDecode(SSdbOper *pOper) { +static int32_t mnodeUserActionDecode(SSdbOper *pOper) { SUserObj *pUser = (SUserObj *)calloc(1, sizeof(SUserObj)); if (pUser == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; @@ -98,19 +101,19 @@ static int32_t mgmtUserActionDecode(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtUserActionRestored() { +static int32_t mnodeUserActionRestored() { if (dnodeIsFirstDeploy()) { - SAcctObj *pAcct = mgmtGetAcct("root"); - mgmtCreateUser(pAcct, "root", "taosdata"); - mgmtCreateUser(pAcct, "monitor", tsInternalPass); - mgmtCreateUser(pAcct, "_root", tsInternalPass); - mgmtDecAcctRef(pAcct); + SAcctObj *pAcct = mnodeGetAcct("root"); + mnodeCreateUser(pAcct, "root", "taosdata"); + mnodeCreateUser(pAcct, "monitor", tsInternalPass); + mnodeCreateUser(pAcct, "_root", tsInternalPass); + mnodeDecAcctRef(pAcct); } return TSDB_CODE_SUCCESS; } -int32_t mgmtInitUsers() { +int32_t mnodeInitUsers() { SUserObj tObj; tsUserUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj; @@ -121,13 +124,13 @@ int32_t mgmtInitUsers() { .maxRowSize = tsUserUpdateSize, .refCountPos = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj, .keyType = SDB_KEY_STRING, - .insertFp = mgmtUserActionInsert, - .deleteFp = mgmtUserActionDelete, - .updateFp = mgmtUserActionUpdate, - .encodeFp = mgmtUserActionEncode, - .decodeFp = mgmtUserActionDecode, - .destroyFp = mgmtUserActionDestroy, - .restoredFp = mgmtUserActionRestored + .insertFp = mnodeUserActionInsert, + .deleteFp = mnodeUserActionDelete, + .updateFp = mnodeUserActionUpdate, + .encodeFp = mnodeUserActionEncode, + .decodeFp = mnodeUserActionDecode, + .destroyFp = mnodeUserActionDestroy, + .restoredFp = mnodeUserActionRestored }; tsUserSdb = sdbOpenTable(&tableDesc); @@ -136,38 +139,38 @@ int32_t mgmtInitUsers() { return -1; } - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_CREATE_USER, mgmtProcessCreateUserMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_ALTER_USER, mgmtProcessAlterUserMsg); - mgmtAddShellMsgHandle(TSDB_MSG_TYPE_CM_DROP_USER, mgmtProcessDropUserMsg); - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_USER, mgmtGetUserMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_USER, mgmtRetrieveUsers); - dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_AUTH, mgmtProcessAuthMsg); + 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); + mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_AUTH, mnodeProcessAuthMsg); mTrace("table:%s, hash is created", tableDesc.tableName); return 0; } -void mgmtCleanUpUsers() { +void mnodeCleanupUsers() { sdbCloseTable(tsUserSdb); } -SUserObj *mgmtGetUser(char *name) { +SUserObj *mnodeGetUser(char *name) { return (SUserObj *)sdbGetRow(tsUserSdb, name); } -void *mgmtGetNextUser(void *pIter, SUserObj **pUser) { +void *mnodeGetNextUser(void *pIter, SUserObj **pUser) { return sdbFetchRow(tsUserSdb, pIter, (void **)pUser); } -void mgmtIncUserRef(SUserObj *pUser) { +void mnodeIncUserRef(SUserObj *pUser) { return sdbIncRef(tsUserSdb, pUser); } -void mgmtDecUserRef(SUserObj *pUser) { +void mnodeDecUserRef(SUserObj *pUser) { return sdbDecRef(tsUserSdb, pUser); } -static int32_t mgmtUpdateUser(SUserObj *pUser) { +static int32_t mnodeUpdateUser(SUserObj *pUser) { SSdbOper oper = { .type = SDB_OPER_GLOBAL, .table = tsUserSdb, @@ -182,7 +185,7 @@ static int32_t mgmtUpdateUser(SUserObj *pUser) { return code; } -int32_t mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass) { +int32_t mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass) { int32_t code = acctCheck(pAcct, ACCT_GRANT_USER); if (code != TSDB_CODE_SUCCESS) { return code; @@ -196,10 +199,10 @@ int32_t mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass) { return TSDB_CODE_INVALID_PASS_FORMAT; } - SUserObj *pUser = mgmtGetUser(name); + SUserObj *pUser = mnodeGetUser(name); if (pUser != NULL) { mTrace("user:%s, is already there", name); - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return TSDB_CODE_USER_ALREADY_EXIST; } @@ -235,7 +238,7 @@ int32_t mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass) { return code; } -static int32_t mgmtDropUser(SUserObj *pUser) { +static int32_t mnodeDropUser(SUserObj *pUser) { SSdbOper oper = { .type = SDB_OPER_GLOBAL, .table = tsUserSdb, @@ -250,8 +253,8 @@ static int32_t mgmtDropUser(SUserObj *pUser) { return code; } -static int32_t mgmtGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { - SUserObj *pUser = mgmtGetUserFromConn(pConn); +static int32_t mnodeGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { + SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) { return TSDB_CODE_NO_USER_FROM_CONN; } @@ -289,18 +292,18 @@ static int32_t mgmtGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pCon pShow->numOfRows = pUser->pAcct->acctInfo.numOfUsers; pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); return 0; } -static int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +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 = mgmtGetNextUser(pShow->pIter, &pUser); + pShow->pIter = mnodeGetNextUser(pShow->pIter, &pUser); if (pUser == NULL) break; cols = 0; @@ -327,30 +330,30 @@ static int32_t mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void cols++; numOfRows++; - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); } pShow->numOfReads += numOfRows; return numOfRows; } -SUserObj *mgmtGetUserFromConn(void *pConn) { +SUserObj *mnodeGetUserFromConn(void *pConn) { SRpcConnInfo connInfo; if (rpcGetConnInfo(pConn, &connInfo) == 0) { - return mgmtGetUser(connInfo.user); + return mnodeGetUser(connInfo.user); } else { mError("can not get user from conn:%p", pConn); return NULL; } } -static void mgmtProcessCreateUserMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessCreateUserMsg(SMnodeMsg *pMsg) { int32_t code; SUserObj *pOperUser = pMsg->pUser; if (pOperUser->superAuth) { SCMCreateUserMsg *pCreate = pMsg->pCont; - code = mgmtCreateUser(pOperUser->pAcct, pCreate->user, pCreate->pass); + code = mnodeCreateUser(pOperUser->pAcct, pCreate->user, pCreate->pass); if (code == TSDB_CODE_SUCCESS) { mLPrint("user:%s, is created by %s", pCreate->user, pOperUser->user); } @@ -359,24 +362,22 @@ static void mgmtProcessCreateUserMsg(SMnodeMsg *pMsg) { code = TSDB_CODE_NO_RIGHTS; } - mgmtSendSimpleResp(pMsg->thandle, code); + return code; } -static void mgmtProcessAlterUserMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessAlterUserMsg(SMnodeMsg *pMsg) { int32_t code; SUserObj *pOperUser = pMsg->pUser; SCMAlterUserMsg *pAlter = pMsg->pCont; - SUserObj *pUser = mgmtGetUser(pAlter->user); + SUserObj *pUser = mnodeGetUser(pAlter->user); if (pUser == NULL) { - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_USER); - return; + return TSDB_CODE_INVALID_USER; } if (strcmp(pUser->user, "monitor") == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) { - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS); - mgmtDecUserRef(pUser); - return; + mnodeDecUserRef(pUser); + return TSDB_CODE_NO_RIGHTS; } if ((pAlter->flag & TSDB_ALTER_USER_PASSWD) != 0) { @@ -398,14 +399,12 @@ static void mgmtProcessAlterUserMsg(SMnodeMsg *pMsg) { if (hasRight) { memset(pUser->pass, 0, sizeof(pUser->pass)); taosEncryptPass((uint8_t*)pAlter->pass, strlen(pAlter->pass), pUser->pass); - code = mgmtUpdateUser(pUser); + code = mnodeUpdateUser(pUser); mLPrint("user:%s, password is altered by %s, result:%s", pUser->user, pOperUser->user, tstrerror(code)); } else { mError("user:%s, no rights to alter user", pOperUser->user); code = TSDB_CODE_NO_RIGHTS; } - - mgmtSendSimpleResp(pMsg->thandle, code); } else if ((pAlter->flag & TSDB_ALTER_USER_PRIVILEGES) != 0) { bool hasRight = false; @@ -441,38 +440,35 @@ static void mgmtProcessAlterUserMsg(SMnodeMsg *pMsg) { pUser->writeAuth = 1; } - code = mgmtUpdateUser(pUser); + code = mnodeUpdateUser(pUser); mLPrint("user:%s, privilege is altered by %s, result:%s", pUser->user, pOperUser->user, tstrerror(code)); } else { mError("user:%s, no rights to alter user", pOperUser->user); code = TSDB_CODE_NO_RIGHTS; } - - mgmtSendSimpleResp(pMsg->thandle, code); } else { mError("user:%s, no rights to alter user", pOperUser->user); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS); + code = TSDB_CODE_NO_RIGHTS; } - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); + return code; } -static void mgmtProcessDropUserMsg(SMnodeMsg *pMsg) { +static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg) { int32_t code; SUserObj *pOperUser = pMsg->pUser; SCMDropUserMsg *pDrop = pMsg->pCont; - SUserObj *pUser = mgmtGetUser(pDrop->user); + SUserObj *pUser = mnodeGetUser(pDrop->user); if (pUser == NULL) { - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_INVALID_USER); - return; + return TSDB_CODE_INVALID_USER; } if (strcmp(pUser->user, "monitor") == 0 || strcmp(pUser->user, pUser->acct) == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) { - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_RIGHTS); - mgmtDecUserRef(pUser); - return ; + mnodeDecUserRef(pUser); + return TSDB_CODE_NO_RIGHTS; } bool hasRight = false; @@ -491,7 +487,7 @@ static void mgmtProcessDropUserMsg(SMnodeMsg *pMsg) { } if (hasRight) { - code = mgmtDropUser(pUser); + code = mnodeDropUser(pUser); if (code == TSDB_CODE_SUCCESS) { mLPrint("user:%s, is dropped by %s, result:%s", pUser->user, pOperUser->user, tstrerror(code)); } @@ -499,18 +495,18 @@ static void mgmtProcessDropUserMsg(SMnodeMsg *pMsg) { code = TSDB_CODE_NO_RIGHTS; } - mgmtSendSimpleResp(pMsg->thandle, code); - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); + return code; } -void mgmtDropAllUsers(SAcctObj *pAcct) { +void mnodeDropAllUsers(SAcctObj *pAcct) { void * pIter = NULL; int32_t numOfUsers = 0; int32_t acctNameLen = strlen(pAcct->user); SUserObj *pUser = NULL; while (1) { - pIter = mgmtGetNextUser(pIter, &pUser); + pIter = mnodeGetNextUser(pIter, &pUser); if (pUser == NULL) break; if (strncmp(pUser->acct, pAcct->user, acctNameLen) == 0) { @@ -523,7 +519,7 @@ void mgmtDropAllUsers(SAcctObj *pAcct) { numOfUsers++; } - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); } sdbFreeIter(pIter); @@ -531,14 +527,14 @@ void mgmtDropAllUsers(SAcctObj *pAcct) { mTrace("acct:%s, all users:%d is dropped from sdb", pAcct->user, numOfUsers); } -int32_t mgmtRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey) { +int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey) { if (!sdbIsMaster()) { *secret = 0; mTrace("user:%s, failed to auth user, reason:%s", user, tstrerror(TSDB_CODE_NOT_READY)); return TSDB_CODE_NOT_READY; } - SUserObj *pUser = mgmtGetUser(user); + SUserObj *pUser = mnodeGetUser(user); if (pUser == NULL) { *secret = 0; mError("user:%s, failed to auth user, reason:%s", user, tstrerror(TSDB_CODE_INVALID_USER)); @@ -549,21 +545,18 @@ int32_t mgmtRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey = 0; memcpy(secret, pUser->pass, TSDB_KEY_LEN); - mgmtDecUserRef(pUser); + mnodeDecUserRef(pUser); mTrace("user:%s, auth info is returned", user); return TSDB_CODE_SUCCESS; } } -static void mgmtProcessAuthMsg(SRpcMsg *rpcMsg) { - SRpcMsg rpcRsp = {.handle = rpcMsg->handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; - - SDMAuthMsg *pAuthMsg = rpcMsg->pCont; +static int32_t mnodeProcessAuthMsg(SMnodeMsg *pMsg) { + SDMAuthMsg *pAuthMsg = pMsg->pCont; SDMAuthRsp *pAuthRsp = rpcMallocCont(sizeof(SDMAuthRsp)); - rpcRsp.code = mgmtRetriveAuth(pAuthMsg->user, &pAuthRsp->spi, &pAuthRsp->encrypt, pAuthRsp->secret, pAuthRsp->ckey); - rpcRsp.pCont = pAuthRsp; - rpcRsp.contLen = sizeof(SDMAuthRsp); + pMsg->rpcRsp.rsp = pAuthRsp; + pMsg->rpcRsp.len = sizeof(SDMAuthRsp); - rpcSendResponse(&rpcRsp); + return mnodeRetriveAuth(pAuthMsg->user, &pAuthRsp->spi, &pAuthRsp->encrypt, pAuthRsp->secret, pAuthRsp->ckey); } diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c index 74753142aa..69baa09c95 100644 --- a/src/mnode/src/mnodeVgroup.c +++ b/src/mnode/src/mnodeVgroup.c @@ -23,8 +23,9 @@ #include "ttime.h" #include "tbalance.h" #include "tglobal.h" -#include "dnode.h" #include "tdataformat.h" +#include "dnode.h" +#include "mnode.h" #include "mnodeDef.h" #include "mnodeInt.h" #include "mnodeDb.h" @@ -32,21 +33,22 @@ #include "mnodeMnode.h" #include "mnodeProfile.h" #include "mnodeSdb.h" -#include "mnodeShell.h" +#include "mnodeShow.h" #include "mnodeTable.h" #include "mnodeVgroup.h" +#include "mnodePeer.h" static void *tsVgroupSdb = NULL; static int32_t tsVgUpdateSize = 0; -static int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); -static int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn); -static void mgmtProcessCreateVnodeRsp(SRpcMsg *rpcMsg); -static void mgmtProcessDropVnodeRsp(SRpcMsg *rpcMsg); -static void mgmtProcessVnodeCfgMsg(SRpcMsg *rpcMsg) ; -static void mgmtSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle); +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 mnodeProcessDropVnodeRsp(SRpcMsg *rpcMsg); +static int32_t mnodeProcessVnodeCfgMsg(SMnodeMsg *pMsg) ; +static void mnodeSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle); -static int32_t mgmtVgroupActionDestroy(SSdbOper *pOper) { +static int32_t mnodeVgroupActionDestroy(SSdbOper *pOper) { SVgObj *pVgroup = pOper->pObj; if (pVgroup->idPool) { taosIdPoolCleanUp(pVgroup->idPool); @@ -60,11 +62,11 @@ static int32_t mgmtVgroupActionDestroy(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtVgroupActionInsert(SSdbOper *pOper) { +static int32_t mnodeVgroupActionInsert(SSdbOper *pOper) { SVgObj *pVgroup = pOper->pObj; // refer to db - SDbObj *pDb = mgmtGetDb(pVgroup->dbName); + SDbObj *pDb = mnodeGetDb(pVgroup->dbName); if (pDb == NULL) { return TSDB_CODE_INVALID_DB; } @@ -88,40 +90,40 @@ static int32_t mgmtVgroupActionInsert(SSdbOper *pOper) { } for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) { - SDnodeObj *pDnode = mgmtGetDnode(pVgroup->vnodeGid[i].dnodeId); + SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId); if (pDnode != NULL) { pVgroup->vnodeGid[i].pDnode = pDnode; atomic_add_fetch_32(&pDnode->openVnodes, 1); - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); } } - mgmtAddVgroupIntoDb(pVgroup); + mnodeAddVgroupIntoDb(pVgroup); return TSDB_CODE_SUCCESS; } -static int32_t mgmtVgroupActionDelete(SSdbOper *pOper) { +static int32_t mnodeVgroupActionDelete(SSdbOper *pOper) { SVgObj *pVgroup = pOper->pObj; if (pVgroup->pDb != NULL) { - mgmtRemoveVgroupFromDb(pVgroup); + mnodeRemoveVgroupFromDb(pVgroup); } - mgmtDecDbRef(pVgroup->pDb); + mnodeDecDbRef(pVgroup->pDb); for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) { - SDnodeObj *pDnode = mgmtGetDnode(pVgroup->vnodeGid[i].dnodeId); + SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId); if (pDnode != NULL) { atomic_sub_fetch_32(&pDnode->openVnodes, 1); } - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); } return TSDB_CODE_SUCCESS; } -static void mgmtVgroupUpdateIdPool(SVgObj *pVgroup) { +static void mnodeVgroupUpdateIdPool(SVgObj *pVgroup) { int32_t oldTables = taosIdPoolMaxSize(pVgroup->idPool); SDbObj *pDb = pVgroup->pDb; if (pDb != NULL) { @@ -135,9 +137,9 @@ static void mgmtVgroupUpdateIdPool(SVgObj *pVgroup) { } } -static int32_t mgmtVgroupActionUpdate(SSdbOper *pOper) { +static int32_t mnodeVgroupActionUpdate(SSdbOper *pOper) { SVgObj *pNew = pOper->pObj; - SVgObj *pVgroup = mgmtGetVgroup(pNew->vgId); + SVgObj *pVgroup = mnodeGetVgroup(pNew->vgId); if (pVgroup != pNew) { for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) { @@ -151,24 +153,24 @@ static int32_t mgmtVgroupActionUpdate(SSdbOper *pOper) { free(pNew); for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) { - SDnodeObj *pDnode = mgmtGetDnode(pVgroup->vnodeGid[i].dnodeId); + SDnodeObj *pDnode = mnodeGetDnode(pVgroup->vnodeGid[i].dnodeId); pVgroup->vnodeGid[i].pDnode = pDnode; if (pDnode != NULL) { atomic_add_fetch_32(&pDnode->openVnodes, 1); } - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); } } - mgmtVgroupUpdateIdPool(pVgroup); + mnodeVgroupUpdateIdPool(pVgroup); - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); mTrace("vgId:%d, is updated, numOfVnode:%d", pVgroup->vgId, pVgroup->numOfVnodes); return TSDB_CODE_SUCCESS; } -static int32_t mgmtVgroupActionEncode(SSdbOper *pOper) { +static int32_t mnodeVgroupActionEncode(SSdbOper *pOper) { SVgObj *pVgroup = pOper->pObj; memcpy(pOper->rowData, pVgroup, tsVgUpdateSize); SVgObj *pTmpVgroup = pOper->rowData; @@ -181,7 +183,7 @@ static int32_t mgmtVgroupActionEncode(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtVgroupActionDecode(SSdbOper *pOper) { +static int32_t mnodeVgroupActionDecode(SSdbOper *pOper) { SVgObj *pVgroup = (SVgObj *) calloc(1, sizeof(SVgObj)); if (pVgroup == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; @@ -190,11 +192,11 @@ static int32_t mgmtVgroupActionDecode(SSdbOper *pOper) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtVgroupActionRestored() { +static int32_t mnodeVgroupActionRestored() { return 0; } -int32_t mgmtInitVgroups() { +int32_t mnodeInitVgroups() { SVgObj tObj; tsVgUpdateSize = (int8_t *)tObj.updateEnd - (int8_t *)&tObj; @@ -205,13 +207,13 @@ int32_t mgmtInitVgroups() { .maxRowSize = tsVgUpdateSize, .refCountPos = (int8_t *)(&tObj.refCount) - (int8_t *)&tObj, .keyType = SDB_KEY_AUTO, - .insertFp = mgmtVgroupActionInsert, - .deleteFp = mgmtVgroupActionDelete, - .updateFp = mgmtVgroupActionUpdate, - .encodeFp = mgmtVgroupActionEncode, - .decodeFp = mgmtVgroupActionDecode, - .destroyFp = mgmtVgroupActionDestroy, - .restoredFp = mgmtVgroupActionRestored, + .insertFp = mnodeVgroupActionInsert, + .deleteFp = mnodeVgroupActionDelete, + .updateFp = mnodeVgroupActionUpdate, + .encodeFp = mnodeVgroupActionEncode, + .decodeFp = mnodeVgroupActionDecode, + .destroyFp = mnodeVgroupActionDestroy, + .restoredFp = mnodeVgroupActionRestored, }; tsVgroupSdb = sdbOpenTable(&tableDesc); @@ -220,30 +222,30 @@ int32_t mgmtInitVgroups() { return -1; } - mnodeAddShowMetaHandle(TSDB_MNODE_TABLE_VGROUP, mgmtGetVgroupMeta); - mnodeAddShowRetrieveHandle(TSDB_MNODE_TABLE_VGROUP, mgmtRetrieveVgroups); - dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP, mgmtProcessCreateVnodeRsp); - dnodeAddClientRspHandle(TSDB_MSG_TYPE_MD_DROP_VNODE_RSP, mgmtProcessDropVnodeRsp); - dnodeAddServerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_VNODE, mgmtProcessVnodeCfgMsg); + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_VGROUP, mnodeGetVgroupMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_VGROUP, mnodeRetrieveVgroups); + mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_CREATE_VNODE_RSP, mnodeProcessCreateVnodeRsp); + mnodeAddPeerRspHandle(TSDB_MSG_TYPE_MD_DROP_VNODE_RSP, mnodeProcessDropVnodeRsp); + mnodeAddPeerMsgHandle(TSDB_MSG_TYPE_DM_CONFIG_VNODE, mnodeProcessVnodeCfgMsg); mTrace("table:vgroups is created"); return 0; } -void mgmtIncVgroupRef(SVgObj *pVgroup) { +void mnodeIncVgroupRef(SVgObj *pVgroup) { return sdbIncRef(tsVgroupSdb, pVgroup); } -void mgmtDecVgroupRef(SVgObj *pVgroup) { +void mnodeDecVgroupRef(SVgObj *pVgroup) { return sdbDecRef(tsVgroupSdb, pVgroup); } -SVgObj *mgmtGetVgroup(int32_t vgId) { +SVgObj *mnodeGetVgroup(int32_t vgId) { return (SVgObj *)sdbGetRow(tsVgroupSdb, &vgId); } -void mgmtUpdateVgroup(SVgObj *pVgroup) { +void mnodeUpdateVgroup(SVgObj *pVgroup) { SSdbOper oper = { .type = SDB_OPER_GLOBAL, .table = tsVgroupSdb, @@ -251,10 +253,10 @@ void mgmtUpdateVgroup(SVgObj *pVgroup) { }; sdbUpdateRow(&oper); - mgmtSendCreateVgroupMsg(pVgroup, NULL); + mnodeSendCreateVgroupMsg(pVgroup, NULL); } -void mgmtUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVload) { +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]; @@ -269,9 +271,9 @@ void mgmtUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVlo } if (!dnodeExist) { - SRpcIpSet ipSet = mgmtGetIpSetFromIp(pDnode->dnodeEp); + SRpcIpSet ipSet = mnodeGetIpSetFromIp(pDnode->dnodeEp); mError("vgId:%d, dnode:%d not exist in mnode, drop it", pVload->vgId, pDnode->dnodeId); - mgmtSendDropVnodeMsg(pVload->vgId, &ipSet, NULL); + mnodeSendDropVnodeMsg(pVload->vgId, &ipSet, NULL); return; } @@ -285,19 +287,19 @@ void mgmtUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVlo mError("dnode:%d, vgId:%d, vnode cfgVersion:%d repica:%d not match with mgmt cfgVersion:%d replica:%d", pDnode->dnodeId, pVload->vgId, pVload->cfgVersion, pVload->replica, pVgroup->pDb->cfgVersion, pVgroup->numOfVnodes); - mgmtSendCreateVgroupMsg(pVgroup, NULL); + mnodeSendCreateVgroupMsg(pVgroup, NULL); } } -SVgObj *mgmtGetAvailableVgroup(SDbObj *pDb) { +SVgObj *mnodeGetAvailableVgroup(SDbObj *pDb) { return pDb->pHead; } -void *mgmtGetNextVgroup(void *pIter, SVgObj **pVgroup) { +void *mnodeGetNextVgroup(void *pIter, SVgObj **pVgroup) { return sdbFetchRow(tsVgroupSdb, pIter, (void **)pVgroup); } -void mgmtCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { +int32_t mnodeCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { SVgObj *pVgroup = (SVgObj *)calloc(1, sizeof(SVgObj)); strcpy(pVgroup->dbName, pDb->name); pVgroup->numOfVnodes = pDb->cfg.replications; @@ -305,9 +307,8 @@ void mgmtCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { if (balanceAllocVnodes(pVgroup) != 0) { mError("db:%s, no enough dnode to alloc %d vnodes to vgroup", pDb->name, pVgroup->numOfVnodes); free(pVgroup); - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_NO_ENOUGH_DNODES); - mgmtFreeQueuedMsg(pMsg); - return; + mnodeCleanupMsg(pMsg); + return TSDB_CODE_NO_ENOUGH_DNODES; } SSdbOper oper = { @@ -321,9 +322,8 @@ void mgmtCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { if (code != TSDB_CODE_SUCCESS) { tfree(pVgroup); code = TSDB_CODE_SDB_ERROR; - mgmtSendSimpleResp(pMsg->thandle, TSDB_CODE_SDB_ERROR); - mgmtFreeQueuedMsg(pMsg); - return; + mnodeCleanupMsg(pMsg); + return TSDB_CODE_SDB_ERROR; } mPrint("vgId:%d, is created in mnode, db:%s replica:%d", pVgroup->vgId, pDb->name, pVgroup->numOfVnodes); @@ -333,15 +333,17 @@ void mgmtCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { pMsg->ahandle = pVgroup; pMsg->expected = pVgroup->numOfVnodes; - mgmtSendCreateVgroupMsg(pVgroup, pMsg); + mnodeSendCreateVgroupMsg(pVgroup, pMsg); + + return TSDB_CODE_ACTION_IN_PROGRESS; } -void mgmtDropVgroup(SVgObj *pVgroup, void *ahandle) { +void mnodeDropVgroup(SVgObj *pVgroup, void *ahandle) { if (ahandle != NULL) { - mgmtSendDropVgroupMsg(pVgroup, ahandle); + mnodeSendDropVgroupMsg(pVgroup, ahandle); } else { mTrace("vgId:%d, replica:%d is deleting from sdb", pVgroup->vgId, pVgroup->numOfVnodes); - mgmtSendDropVgroupMsg(pVgroup, NULL); + mnodeSendDropVgroupMsg(pVgroup, NULL); SSdbOper oper = { .type = SDB_OPER_GLOBAL, .table = tsVgroupSdb, @@ -351,12 +353,12 @@ void mgmtDropVgroup(SVgObj *pVgroup, void *ahandle) { } } -void mgmtCleanUpVgroups() { +void mnodeCleanupVgroups() { sdbCloseTable(tsVgroupSdb); } -int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { - SDbObj *pDb = mgmtGetDb(pShow->db); +int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { + SDbObj *pDb = mnodeGetDb(pShow->db); if (pDb == NULL) { return TSDB_CODE_DB_NOT_SELECTED; } @@ -380,15 +382,15 @@ int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { SVgObj *pVgroup = NULL; STableObj *pTable = NULL; if (pShow->payloadLen > 0 ) { - pTable = mgmtGetTable(pShow->payload); + pTable = mnodeGetTable(pShow->payload); if (NULL == pTable || pTable->type == TSDB_SUPER_TABLE) { - mgmtDecTableRef(pTable); + mnodeDecTableRef(pTable); return TSDB_CODE_INVALID_TABLE_ID; } - mgmtDecTableRef(pTable); - pVgroup = mgmtGetVgroup(((SChildTableObj*)pTable)->vgId); + mnodeDecTableRef(pTable); + pVgroup = mnodeGetVgroup(((SChildTableObj*)pTable)->vgId); if (NULL == pVgroup) return TSDB_CODE_INVALID_TABLE_ID; - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica; } else { SVgObj *pVgroup = pDb->pHead; @@ -434,19 +436,19 @@ int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { pShow->pIter = pVgroup; } - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); return 0; } -int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn) { +int32_t mnodeRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn) { int32_t numOfRows = 0; SVgObj *pVgroup = NULL; int32_t maxReplica = 0; int32_t cols = 0; char * pWrite; - SDbObj *pDb = mgmtGetDb(pShow->db); + SDbObj *pDb = mnodeGetDb(pShow->db); if (pDb == NULL) return 0; pVgroup = pDb->pHead; @@ -483,7 +485,7 @@ int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pCo cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - char *role = mgmtGetMnodeRoleStr(pVgroup->vnodeGid[i].role); + char *role = mnodeGetMnodeRoleStr(pVgroup->vnodeGid[i].role); STR_TO_VARSTR(pWrite, role); cols++; } else { @@ -502,12 +504,12 @@ int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pCo } pShow->numOfReads += numOfRows; - mgmtDecDbRef(pDb); + mnodeDecDbRef(pDb); return numOfRows; } -void mgmtAddTableIntoVgroup(SVgObj *pVgroup, SChildTableObj *pTable) { +void mnodeAddTableIntoVgroup(SVgObj *pVgroup, SChildTableObj *pTable) { if (pTable->sid >= 1 && pVgroup->tableList[pTable->sid - 1] == NULL) { pVgroup->tableList[pTable->sid - 1] = pTable; taosIdPoolMarkStatus(pVgroup->idPool, pTable->sid); @@ -515,21 +517,21 @@ void mgmtAddTableIntoVgroup(SVgObj *pVgroup, SChildTableObj *pTable) { } if (pVgroup->numOfTables >= pVgroup->pDb->cfg.maxTables) { - mgmtMoveVgroupToTail(pVgroup); + mnodeMoveVgroupToTail(pVgroup); } - mgmtIncVgroupRef(pVgroup); + mnodeIncVgroupRef(pVgroup); } -void mgmtRemoveTableFromVgroup(SVgObj *pVgroup, SChildTableObj *pTable) { +void mnodeRemoveTableFromVgroup(SVgObj *pVgroup, SChildTableObj *pTable) { if (pTable->sid >= 1 && pVgroup->tableList[pTable->sid - 1] != NULL) { pVgroup->tableList[pTable->sid - 1] = NULL; taosFreeId(pVgroup->idPool, pTable->sid); pVgroup->numOfTables--; } - mgmtMoveVgroupToHead(pVgroup); - mgmtDecVgroupRef(pVgroup); + mnodeMoveVgroupToHead(pVgroup); + mnodeDecVgroupRef(pVgroup); } SMDCreateVnodeMsg *mgmtBuildCreateVnodeMsg(SVgObj *pVgroup) { @@ -571,7 +573,7 @@ SMDCreateVnodeMsg *mgmtBuildCreateVnodeMsg(SVgObj *pVgroup) { return pVnode; } -SRpcIpSet mgmtGetIpSetFromVgroup(SVgObj *pVgroup) { +SRpcIpSet mnodeGetIpSetFromVgroup(SVgObj *pVgroup) { SRpcIpSet ipSet = { .numOfIps = pVgroup->numOfVnodes, .inUse = 0, @@ -583,7 +585,7 @@ SRpcIpSet mgmtGetIpSetFromVgroup(SVgObj *pVgroup) { return ipSet; } -SRpcIpSet mgmtGetIpSetFromIp(char *ep) { +SRpcIpSet mnodeGetIpSetFromIp(char *ep) { SRpcIpSet ipSet; ipSet.numOfIps = 1; @@ -593,7 +595,7 @@ SRpcIpSet mgmtGetIpSetFromIp(char *ep) { return ipSet; } -void mgmtSendCreateVnodeMsg(SVgObj *pVgroup, SRpcIpSet *ipSet, void *ahandle) { +void mnodeSendCreateVnodeMsg(SVgObj *pVgroup, SRpcIpSet *ipSet, void *ahandle) { mTrace("vgId:%d, send create vnode:%d msg, ahandle:%p", pVgroup->vgId, pVgroup->vgId, ahandle); SMDCreateVnodeMsg *pCreate = mgmtBuildCreateVnodeMsg(pVgroup); SRpcMsg rpcMsg = { @@ -606,34 +608,33 @@ void mgmtSendCreateVnodeMsg(SVgObj *pVgroup, SRpcIpSet *ipSet, void *ahandle) { dnodeSendMsgToDnode(ipSet, &rpcMsg); } -void mgmtSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle) { +void mnodeSendCreateVgroupMsg(SVgObj *pVgroup, void *ahandle) { mTrace("vgId:%d, send create all vnodes msg, ahandle:%p", pVgroup->vgId, ahandle); for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) { - SRpcIpSet ipSet = mgmtGetIpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp); - mgmtSendCreateVnodeMsg(pVgroup, &ipSet, ahandle); + SRpcIpSet ipSet = mnodeGetIpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp); + mnodeSendCreateVnodeMsg(pVgroup, &ipSet, ahandle); } } -static void mgmtProcessCreateVnodeRsp(SRpcMsg *rpcMsg) { +static void mnodeProcessCreateVnodeRsp(SRpcMsg *rpcMsg) { if (rpcMsg->handle == NULL) return; - SMnodeMsg *queueMsg = rpcMsg->handle; - queueMsg->received++; + SMnodeMsg *mnodeMsg = rpcMsg->handle; + mnodeMsg->received++; if (rpcMsg->code == TSDB_CODE_SUCCESS) { - queueMsg->code = rpcMsg->code; - queueMsg->successed++; + mnodeMsg->code = rpcMsg->code; + mnodeMsg->successed++; } - SVgObj *pVgroup = queueMsg->ahandle; + SVgObj *pVgroup = mnodeMsg->ahandle; mTrace("vgId:%d, create vnode rsp received, result:%s received:%d successed:%d expected:%d, thandle:%p ahandle:%p", - pVgroup->vgId, tstrerror(rpcMsg->code), queueMsg->received, queueMsg->successed, queueMsg->expected, - queueMsg->thandle, rpcMsg->handle); + pVgroup->vgId, tstrerror(rpcMsg->code), mnodeMsg->received, mnodeMsg->successed, mnodeMsg->expected, + mnodeMsg->thandle, rpcMsg->handle); - if (queueMsg->received != queueMsg->expected) return; + if (mnodeMsg->received != mnodeMsg->expected) return; - if (queueMsg->received == queueMsg->successed) { - SMnodeMsg *newMsg = mgmtCloneQueuedMsg(queueMsg); - mgmtAddToShellQueue(newMsg); + if (mnodeMsg->received == mnodeMsg->successed) { + dnodeReprocessMnodeWriteMsg(mnodeMsg); } else { SSdbOper oper = { .type = SDB_OPER_GLOBAL, @@ -644,11 +645,9 @@ static void mgmtProcessCreateVnodeRsp(SRpcMsg *rpcMsg) { if (code != 0) { code = TSDB_CODE_SDB_ERROR; } - - mgmtSendSimpleResp(queueMsg->thandle, rpcMsg->code); - } - mgmtFreeQueuedMsg(queueMsg); + dnodeSendRpcMnodeWriteRsp(mnodeMsg, code); + } } static SMDDropVnodeMsg *mgmtBuildDropVnodeMsg(int32_t vgId) { @@ -659,7 +658,7 @@ static SMDDropVnodeMsg *mgmtBuildDropVnodeMsg(int32_t vgId) { return pDrop; } -void mgmtSendDropVnodeMsg(int32_t vgId, SRpcIpSet *ipSet, void *ahandle) { +void mnodeSendDropVnodeMsg(int32_t vgId, SRpcIpSet *ipSet, void *ahandle) { SMDDropVnodeMsg *pDrop = mgmtBuildDropVnodeMsg(vgId); SRpcMsg rpcMsg = { .handle = ahandle, @@ -671,32 +670,32 @@ void mgmtSendDropVnodeMsg(int32_t vgId, SRpcIpSet *ipSet, void *ahandle) { dnodeSendMsgToDnode(ipSet, &rpcMsg); } -static void mgmtSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle) { +static void mnodeSendDropVgroupMsg(SVgObj *pVgroup, void *ahandle) { mTrace("vgId:%d, send drop all vnodes msg, ahandle:%p", pVgroup->vgId, ahandle); for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) { - SRpcIpSet ipSet = mgmtGetIpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp); + SRpcIpSet ipSet = mnodeGetIpSetFromIp(pVgroup->vnodeGid[i].pDnode->dnodeEp); mTrace("vgId:%d, send drop vnode msg to dnode:%d, ahandle:%p", pVgroup->vgId, pVgroup->vnodeGid[i].dnodeId, ahandle); - mgmtSendDropVnodeMsg(pVgroup->vgId, &ipSet, ahandle); + mnodeSendDropVnodeMsg(pVgroup->vgId, &ipSet, ahandle); } } -static void mgmtProcessDropVnodeRsp(SRpcMsg *rpcMsg) { +static void mnodeProcessDropVnodeRsp(SRpcMsg *rpcMsg) { mTrace("drop vnode rsp is received, handle:%p", rpcMsg->handle); if (rpcMsg->handle == NULL) return; - SMnodeMsg *queueMsg = rpcMsg->handle; - queueMsg->received++; + SMnodeMsg *mnodeMsg = rpcMsg->handle; + mnodeMsg->received++; if (rpcMsg->code == TSDB_CODE_SUCCESS) { - queueMsg->code = rpcMsg->code; - queueMsg->successed++; + mnodeMsg->code = rpcMsg->code; + mnodeMsg->successed++; } - SVgObj *pVgroup = queueMsg->ahandle; + SVgObj *pVgroup = mnodeMsg->ahandle; mTrace("vgId:%d, drop vnode rsp received, result:%s received:%d successed:%d expected:%d, thandle:%p ahandle:%p", - pVgroup->vgId, tstrerror(rpcMsg->code), queueMsg->received, queueMsg->successed, queueMsg->expected, - queueMsg->thandle, rpcMsg->handle); + pVgroup->vgId, tstrerror(rpcMsg->code), mnodeMsg->received, mnodeMsg->successed, mnodeMsg->expected, + mnodeMsg->thandle, rpcMsg->handle); - if (queueMsg->received != queueMsg->expected) return; + if (mnodeMsg->received != mnodeMsg->expected) return; SSdbOper oper = { .type = SDB_OPER_GLOBAL, @@ -708,41 +707,35 @@ static void mgmtProcessDropVnodeRsp(SRpcMsg *rpcMsg) { code = TSDB_CODE_SDB_ERROR; } - SMnodeMsg *newMsg = mgmtCloneQueuedMsg(queueMsg); - mgmtAddToShellQueue(newMsg); - - queueMsg->pCont = NULL; - mgmtFreeQueuedMsg(queueMsg); + dnodeReprocessMnodeWriteMsg(mnodeMsg); } -static void mgmtProcessVnodeCfgMsg(SRpcMsg *rpcMsg) { - SDMConfigVnodeMsg *pCfg = (SDMConfigVnodeMsg *) rpcMsg->pCont; +static int32_t mnodeProcessVnodeCfgMsg(SMnodeMsg *pMsg) { + SDMConfigVnodeMsg *pCfg = (SDMConfigVnodeMsg *) pMsg->pCont; pCfg->dnodeId = htonl(pCfg->dnodeId); pCfg->vgId = htonl(pCfg->vgId); - SDnodeObj *pDnode = mgmtGetDnode(pCfg->dnodeId); + SDnodeObj *pDnode = mnodeGetDnode(pCfg->dnodeId); if (pDnode == NULL) { mTrace("dnode:%s, invalid dnode", taosIpStr(pCfg->dnodeId), pCfg->vgId); - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_NOT_ACTIVE_VNODE); - return; + return TSDB_CODE_NOT_ACTIVE_VNODE; } - mgmtDecDnodeRef(pDnode); + mnodeDecDnodeRef(pDnode); - SVgObj *pVgroup = mgmtGetVgroup(pCfg->vgId); + SVgObj *pVgroup = mnodeGetVgroup(pCfg->vgId); if (pVgroup == NULL) { mTrace("dnode:%s, vgId:%d, no vgroup info", taosIpStr(pCfg->dnodeId), pCfg->vgId); - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_NOT_ACTIVE_VNODE); - return; + return TSDB_CODE_NOT_ACTIVE_VNODE; } - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); - mgmtSendSimpleResp(rpcMsg->handle, TSDB_CODE_SUCCESS); + SRpcIpSet ipSet = mnodeGetIpSetFromIp(pDnode->dnodeEp); + mnodeSendCreateVnodeMsg(pVgroup, &ipSet, NULL); - SRpcIpSet ipSet = mgmtGetIpSetFromIp(pDnode->dnodeEp); - mgmtSendCreateVnodeMsg(pVgroup, &ipSet, NULL); + return TSDB_CODE_SUCCESS; } -void mgmtDropAllDnodeVgroups(SDnodeObj *pDropDnode) { +void mnodeDropAllDnodeVgroups(SDnodeObj *pDropDnode) { void * pIter = NULL; SVgObj *pVgroup = NULL; int32_t numOfVgroups = 0; @@ -750,11 +743,11 @@ void mgmtDropAllDnodeVgroups(SDnodeObj *pDropDnode) { mPrint("dnode:%d, all vgroups will be dropped from sdb", pDropDnode->dnodeId); while (1) { - pIter = mgmtGetNextVgroup(pIter, &pVgroup); + pIter = mnodeGetNextVgroup(pIter, &pVgroup); if (pVgroup == NULL) break; if (pVgroup->vnodeGid[0].dnodeId == pDropDnode->dnodeId) { - mgmtDropAllChildTablesInVgroups(pVgroup); + mnodeDropAllChildTablesInVgroups(pVgroup); SSdbOper oper = { .type = SDB_OPER_LOCAL, .table = tsVgroupSdb, @@ -763,7 +756,7 @@ void mgmtDropAllDnodeVgroups(SDnodeObj *pDropDnode) { sdbDeleteRow(&oper); numOfVgroups++; } - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); } sdbFreeIter(pIter); @@ -771,21 +764,21 @@ void mgmtDropAllDnodeVgroups(SDnodeObj *pDropDnode) { mPrint("dnode:%d, all vgroups is dropped from sdb", pDropDnode->dnodeId); } -void mgmtUpdateAllDbVgroups(SDbObj *pAlterDb) { +void mnodeUpdateAllDbVgroups(SDbObj *pAlterDb) { void * pIter = NULL; SVgObj *pVgroup = NULL; mPrint("db:%s, all vgroups will be update in sdb", pAlterDb->name); while (1) { - pIter = mgmtGetNextVgroup(pIter, &pVgroup); + pIter = mnodeGetNextVgroup(pIter, &pVgroup); if (pVgroup == NULL) break; if (pVgroup->pDb == pAlterDb) { - mgmtVgroupUpdateIdPool(pVgroup); + mnodeVgroupUpdateIdPool(pVgroup); } - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); } sdbFreeIter(pIter); @@ -793,14 +786,14 @@ void mgmtUpdateAllDbVgroups(SDbObj *pAlterDb) { mPrint("db:%s, all vgroups is updated in sdb", pAlterDb->name); } -void mgmtDropAllDbVgroups(SDbObj *pDropDb, bool sendMsg) { +void mnodeDropAllDbVgroups(SDbObj *pDropDb, bool sendMsg) { void * pIter = NULL; int32_t numOfVgroups = 0; SVgObj *pVgroup = NULL; mPrint("db:%s, all vgroups will be dropped from sdb", pDropDb->name); while (1) { - pIter = mgmtGetNextVgroup(pIter, &pVgroup); + pIter = mnodeGetNextVgroup(pIter, &pVgroup); if (pVgroup == NULL) break; if (pVgroup->pDb == pDropDb) { @@ -813,11 +806,11 @@ void mgmtDropAllDbVgroups(SDbObj *pDropDb, bool sendMsg) { numOfVgroups++; if (sendMsg) { - mgmtSendDropVgroupMsg(pVgroup, NULL); + mnodeSendDropVgroupMsg(pVgroup, NULL); } } - mgmtDecVgroupRef(pVgroup); + mnodeDecVgroupRef(pVgroup); } sdbFreeIter(pIter); diff --git a/src/mnode/src/mnodeWrite.c b/src/mnode/src/mnodeWrite.c index 69a4a53077..33a5399fe2 100644 --- a/src/mnode/src/mnodeWrite.c +++ b/src/mnode/src/mnodeWrite.c @@ -19,12 +19,11 @@ #include "tsched.h" #include "tbalance.h" #include "tgrant.h" -#include "ttimer.h" #include "tglobal.h" +#include "mnode.h" #include "dnode.h" #include "mnodeDef.h" #include "mnodeInt.h" -#include "mnodeServer.h" #include "mnodeAcct.h" #include "mnodeDnode.h" #include "mnodeMnode.h" @@ -33,29 +32,28 @@ #include "mnodeVgroup.h" #include "mnodeUser.h" #include "mnodeTable.h" -#include "mnodeShell.h" +#include "mnodeShow.h" -static void (*tsMnodeProcessWriteMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *); +static int32_t (*tsMnodeProcessWriteMsgFp[TSDB_MSG_TYPE_MAX])(SMnodeMsg *); -void mnodeAddWriteMsgHandle(uint8_t msgType, void (*fp)(SMnodeMsg *pMsg)) { +void mnodeAddWriteMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg)) { tsMnodeProcessWriteMsgFp[msgType] = fp; } int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { - SRpcMsg *rpcMsg = &pMsg->rpcMsg; - if (rpcMsg->pCont == NULL) { - mError("%p, msg:%s content is null", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + if (pMsg->pCont == NULL) { + mError("msg:%s content is null", taosMsg[pMsg->msgType]); return TSDB_CODE_INVALID_MSG_LEN; } if (!sdbIsMaster()) { SMnodeRsp *rpcRsp = &pMsg->rpcRsp; SRpcIpSet *ipSet = rpcMallocCont(sizeof(SRpcIpSet)); - mgmtGetMnodeIpSetForShell(ipSet); + mnodeGetMnodeIpSetForShell(ipSet); rpcRsp->rsp = ipSet; rpcRsp->len = sizeof(SRpcIpSet); - mTrace("%p, msg:%s will be redireced, inUse:%d", rpcMsg->ahandle, taosMsg[rpcMsg->msgType], ipSet->inUse); + mTrace("msg:%s will be redireced, inUse:%d", taosMsg[pMsg->msgType], ipSet->inUse); for (int32_t i = 0; i < ipSet->numOfIps; ++i) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } @@ -63,34 +61,20 @@ int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { return TSDB_CODE_REDIRECT; } - if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) { - mError("%p, msg:%s not processed, grant time expired", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); - return TSDB_CODE_GRANT_EXPIRED; - } - - if (tsMnodeProcessReadMsgFp[rpcMsg->msgType] == NULL) { - mError("%p, msg:%s not processed, no handle exist", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + if (tsMnodeProcessWriteMsgFp[pMsg->msgType] == NULL) { + mError("msg:%s not processed, no handle exist", taosMsg[pMsg->msgType]); return TSDB_CODE_MSG_NOT_PROCESSED; } if (!mnodeInitMsg(pMsg)) { - mError("%p, msg:%s not processed, reason:%s", rpcMsg->ahandle, taosMsg[rpcMsg->msgType], tstrerror(terrno)); + mError("msg:%s not processed, reason:%s", taosMsg[pMsg->msgType], tstrerror(terrno)); return terrno; } if (!pMsg->pUser->writeAuth) { - mError("%p, msg:%s not processed, no rights", rpcMsg->ahandle, taosMsg[rpcMsg->msgType]); + mError("%p, msg:%s not processed, no rights", taosMsg[pMsg->msgType]); return TSDB_CODE_NO_RIGHTS; } - return (*tsMnodeProcessWriteMsgFp[rpcMsg->msgType])(pMsg); + return (*tsMnodeProcessWriteMsgFp[pMsg->msgType])(pMsg); } - -static void mgmtDoDealyedAddToShellQueue(void *param, void *tmrId) { - mgmtAddToShellQueue(param); -} - -void mgmtDealyedAddToShellQueue(SMnodeMsg *queuedMsg) { - void *unUsed = NULL; - taosTmrReset(mgmtDoDealyedAddToShellQueue, 300, queuedMsg, tsMgmtTmr, &unUsed); -} \ No newline at end of file From d1003fedff1983e5165e931e03ebb994b0b9d68d Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Wed, 27 May 2020 10:57:38 +0000 Subject: [PATCH 05/17] [TD-335] message put into peer queue --- src/dnode/inc/dnodeMPeer.h | 2 ++ src/dnode/inc/dnodeMRead.h | 2 ++ src/dnode/inc/dnodeMWrite.h | 2 ++ src/dnode/src/dnodePeer.c | 30 ++++++++++++++---------------- src/dnode/src/dnodeShell.c | 6 +++--- src/mnode/inc/mnodePeer.h | 1 + src/mnode/src/mnodePeer.c | 2 -- 7 files changed, 24 insertions(+), 21 deletions(-) diff --git a/src/dnode/inc/dnodeMPeer.h b/src/dnode/inc/dnodeMPeer.h index 0015532f15..cdbb4a210c 100644 --- a/src/dnode/inc/dnodeMPeer.h +++ b/src/dnode/inc/dnodeMPeer.h @@ -22,6 +22,8 @@ extern "C" { int32_t dnodeInitMnodePeer(); void dnodeCleanupMnodePeer(); +int32_t dnodeAllocateMnodePqueue(); +void dnodeFreeMnodePqueue(); void dnodeDispatchToMnodePeerQueue(SRpcMsg *pMsg); #ifdef __cplusplus diff --git a/src/dnode/inc/dnodeMRead.h b/src/dnode/inc/dnodeMRead.h index 0b340a865f..4e93838b79 100644 --- a/src/dnode/inc/dnodeMRead.h +++ b/src/dnode/inc/dnodeMRead.h @@ -22,6 +22,8 @@ extern "C" { int32_t dnodeInitMnodeRead(); void dnodeCleanupMnodeRead(); +int32_t dnodeAllocateMnodeRqueue(); +void dnodeFreeMnodeRqueue(); void dnodeDispatchToMnodeReadQueue(SRpcMsg *rpcMsg); #ifdef __cplusplus diff --git a/src/dnode/inc/dnodeMWrite.h b/src/dnode/inc/dnodeMWrite.h index 7a3ec93446..498fea81c5 100644 --- a/src/dnode/inc/dnodeMWrite.h +++ b/src/dnode/inc/dnodeMWrite.h @@ -22,6 +22,8 @@ extern "C" { int32_t dnodeInitMnodeWrite(); void dnodeCleanupMnodeWrite(); +int32_t dnodeAllocateMnodeWqueue(); +void dnodeFreeMnodeWqueue(); void dnodeDispatchToMnodeWriteQueue(SRpcMsg *pMsg); #ifdef __cplusplus diff --git a/src/dnode/src/dnodePeer.c b/src/dnode/src/dnodePeer.c index 53e664b58b..bde6cd2aa7 100644 --- a/src/dnode/src/dnodePeer.c +++ b/src/dnode/src/dnodePeer.c @@ -28,8 +28,7 @@ #include "dnodeInt.h" #include "dnodeMgmt.h" #include "dnodeVWrite.h" -#include "dnodeMRead.h" -#include "dnodeMWrite.h" +#include "dnodeMPeer.h" extern void dnodeUpdateMnodeIpSetForPeer(SRpcIpSet *pIpSet); static void (*dnodeProcessReqMsgFp[TSDB_MSG_TYPE_MAX])(SRpcMsg *); @@ -50,11 +49,11 @@ int32_t dnodeInitServer() { dnodeProcessReqMsgFp[TSDB_MSG_TYPE_MD_ALTER_STREAM] = dnodeDispatchToDnodeMgmt; dnodeProcessReqMsgFp[TSDB_MSG_TYPE_MD_CONFIG_DNODE] = dnodeDispatchToDnodeMgmt; - dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = dnodeDispatchToMnodeReadQueue; - dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = dnodeDispatchToMnodeReadQueue; - dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_AUTH] = dnodeDispatchToMnodeReadQueue; - dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_GRANT] = dnodeDispatchToMnodeWriteQueue; - dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_STATUS] = dnodeDispatchToMnodeWriteQueue; + dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_TABLE] = dnodeDispatchToMnodePeerQueue; + dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_CONFIG_VNODE] = dnodeDispatchToMnodePeerQueue; + dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_AUTH] = dnodeDispatchToMnodePeerQueue; + dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_GRANT] = dnodeDispatchToMnodePeerQueue; + dnodeProcessReqMsgFp[TSDB_MSG_TYPE_DM_STATUS] = dnodeDispatchToMnodePeerQueue; SRpcInit rpcInit; memset(&rpcInit, 0, sizeof(rpcInit)); @@ -103,16 +102,14 @@ static void dnodeProcessReqMsgFromDnode(SRpcMsg *pMsg, SRpcIpSet *pIpSet) { rpcSendResponse(&rspMsg); return; } - + if (dnodeProcessReqMsgFp[pMsg->msgType]) { (*dnodeProcessReqMsgFp[pMsg->msgType])(pMsg); } else { + dTrace("RPC %p, message:%s not processed", pMsg->handle, taosMsg[pMsg->msgType]); rspMsg.code = TSDB_CODE_MSG_NOT_PROCESSED; rpcSendResponse(&rspMsg); rpcFreeCont(pMsg->pCont); - dTrace("RPC %p, message:%s not processed", pMsg->handle, taosMsg[pMsg->msgType]); - return; - } } @@ -148,13 +145,14 @@ void dnodeCleanupClient() { } static void dnodeProcessRspFromDnode(SRpcMsg *pMsg, SRpcIpSet *pIpSet) { - if (dnodeProcessRspMsgFp[pMsg->msgType]) { - if (pMsg->msgType == TSDB_MSG_TYPE_DM_STATUS_RSP && pIpSet) { - dnodeUpdateMnodeIpSetForPeer(pIpSet); - } + if (pMsg->msgType == TSDB_MSG_TYPE_DM_STATUS_RSP && pIpSet) { + dnodeUpdateMnodeIpSetForPeer(pIpSet); + } + + if (dnodeProcessRspMsgFp[pMsg->msgType]) { (*dnodeProcessRspMsgFp[pMsg->msgType])(pMsg); } else { - dError("RPC %p, msg:%s is not processed", pMsg->handle, taosMsg[pMsg->msgType]); + mnodeProcessPeerRsp(pMsg); } rpcFreeCont(pMsg->pCont); diff --git a/src/dnode/src/dnodeShell.c b/src/dnode/src/dnodeShell.c index 68dfaef408..bf40dd4326 100644 --- a/src/dnode/src/dnodeShell.c +++ b/src/dnode/src/dnodeShell.c @@ -61,9 +61,10 @@ int32_t dnodeInitShell() { dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_QUERY] = dnodeDispatchToMnodeWriteQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_STREAM] = dnodeDispatchToMnodeWriteQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_KILL_CONN] = dnodeDispatchToMnodeWriteQueue; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = dnodeDispatchToMnodeWriteQueue; - + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE]= dnodeDispatchToMnodeWriteQueue; + // the following message shall be treated as mnode query + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_HEARTBEAT] = dnodeDispatchToMnodeReadQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CONNECT] = dnodeDispatchToMnodeReadQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_USE_DB] = dnodeDispatchToMnodeReadQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLE_META] = dnodeDispatchToMnodeReadQueue; @@ -71,7 +72,6 @@ int32_t dnodeInitShell() { dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = dnodeDispatchToMnodeReadQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_SHOW] = dnodeDispatchToMnodeReadQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE] = dnodeDispatchToMnodeReadQueue; - dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CONFIG_DNODE]= dnodeDispatchToMnodeReadQueue; int32_t numOfThreads = tsNumOfCores * tsNumOfThreadsPerCore; numOfThreads = (int32_t) ((1.0 - tsRatioOfQueryThreads) * numOfThreads / 2.0); diff --git a/src/mnode/inc/mnodePeer.h b/src/mnode/inc/mnodePeer.h index c81617266d..e409d90de9 100644 --- a/src/mnode/inc/mnodePeer.h +++ b/src/mnode/inc/mnodePeer.h @@ -24,6 +24,7 @@ extern "C" { 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); #ifdef __cplusplus } diff --git a/src/mnode/src/mnodePeer.c b/src/mnode/src/mnodePeer.c index a4bb28b02c..e17c52a0b1 100644 --- a/src/mnode/src/mnodePeer.c +++ b/src/mnode/src/mnodePeer.c @@ -81,6 +81,4 @@ void mnodeProcessPeerRsp(SRpcMsg *pMsg) { } else { mError("msg:%s is not processed", pMsg->handle, taosMsg[pMsg->msgType]); } - - rpcFreeCont(pMsg->pCont); } From 5a601c83f137c982f0a265d6558acfa4f6180729 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 01:35:26 +0000 Subject: [PATCH 06/17] [TD-335] optimize mnode queue --- src/dnode/src/dnodeMPeer.c | 2 +- src/dnode/src/dnodeMRead.c | 2 +- src/dnode/src/dnodeMWrite.c | 2 +- src/inc/dnode.h | 8 +++++++- src/mnode/src/mnodeDnode.c | 2 +- src/mnode/src/mnodeMain.c | 9 ++++++++- src/mnode/src/mnodePeer.c | 6 +++--- src/mnode/src/mnodeRead.c | 13 +++++++------ src/mnode/src/mnodeShow.c | 3 +++ src/mnode/src/mnodeWrite.c | 15 ++++++++------- 10 files changed, 40 insertions(+), 22 deletions(-) diff --git a/src/dnode/src/dnodeMPeer.c b/src/dnode/src/dnodeMPeer.c index 400215472d..dec4f5ef59 100644 --- a/src/dnode/src/dnodeMPeer.c +++ b/src/dnode/src/dnodeMPeer.c @@ -145,7 +145,7 @@ static void *dnodeProcessMnodePeerQueue(void *param) { break; } - dTrace("%p, msg:%s will be processed", pPeerMsg->ahandle, taosMsg[pPeerMsg->msgType]); + dTrace("%p, msg:%s will be processed in mpeer queue", pPeerMsg->ahandle, taosMsg[pPeerMsg->msgType]); int32_t code = mnodeProcessPeerReq(pPeerMsg); dnodeSendRpcMnodePeerRsp(pPeerMsg, code); taosFreeQitem(pPeerMsg); diff --git a/src/dnode/src/dnodeMRead.c b/src/dnode/src/dnodeMRead.c index 64375a3d7b..2ab5f48a9a 100644 --- a/src/dnode/src/dnodeMRead.c +++ b/src/dnode/src/dnodeMRead.c @@ -150,7 +150,7 @@ static void *dnodeProcessMnodeReadQueue(void *param) { break; } - dTrace("%p, msg:%s will be processed", pReadMsg->ahandle, taosMsg[pReadMsg->msgType]); + dTrace("%p, msg:%s will be processed in mread queue", pReadMsg->ahandle, taosMsg[pReadMsg->msgType]); int32_t code = mnodeProcessRead(pReadMsg); dnodeSendRpcMnodeReadRsp(pReadMsg, code); taosFreeQitem(pReadMsg); diff --git a/src/dnode/src/dnodeMWrite.c b/src/dnode/src/dnodeMWrite.c index 56022b4bf6..89c44d829b 100644 --- a/src/dnode/src/dnodeMWrite.c +++ b/src/dnode/src/dnodeMWrite.c @@ -148,7 +148,7 @@ static void *dnodeProcessMnodeWriteQueue(void *param) { break; } - dTrace("%p, msg:%s will be processed", pWriteMsg->ahandle, taosMsg[pWriteMsg->msgType]); + dTrace("%p, msg:%s will be processed in mwrite queue", pWriteMsg->ahandle, taosMsg[pWriteMsg->msgType]); int32_t code = mnodeProcessWrite(pWriteMsg); dnodeSendRpcMnodeWriteRsp(pWriteMsg, code); taosFreeQitem(pWriteMsg); diff --git a/src/inc/dnode.h b/src/inc/dnode.h index 54108af4b9..ff4cc7f81f 100644 --- a/src/inc/dnode.h +++ b/src/inc/dnode.h @@ -51,10 +51,16 @@ void * dnodeGetMnodeInfos(); int32_t dnodeGetDnodeId(); void dnodeAddClientRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)); -void dnodeAddServerMsgHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)); void dnodeSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg); void dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp); +int32_t dnodeAllocateMnodeWqueue(); +void dnodeFreeMnodeWqueue(); +int32_t dnodeAllocateMnodeRqueue(); +void dnodeFreeMnodeRqueue(); +int32_t dnodeAllocateMnodePqueue(); +void dnodeFreeMnodePqueue(); + void dnodeSendRpcMnodeWriteRsp(void *pMsg, int32_t code); void dnodeReprocessMnodeWriteMsg(void *pMsg); void dnodeDelayReprocessMnodeWriteMsg(void *pMsg); diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c index 57ce07dbcf..5872081d67 100644 --- a/src/mnode/src/mnodeDnode.c +++ b/src/mnode/src/mnodeDnode.c @@ -314,7 +314,7 @@ static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg) { if (pStatus->dnodeId == 0) { mTrace("dnode:%d %s, first access", pDnode->dnodeId, pDnode->dnodeEp); } else { - //mTrace("dnode:%d, status received, access times %d", pDnode->dnodeId, pDnode->lastAccess); + mTrace("dnode:%d, status received, access times %d", pDnode->dnodeId, pDnode->lastAccess); } int32_t openVnodes = htons(pStatus->openVnodes); diff --git a/src/mnode/src/mnodeMain.c b/src/mnode/src/mnodeMain.c index 6e3b3d24e9..f1be6a8a87 100644 --- a/src/mnode/src/mnodeMain.c +++ b/src/mnode/src/mnodeMain.c @@ -53,6 +53,10 @@ int32_t mnodeStartSystem() { mkdir(tsMnodeDir, 0755); } + dnodeAllocateMnodeWqueue(); + dnodeAllocateMnodeRqueue(); + dnodeAllocateMnodePqueue(); + if (mnodeInitAccts() < 0) { mError("failed to init accts"); return -1; @@ -125,6 +129,9 @@ void mnodeCleanupSystem() { mPrint("starting to clean up mgmt"); tsMgmtIsRunning = false; + dnodeFreeMnodeWqueue(); + dnodeFreeMnodeRqueue(); + dnodeFreeMnodePqueue(); mnodeCleanupTimer(); mnodeCleanUpShow(); grantCleanUp(); @@ -152,7 +159,7 @@ void mgmtStopSystem() { } static void mnodeInitTimer() { - if (tsMnodeTmr != NULL) { + if (tsMnodeTmr == NULL) { tsMnodeTmr = taosTmrInit((tsMaxShellConns)*3, 200, 3600000, "MND"); } } diff --git a/src/mnode/src/mnodePeer.c b/src/mnode/src/mnodePeer.c index e17c52a0b1..8acd12dce3 100644 --- a/src/mnode/src/mnodePeer.c +++ b/src/mnode/src/mnodePeer.c @@ -48,7 +48,7 @@ void mnodeAddPeerRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)) { int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg) { if (pMsg->pCont == NULL) { - mError("msg:%s content is null", taosMsg[pMsg->msgType]); + mError("%p, msg:%s in mpeer queue, content is null", pMsg->ahandle, taosMsg[pMsg->msgType]); return TSDB_CODE_INVALID_MSG_LEN; } @@ -59,7 +59,7 @@ int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg) { rpcRsp->rsp = ipSet; rpcRsp->len = sizeof(SRpcIpSet); - mTrace("msg:%s will be redireced, inUse:%d", taosMsg[pMsg->msgType], ipSet->inUse); + mTrace("%p, msg:%s in mpeer queue, will be redireced inUse:%d", pMsg->ahandle, taosMsg[pMsg->msgType], ipSet->inUse); for (int32_t i = 0; i < ipSet->numOfIps; ++i) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } @@ -68,7 +68,7 @@ int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg) { } if (tsMnodeProcessPeerMsgFp[pMsg->msgType] == NULL) { - mError("msg:%s not processed, no handle exist", taosMsg[pMsg->msgType]); + mError("%p, msg:%s in mpeer queue, not processed", pMsg->ahandle, taosMsg[pMsg->msgType]); return TSDB_CODE_MSG_NOT_PROCESSED; } diff --git a/src/mnode/src/mnodeRead.c b/src/mnode/src/mnodeRead.c index 32790af03f..172a27a52f 100644 --- a/src/mnode/src/mnodeRead.c +++ b/src/mnode/src/mnodeRead.c @@ -43,7 +43,7 @@ void mnodeAddReadMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *pMsg)) { int32_t mnodeProcessRead(SMnodeMsg *pMsg) { if (pMsg->pCont == NULL) { - mError("msg:%s content is null", taosMsg[pMsg->msgType]); + mError("%p, msg:%s in mread queue, content is null", pMsg->ahandle, taosMsg[pMsg->msgType]); return TSDB_CODE_INVALID_MSG_LEN; } @@ -54,7 +54,7 @@ int32_t mnodeProcessRead(SMnodeMsg *pMsg) { rpcRsp->rsp = ipSet; rpcRsp->len = sizeof(SRpcIpSet); - mTrace("msg:%s will be redireced, inUse:%d", taosMsg[pMsg->msgType], ipSet->inUse); + mTrace("%p, msg:%s in mread queue, will be redireced, inUse:%d", pMsg->ahandle, taosMsg[pMsg->msgType], ipSet->inUse); for (int32_t i = 0; i < ipSet->numOfIps; ++i) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } @@ -63,13 +63,14 @@ int32_t mnodeProcessRead(SMnodeMsg *pMsg) { } if (tsMnodeProcessReadMsgFp[pMsg->msgType] == NULL) { - mError("msg:%s not processed, no handle exist", taosMsg[pMsg->msgType]); + mError("%p, msg:%s in mread queue, not processed", pMsg->ahandle, taosMsg[pMsg->msgType]); return TSDB_CODE_MSG_NOT_PROCESSED; } - if (!mnodeInitMsg(pMsg)) { - mError("msg:%s not processed, reason:%s", taosMsg[pMsg->msgType], tstrerror(terrno)); - return terrno; + int32_t code = mnodeInitMsg(pMsg); + if (code != TSDB_CODE_SUCCESS) { + mError("%p, msg:%s in mread queue, not processed reason:%s", pMsg->ahandle, taosMsg[pMsg->msgType], tstrerror(code)); + return code; } return (*tsMnodeProcessReadMsgFp[pMsg->msgType])(pMsg); diff --git a/src/mnode/src/mnodeShow.c b/src/mnode/src/mnodeShow.c index 37bcd075a5..2a42ad869e 100644 --- a/src/mnode/src/mnodeShow.c +++ b/src/mnode/src/mnodeShow.c @@ -131,6 +131,9 @@ static int32_t mnodeProcessShowMsg(SMnodeMsg *pMsg) { memcpy(pShow->payload, pShowMsg->payload, pShow->payloadLen); pShow = mnodeSaveQhandle(pShow, showObjSize); + if (pShow == NULL) { + return TSDB_CODE_SERV_OUT_OF_MEMORY; + } pShowRsp->qhandle = htobe64((uint64_t) pShow); mTrace("show:%p, type:%s, start to get meta", pShow, mnodeGetShowType(pShowMsg->type)); diff --git a/src/mnode/src/mnodeWrite.c b/src/mnode/src/mnodeWrite.c index 33a5399fe2..1741d04fc6 100644 --- a/src/mnode/src/mnodeWrite.c +++ b/src/mnode/src/mnodeWrite.c @@ -42,7 +42,7 @@ void mnodeAddWriteMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg)) int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { if (pMsg->pCont == NULL) { - mError("msg:%s content is null", taosMsg[pMsg->msgType]); + mError("%p, msg:%s in mwrite queue, content is null", pMsg->ahandle, taosMsg[pMsg->msgType]); return TSDB_CODE_INVALID_MSG_LEN; } @@ -53,7 +53,7 @@ int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { rpcRsp->rsp = ipSet; rpcRsp->len = sizeof(SRpcIpSet); - mTrace("msg:%s will be redireced, inUse:%d", taosMsg[pMsg->msgType], ipSet->inUse); + mTrace("%p, msg:%s in mwrite queue, will be redireced inUse:%d", pMsg->ahandle, taosMsg[pMsg->msgType], ipSet->inUse); for (int32_t i = 0; i < ipSet->numOfIps; ++i) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } @@ -62,17 +62,18 @@ int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { } if (tsMnodeProcessWriteMsgFp[pMsg->msgType] == NULL) { - mError("msg:%s not processed, no handle exist", taosMsg[pMsg->msgType]); + mError("%p, msg:%s in mwrite queue, not processed", pMsg->ahandle, taosMsg[pMsg->msgType]); return TSDB_CODE_MSG_NOT_PROCESSED; } - if (!mnodeInitMsg(pMsg)) { - mError("msg:%s not processed, reason:%s", taosMsg[pMsg->msgType], tstrerror(terrno)); - return terrno; + int32_t code = mnodeInitMsg(pMsg); + if (code != TSDB_CODE_SUCCESS) { + mError("%p, msg:%s in mwrite queue, not processed reason:%s", pMsg->ahandle, taosMsg[pMsg->msgType], tstrerror(code)); + return code; } if (!pMsg->pUser->writeAuth) { - mError("%p, msg:%s not processed, no rights", taosMsg[pMsg->msgType]); + mError("%p, msg:%s in mwrite queue, not processed, no write auth", pMsg->ahandle, taosMsg[pMsg->msgType]); return TSDB_CODE_NO_RIGHTS; } From 5c889fff5481b9433ede1af2b05696d2e412612f Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 02:13:38 +0000 Subject: [PATCH 07/17] [TD-335] refact SMnodeMsg --- src/inc/mnode.h | 11 ++----- src/mnode/src/mnodeDb.c | 11 ++++--- src/mnode/src/mnodeDnode.c | 9 +++--- src/mnode/src/mnodeInt.c | 9 ++---- src/mnode/src/mnodePeer.c | 14 ++++----- src/mnode/src/mnodeRead.c | 15 +++++----- src/mnode/src/mnodeShow.c | 16 +++++----- src/mnode/src/mnodeTable.c | 59 ++++++++++++++++++------------------- src/mnode/src/mnodeUser.c | 8 ++--- src/mnode/src/mnodeVgroup.c | 12 ++++---- src/mnode/src/mnodeWrite.c | 17 ++++++----- 11 files changed, 87 insertions(+), 94 deletions(-) diff --git a/src/inc/mnode.h b/src/inc/mnode.h index da0a899f37..513e81a461 100644 --- a/src/inc/mnode.h +++ b/src/inc/mnode.h @@ -29,23 +29,18 @@ struct STableObj; struct SRpcMsg; typedef struct { - int len; - void *rsp; + int32_t len; + void * rsp; } SMnodeRsp; typedef struct SMnodeMsg { SMnodeRsp rpcRsp; - uint8_t msgType; int8_t received; int8_t successed; int8_t expected; int8_t retry; - int8_t maxRetry; - int32_t contLen; int32_t code; - void * ahandle; - void * thandle; - void * pCont; + struct SRpcMsg rpcMsg; struct SAcctObj * pAcct; struct SDnodeObj *pDnode; struct SUserObj * pUser; diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c index 09fd7f5b3e..1220988221 100644 --- a/src/mnode/src/mnodeDb.c +++ b/src/mnode/src/mnodeDb.c @@ -750,8 +750,7 @@ static int32_t mnodeSetDbDropping(SDbObj *pDb) { } static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg) { - SCMCreateDbMsg *pCreate = pMsg->pCont; - + SCMCreateDbMsg *pCreate = pMsg->rpcMsg.pCont; pCreate->maxTables = htonl(pCreate->maxTables); pCreate->cacheBlockSize = htonl(pCreate->cacheBlockSize); pCreate->totalBlocks = htonl(pCreate->totalBlocks); @@ -937,8 +936,8 @@ static int32_t mnodeAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) { } static int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg) { - SCMAlterDbMsg *pAlter = pMsg->pCont; - mTrace("db:%s, alter db msg is received from thandle:%p", pAlter->db, pMsg->thandle); + SCMAlterDbMsg *pAlter = pMsg->rpcMsg.pCont; + mTrace("db:%s, alter db msg is received from thandle:%p", pAlter->db, pMsg->rpcMsg.handle); if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pAlter->db); if (pMsg->pDb == NULL) { @@ -974,8 +973,8 @@ static int32_t mnodeDropDb(SMnodeMsg *pMsg) { } static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg) { - SCMDropDbMsg *pDrop = pMsg->pCont; - mTrace("db:%s, drop db msg is received from thandle:%p", pDrop->db, pMsg->thandle); + SCMDropDbMsg *pDrop = pMsg->rpcMsg.pCont; + mTrace("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) { diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c index 5872081d67..8ce710110e 100644 --- a/src/mnode/src/mnodeDnode.c +++ b/src/mnode/src/mnodeDnode.c @@ -15,6 +15,7 @@ #define _DEFAULT_SOURCE #include "os.h" +#include "trpc.h" #include "tgrant.h" #include "tbalance.h" #include "tglobal.h" @@ -240,7 +241,7 @@ void mnodeUpdateDnode(SDnodeObj *pDnode) { } static int32_t mnodeProcessCfgDnodeMsg(SMnodeMsg *pMsg) { - SCMCfgDnodeMsg *pCmCfgDnode = pMsg->pCont; + SCMCfgDnodeMsg *pCmCfgDnode = pMsg->rpcMsg.pCont; if (pCmCfgDnode->ep[0] == 0) { strcpy(pCmCfgDnode->ep, tsLocalEp); } else { @@ -275,7 +276,7 @@ static void mnodeProcessCfgDnodeMsgRsp(SRpcMsg *rpcMsg) { } static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg) { - SDMStatusMsg *pStatus = pMsg->pCont; + SDMStatusMsg *pStatus = pMsg->rpcMsg.pCont; pStatus->dnodeId = htonl(pStatus->dnodeId); pStatus->moduleStatus = htonl(pStatus->moduleStatus); pStatus->lastReboot = htonl(pStatus->lastReboot); @@ -442,7 +443,7 @@ static int32_t mnodeDropDnodeByEp(char *ep) { } static int32_t mnodeProcessCreateDnodeMsg(SMnodeMsg *pMsg) { - SCMCreateDnodeMsg *pCreate = pMsg->pCont; + SCMCreateDnodeMsg *pCreate = pMsg->rpcMsg.pCont; if (strcmp(pMsg->pUser->user, "root") != 0) { return TSDB_CODE_NO_RIGHTS; @@ -462,7 +463,7 @@ static int32_t mnodeProcessCreateDnodeMsg(SMnodeMsg *pMsg) { } static int32_t mnodeProcessDropDnodeMsg(SMnodeMsg *pMsg) { - SCMDropDnodeMsg *pDrop = pMsg->pCont; + SCMDropDnodeMsg *pDrop = pMsg->rpcMsg.pCont; if (strcmp(pMsg->pUser->user, "root") != 0) { return TSDB_CODE_NO_RIGHTS; diff --git a/src/mnode/src/mnodeInt.c b/src/mnode/src/mnodeInt.c index a701f1e1f4..1cb421bef7 100644 --- a/src/mnode/src/mnodeInt.c +++ b/src/mnode/src/mnodeInt.c @@ -35,14 +35,11 @@ #include "mnodeVgroup.h" void mnodeCreateMsg(SMnodeMsg *pMsg, SRpcMsg *rpcMsg) { - pMsg->thandle = rpcMsg->handle; - pMsg->msgType = rpcMsg->msgType; - pMsg->contLen = rpcMsg->contLen; - pMsg->pCont = rpcMsg->pCont; + pMsg->rpcMsg = *rpcMsg; } int32_t mnodeInitMsg(SMnodeMsg *pMsg) { - pMsg->pUser = mnodeGetUserFromConn(pMsg->thandle); + pMsg->pUser = mnodeGetUserFromConn(pMsg->rpcMsg.handle); if (pMsg->pUser == NULL) { return TSDB_CODE_INVALID_USER; } @@ -52,7 +49,7 @@ int32_t mnodeInitMsg(SMnodeMsg *pMsg) { void mnodeCleanupMsg(SMnodeMsg *pMsg) { if (pMsg != NULL) { - if (pMsg->pCont) rpcFreeCont(pMsg->pCont); + if (pMsg->rpcMsg.pCont) rpcFreeCont(pMsg->rpcMsg.pCont); if (pMsg->pUser) mnodeDecUserRef(pMsg->pUser); if (pMsg->pDb) mnodeDecDbRef(pMsg->pDb); if (pMsg->pVgroup) mnodeDecVgroupRef(pMsg->pVgroup); diff --git a/src/mnode/src/mnodePeer.c b/src/mnode/src/mnodePeer.c index 8acd12dce3..3594b60cf1 100644 --- a/src/mnode/src/mnodePeer.c +++ b/src/mnode/src/mnodePeer.c @@ -47,8 +47,8 @@ void mnodeAddPeerRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)) { } int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg) { - if (pMsg->pCont == NULL) { - mError("%p, msg:%s in mpeer queue, content is null", pMsg->ahandle, taosMsg[pMsg->msgType]); + if (pMsg->rpcMsg.pCont == NULL) { + mError("%p, msg:%s in mpeer queue, content is null", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); return TSDB_CODE_INVALID_MSG_LEN; } @@ -59,7 +59,7 @@ int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg) { rpcRsp->rsp = ipSet; rpcRsp->len = sizeof(SRpcIpSet); - mTrace("%p, msg:%s in mpeer queue, will be redireced inUse:%d", pMsg->ahandle, taosMsg[pMsg->msgType], ipSet->inUse); + mTrace("%p, msg:%s in mpeer queue, will be redireced inUse:%d", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], ipSet->inUse); for (int32_t i = 0; i < ipSet->numOfIps; ++i) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } @@ -67,18 +67,18 @@ int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg) { return TSDB_CODE_REDIRECT; } - if (tsMnodeProcessPeerMsgFp[pMsg->msgType] == NULL) { - mError("%p, msg:%s in mpeer queue, not processed", pMsg->ahandle, taosMsg[pMsg->msgType]); + if (tsMnodeProcessPeerMsgFp[pMsg->rpcMsg.msgType] == NULL) { + mError("%p, msg:%s in mpeer queue, not processed", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); return TSDB_CODE_MSG_NOT_PROCESSED; } - return (*tsMnodeProcessPeerMsgFp[pMsg->msgType])(pMsg); + return (*tsMnodeProcessPeerMsgFp[pMsg->rpcMsg.msgType])(pMsg); } void mnodeProcessPeerRsp(SRpcMsg *pMsg) { if (tsMnodeProcessPeerRspFp[pMsg->msgType]) { (*tsMnodeProcessPeerRspFp[pMsg->msgType])(pMsg); } else { - mError("msg:%s is not processed", pMsg->handle, taosMsg[pMsg->msgType]); + mError("%p, msg:%s is not processed", pMsg->ahandle, taosMsg[pMsg->msgType]); } } diff --git a/src/mnode/src/mnodeRead.c b/src/mnode/src/mnodeRead.c index 172a27a52f..cc58f89041 100644 --- a/src/mnode/src/mnodeRead.c +++ b/src/mnode/src/mnodeRead.c @@ -15,6 +15,7 @@ #define _DEFAULT_SOURCE #include "os.h" +#include "trpc.h" #include "taosdef.h" #include "tsched.h" #include "tbalance.h" @@ -42,8 +43,8 @@ void mnodeAddReadMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *pMsg)) { } int32_t mnodeProcessRead(SMnodeMsg *pMsg) { - if (pMsg->pCont == NULL) { - mError("%p, msg:%s in mread queue, content is null", pMsg->ahandle, taosMsg[pMsg->msgType]); + if (pMsg->rpcMsg.pCont == NULL) { + mError("%p, msg:%s in mread queue, content is null", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); return TSDB_CODE_INVALID_MSG_LEN; } @@ -54,7 +55,7 @@ int32_t mnodeProcessRead(SMnodeMsg *pMsg) { rpcRsp->rsp = ipSet; rpcRsp->len = sizeof(SRpcIpSet); - mTrace("%p, msg:%s in mread queue, will be redireced, inUse:%d", pMsg->ahandle, taosMsg[pMsg->msgType], ipSet->inUse); + mTrace("%p, msg:%s in mread queue, will be redireced, inUse:%d", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], ipSet->inUse); for (int32_t i = 0; i < ipSet->numOfIps; ++i) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } @@ -62,16 +63,16 @@ int32_t mnodeProcessRead(SMnodeMsg *pMsg) { return TSDB_CODE_REDIRECT; } - if (tsMnodeProcessReadMsgFp[pMsg->msgType] == NULL) { - mError("%p, msg:%s in mread queue, not processed", pMsg->ahandle, taosMsg[pMsg->msgType]); + if (tsMnodeProcessReadMsgFp[pMsg->rpcMsg.msgType] == NULL) { + mError("%p, msg:%s in mread queue, not processed", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); return TSDB_CODE_MSG_NOT_PROCESSED; } int32_t code = mnodeInitMsg(pMsg); if (code != TSDB_CODE_SUCCESS) { - mError("%p, msg:%s in mread queue, not processed reason:%s", pMsg->ahandle, taosMsg[pMsg->msgType], tstrerror(code)); + mError("%p, msg:%s in mread queue, not processed reason:%s", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], tstrerror(code)); return code; } - return (*tsMnodeProcessReadMsgFp[pMsg->msgType])(pMsg); + return (*tsMnodeProcessReadMsgFp[pMsg->rpcMsg.msgType])(pMsg); } diff --git a/src/mnode/src/mnodeShow.c b/src/mnode/src/mnodeShow.c index 2a42ad869e..c29c3dab68 100644 --- a/src/mnode/src/mnodeShow.c +++ b/src/mnode/src/mnodeShow.c @@ -106,7 +106,7 @@ static char *mnodeGetShowType(int32_t showType) { } static int32_t mnodeProcessShowMsg(SMnodeMsg *pMsg) { - SCMShowMsg *pShowMsg = pMsg->pCont; + SCMShowMsg *pShowMsg = pMsg->rpcMsg.pCont; if (pShowMsg->type >= TSDB_MGMT_TABLE_MAX) { return TSDB_CODE_INVALID_MSG_TYPE; } @@ -137,7 +137,7 @@ static int32_t mnodeProcessShowMsg(SMnodeMsg *pMsg) { pShowRsp->qhandle = htobe64((uint64_t) pShow); mTrace("show:%p, type:%s, start to get meta", pShow, mnodeGetShowType(pShowMsg->type)); - int32_t code = (*tsMnodeShowMetaFp[pShowMsg->type])(&pShowRsp->tableMeta, pShow, pMsg->thandle); + int32_t code = (*tsMnodeShowMetaFp[pShowMsg->type])(&pShowRsp->tableMeta, pShow, pMsg->rpcMsg.handle); if (code == 0) { pMsg->rpcRsp.rsp = pShowRsp; pMsg->rpcRsp.len = sizeof(SCMShowRsp) + sizeof(SSchema) * pShow->numOfColumns; @@ -153,7 +153,7 @@ static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { int32_t rowsToRead = 0; int32_t size = 0; int32_t rowsRead = 0; - SRetrieveTableMsg *pRetrieve = pMsg->pCont; + SRetrieveTableMsg *pRetrieve = pMsg->rpcMsg.pCont; pRetrieve->qhandle = htobe64(pRetrieve->qhandle); /* @@ -187,7 +187,7 @@ static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { // 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->thandle); + rowsRead = (*tsMnodeShowRetrieveFp[pShow->type])(pShow, pRsp->data, rowsToRead, pMsg->rpcMsg.handle); if (rowsRead < 0) { rpcFreeCont(pRsp); @@ -236,12 +236,12 @@ static int32_t mnodeProcessHeartBeatMsg(SMnodeMsg *pMsg) { } static int32_t mnodeProcessConnectMsg(SMnodeMsg *pMsg) { - SCMConnectMsg *pConnectMsg = pMsg->pCont; + SCMConnectMsg *pConnectMsg = pMsg->rpcMsg.pCont; int32_t code = TSDB_CODE_SUCCESS; SRpcConnInfo connInfo; - if (rpcGetConnInfo(pMsg->thandle, &connInfo) != 0) { - mError("thandle:%p is already released while process connect msg", pMsg->thandle); + if (rpcGetConnInfo(pMsg->rpcMsg.handle, &connInfo) != 0) { + mError("thandle:%p is already released while process connect msg", pMsg->rpcMsg.handle); code = TSDB_CODE_INVALID_MSG_CONTENT; goto connect_over; } @@ -291,7 +291,7 @@ connect_over: } static int32_t mnodeProcessUseMsg(SMnodeMsg *pMsg) { - SCMUseDbMsg *pUseDbMsg = pMsg->pCont; + SCMUseDbMsg *pUseDbMsg = pMsg->rpcMsg.pCont; int32_t code = TSDB_CODE_SUCCESS; if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pUseDbMsg->db); diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c index 9399c29be8..7eb6320763 100644 --- a/src/mnode/src/mnodeTable.c +++ b/src/mnode/src/mnodeTable.c @@ -660,7 +660,7 @@ static void mgmtExtractTableName(char* tableId, char* name) { } static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) { - SCMCreateTableMsg *pCreate = pMsg->pCont; + SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont; if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pCreate->db); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { @@ -683,16 +683,16 @@ static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) { } if (pCreate->numOfTags != 0) { - mTrace("table:%s, create msg is received from thandle:%p", pCreate->tableId, pMsg->thandle); + mTrace("table:%s, create msg is received from thandle:%p", pCreate->tableId, pMsg->rpcMsg.handle); return mnodeProcessCreateSuperTableMsg(pMsg); } else { - mTrace("table:%s, create msg is received from thandle:%p", pCreate->tableId, pMsg->thandle); + mTrace("table:%s, create msg is received from thandle:%p", pCreate->tableId, pMsg->rpcMsg.handle); return mnodeProcessCreateChildTableMsg(pMsg); } } static int32_t mnodeProcessDropTableMsg(SMnodeMsg *pMsg) { - SCMDropTableMsg *pDrop = pMsg->pCont; + SCMDropTableMsg *pDrop = pMsg->rpcMsg.pCont; if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableId(pDrop->tableId); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { mError("table:%s, failed to drop table, db not selected", pDrop->tableId); @@ -725,9 +725,9 @@ static int32_t mnodeProcessDropTableMsg(SMnodeMsg *pMsg) { } static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *pMsg) { - SCMTableInfoMsg *pInfo = pMsg->pCont; + SCMTableInfoMsg *pInfo = pMsg->rpcMsg.pCont; pInfo->createFlag = htons(pInfo->createFlag); - mTrace("table:%s, table meta msg is received from thandle:%p, createFlag:%d", pInfo->tableId, pMsg->thandle, pInfo->createFlag); + mTrace("table:%s, table meta msg is received from thandle:%p, createFlag:%d", pInfo->tableId, pMsg->rpcMsg.handle, pInfo->createFlag); if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableId(pInfo->tableId); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { @@ -753,7 +753,7 @@ static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *pMsg) { } static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) { - SCMCreateTableMsg *pCreate = pMsg->pCont; + SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont; SSuperTableObj *pStable = calloc(1, sizeof(SSuperTableObj)); if (pStable == NULL) { mError("table:%s, failed to create, no enough memory", pCreate->tableId); @@ -1257,7 +1257,7 @@ static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) { } static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) { - SCMSTableVgroupMsg *pInfo = pMsg->pCont; + SCMSTableVgroupMsg *pInfo = pMsg->rpcMsg.pCont; int32_t numOfTable = htonl(pInfo->numOfTables); // reserve space @@ -1479,7 +1479,7 @@ static SChildTableObj* mnodeDoCreateChildTable(SCMCreateTableMsg *pCreate, SVgOb } static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) { - SCMCreateTableMsg *pCreate = pMsg->pCont; + SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont; int32_t code = grantCheck(TSDB_GRANT_TIMESERIES); if (code != TSDB_CODE_SUCCESS) { mError("table:%s, failed to create, grant timeseries failed", pCreate->tableId); @@ -1521,8 +1521,6 @@ static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) { } SRpcIpSet ipSet = mnodeGetIpSetFromVgroup(pVgroup); - pMsg->ahandle = pMsg->pTable; - pMsg->maxRetry = 10; SRpcMsg rpcMsg = { .handle = pMsg, .pCont = pMDCreate, @@ -1559,7 +1557,6 @@ static int32_t mnodeProcessDropChildTableMsg(SMnodeMsg *pMsg) { SRpcIpSet ipSet = mnodeGetIpSetFromVgroup(pMsg->pVgroup); mPrint("table:%s, send drop ctable msg", pDrop->tableId); - pMsg->ahandle = pMsg->pTable; SRpcMsg rpcMsg = { .handle = pMsg, .pCont = pDrop, @@ -1726,7 +1723,7 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) { } static int32_t mgmtAutoCreateChildTable(SMnodeMsg *pMsg) { - SCMTableInfoMsg *pInfo = pMsg->pCont; + SCMTableInfoMsg *pInfo = pMsg->rpcMsg.pCont; STagData* pTag = (STagData*)pInfo->tags; int32_t contLen = sizeof(SCMCreateTableMsg) + offsetof(STagData, data) + ntohl(pTag->dataLen); @@ -1744,10 +1741,10 @@ static int32_t mgmtAutoCreateChildTable(SMnodeMsg *pMsg) { memcpy(pCreateMsg->schema, pInfo->tags, contLen - sizeof(SCMCreateTableMsg)); - pMsg->msgType = TSDB_MSG_TYPE_CM_CREATE_TABLE; - rpcFreeCont(pMsg->pCont); - pMsg->pCont = pCreateMsg; - pMsg->contLen = contLen; + rpcFreeCont(pMsg->rpcMsg.pCont); + pMsg->rpcMsg.msgType = TSDB_MSG_TYPE_CM_CREATE_TABLE; + pMsg->rpcMsg.pCont = pCreateMsg; + pMsg->rpcMsg.contLen = contLen; mTrace("table:%s, start to create on demand, stable:%s", pInfo->tableId, pInfo->tags); @@ -1868,7 +1865,7 @@ static SChildTableObj* mnodeGetTableByPos(int32_t vnode, int32_t sid) { } static int32_t mnodeProcessTableCfgMsg(SMnodeMsg *pMsg) { - SDMConfigTableMsg *pCfg = (SDMConfigTableMsg *) pMsg->pCont; + SDMConfigTableMsg *pCfg = pMsg->rpcMsg.pCont; pCfg->dnode = htonl(pCfg->dnode); pCfg->vnode = htonl(pCfg->vnode); pCfg->sid = htonl(pCfg->sid); @@ -1911,8 +1908,9 @@ static void mnodeProcessDropChildTableRsp(SRpcMsg *rpcMsg) { SMnodeMsg *mnodeMsg = rpcMsg->handle; mnodeMsg->received++; - SChildTableObj *pTable = mnodeMsg->ahandle; - mPrint("table:%s, drop table rsp received, thandle:%p result:%s", pTable->info.tableId, mnodeMsg->thandle, tstrerror(rpcMsg->code)); + SChildTableObj *pTable = (SChildTableObj *)mnodeMsg->pTable; + assert(pTable); + mPrint("table:%s, drop table rsp received, thandle:%p result:%s", pTable->info.tableId, mnodeMsg->rpcMsg.handle, tstrerror(rpcMsg->code)); if (rpcMsg->code != TSDB_CODE_SUCCESS) { mError("table:%s, failed to drop in dnode, reason:%s", pTable->info.tableId, tstrerror(rpcMsg->code)); @@ -1957,18 +1955,19 @@ static void mnodeProcessCreateChildTableRsp(SRpcMsg *rpcMsg) { SMnodeMsg *mnodeMsg = rpcMsg->handle; mnodeMsg->received++; - SChildTableObj *pTable = mnodeMsg->ahandle; - mTrace("table:%s, create table rsp received, thandle:%p result:%s", pTable->info.tableId, mnodeMsg->thandle, + SChildTableObj *pTable = (SChildTableObj *)mnodeMsg->pTable; + assert(pTable); + mTrace("table:%s, create table rsp received, thandle:%p result:%s", pTable->info.tableId, mnodeMsg->rpcMsg.handle, tstrerror(rpcMsg->code)); if (rpcMsg->code != TSDB_CODE_SUCCESS) { - if (mnodeMsg->retry++ < mnodeMsg->maxRetry) { + if (mnodeMsg->retry++ < 10) { mTrace("table:%s, create table rsp received, retry:%d thandle:%p result:%s", pTable->info.tableId, - mnodeMsg->retry, mnodeMsg->thandle, tstrerror(rpcMsg->code)); + mnodeMsg->retry, mnodeMsg->rpcMsg.handle, tstrerror(rpcMsg->code)); dnodeDelayReprocessMnodeWriteMsg(mnodeMsg); } else { mError("table:%s, failed to create in dnode, thandle:%p result:%s", pTable->info.tableId, - mnodeMsg->thandle, tstrerror(rpcMsg->code)); + mnodeMsg->rpcMsg.handle, tstrerror(rpcMsg->code)); SSdbOper oper = { .type = SDB_OPER_GLOBAL, @@ -1980,9 +1979,9 @@ static void mnodeProcessCreateChildTableRsp(SRpcMsg *rpcMsg) { dnodeSendRpcMnodeWriteRsp(mnodeMsg, rpcMsg->code); } } else { - mTrace("table:%s, created in dnode, thandle:%p result:%s", pTable->info.tableId, mnodeMsg->thandle, + mTrace("table:%s, created in dnode, thandle:%p result:%s", pTable->info.tableId, mnodeMsg->rpcMsg.handle, tstrerror(rpcMsg->code)); - SCMCreateTableMsg *pCreate = mnodeMsg->pCont; + SCMCreateTableMsg *pCreate = mnodeMsg->rpcMsg.pCont; if (pCreate->getMeta) { mTrace("table:%s, continue to get meta", pTable->info.tableId); mnodeMsg->retry = 0; @@ -1999,7 +1998,7 @@ static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg) { } static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) { - SCMMultiTableInfoMsg *pInfo = pMsg->pCont; + SCMMultiTableInfoMsg *pInfo = pMsg->rpcMsg.pCont; pInfo->numOfTables = htonl(pInfo->numOfTables); int32_t totalMallocLen = 4 * 1024 * 1024; // first malloc 4 MB, subsequent reallocation as twice @@ -2183,8 +2182,8 @@ static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows } static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg) { - SCMAlterTableMsg *pAlter = pMsg->pCont; - mTrace("table:%s, alter table msg is received from thandle:%p", pAlter->tableId, pMsg->thandle); + SCMAlterTableMsg *pAlter = pMsg->rpcMsg.pCont; + mTrace("table:%s, alter table msg is received from thandle:%p", pAlter->tableId, pMsg->rpcMsg.handle); if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableId(pAlter->tableId); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { diff --git a/src/mnode/src/mnodeUser.c b/src/mnode/src/mnodeUser.c index ad6370302a..a1edaaa0a8 100644 --- a/src/mnode/src/mnodeUser.c +++ b/src/mnode/src/mnodeUser.c @@ -352,7 +352,7 @@ static int32_t mnodeProcessCreateUserMsg(SMnodeMsg *pMsg) { SUserObj *pOperUser = pMsg->pUser; if (pOperUser->superAuth) { - SCMCreateUserMsg *pCreate = pMsg->pCont; + SCMCreateUserMsg *pCreate = pMsg->rpcMsg.pCont; code = mnodeCreateUser(pOperUser->pAcct, pCreate->user, pCreate->pass); if (code == TSDB_CODE_SUCCESS) { mLPrint("user:%s, is created by %s", pCreate->user, pOperUser->user); @@ -369,7 +369,7 @@ static int32_t mnodeProcessAlterUserMsg(SMnodeMsg *pMsg) { int32_t code; SUserObj *pOperUser = pMsg->pUser; - SCMAlterUserMsg *pAlter = pMsg->pCont; + SCMAlterUserMsg *pAlter = pMsg->rpcMsg.pCont; SUserObj *pUser = mnodeGetUser(pAlter->user); if (pUser == NULL) { return TSDB_CODE_INVALID_USER; @@ -459,7 +459,7 @@ static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg) { int32_t code; SUserObj *pOperUser = pMsg->pUser; - SCMDropUserMsg *pDrop = pMsg->pCont; + SCMDropUserMsg *pDrop = pMsg->rpcMsg.pCont; SUserObj *pUser = mnodeGetUser(pDrop->user); if (pUser == NULL) { return TSDB_CODE_INVALID_USER; @@ -552,7 +552,7 @@ int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, cha } static int32_t mnodeProcessAuthMsg(SMnodeMsg *pMsg) { - SDMAuthMsg *pAuthMsg = pMsg->pCont; + SDMAuthMsg *pAuthMsg = pMsg->rpcMsg.pCont; SDMAuthRsp *pAuthRsp = rpcMallocCont(sizeof(SDMAuthRsp)); pMsg->rpcRsp.rsp = pAuthRsp; diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c index 69baa09c95..0d235f898d 100644 --- a/src/mnode/src/mnodeVgroup.c +++ b/src/mnode/src/mnodeVgroup.c @@ -331,7 +331,7 @@ int32_t mnodeCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { mPrint("vgId:%d, index:%d, dnode:%d", pVgroup->vgId, i, pVgroup->vnodeGid[i].dnodeId); } - pMsg->ahandle = pVgroup; + pMsg->pVgroup = pVgroup; pMsg->expected = pVgroup->numOfVnodes; mnodeSendCreateVgroupMsg(pVgroup, pMsg); @@ -626,10 +626,10 @@ static void mnodeProcessCreateVnodeRsp(SRpcMsg *rpcMsg) { mnodeMsg->successed++; } - SVgObj *pVgroup = mnodeMsg->ahandle; + SVgObj *pVgroup = mnodeMsg->pVgroup; mTrace("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->thandle, rpcMsg->handle); + mnodeMsg->rpcMsg.handle, rpcMsg->handle); if (mnodeMsg->received != mnodeMsg->expected) return; @@ -690,10 +690,10 @@ static void mnodeProcessDropVnodeRsp(SRpcMsg *rpcMsg) { mnodeMsg->successed++; } - SVgObj *pVgroup = mnodeMsg->ahandle; + SVgObj *pVgroup = mnodeMsg->pVgroup; mTrace("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->thandle, rpcMsg->handle); + mnodeMsg->rpcMsg.handle, rpcMsg->handle); if (mnodeMsg->received != mnodeMsg->expected) return; @@ -711,7 +711,7 @@ static void mnodeProcessDropVnodeRsp(SRpcMsg *rpcMsg) { } static int32_t mnodeProcessVnodeCfgMsg(SMnodeMsg *pMsg) { - SDMConfigVnodeMsg *pCfg = (SDMConfigVnodeMsg *) pMsg->pCont; + SDMConfigVnodeMsg *pCfg = pMsg->rpcMsg.pCont; pCfg->dnodeId = htonl(pCfg->dnodeId); pCfg->vgId = htonl(pCfg->vgId); diff --git a/src/mnode/src/mnodeWrite.c b/src/mnode/src/mnodeWrite.c index 1741d04fc6..8b3d82d32a 100644 --- a/src/mnode/src/mnodeWrite.c +++ b/src/mnode/src/mnodeWrite.c @@ -20,6 +20,7 @@ #include "tbalance.h" #include "tgrant.h" #include "tglobal.h" +#include "trpc.h" #include "mnode.h" #include "dnode.h" #include "mnodeDef.h" @@ -41,8 +42,8 @@ void mnodeAddWriteMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg)) } int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { - if (pMsg->pCont == NULL) { - mError("%p, msg:%s in mwrite queue, content is null", pMsg->ahandle, taosMsg[pMsg->msgType]); + if (pMsg->rpcMsg.pCont == NULL) { + mError("%p, msg:%s in mwrite queue, content is null", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); return TSDB_CODE_INVALID_MSG_LEN; } @@ -53,7 +54,7 @@ int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { rpcRsp->rsp = ipSet; rpcRsp->len = sizeof(SRpcIpSet); - mTrace("%p, msg:%s in mwrite queue, will be redireced inUse:%d", pMsg->ahandle, taosMsg[pMsg->msgType], ipSet->inUse); + mTrace("%p, msg:%s in mwrite queue, will be redireced inUse:%d", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], ipSet->inUse); for (int32_t i = 0; i < ipSet->numOfIps; ++i) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } @@ -61,21 +62,21 @@ int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { return TSDB_CODE_REDIRECT; } - if (tsMnodeProcessWriteMsgFp[pMsg->msgType] == NULL) { - mError("%p, msg:%s in mwrite queue, not processed", pMsg->ahandle, taosMsg[pMsg->msgType]); + if (tsMnodeProcessWriteMsgFp[pMsg->rpcMsg.msgType] == NULL) { + mError("%p, msg:%s in mwrite queue, not processed", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); return TSDB_CODE_MSG_NOT_PROCESSED; } int32_t code = mnodeInitMsg(pMsg); if (code != TSDB_CODE_SUCCESS) { - mError("%p, msg:%s in mwrite queue, not processed reason:%s", pMsg->ahandle, taosMsg[pMsg->msgType], tstrerror(code)); + mError("%p, msg:%s in mwrite queue, not processed reason:%s", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType], tstrerror(code)); return code; } if (!pMsg->pUser->writeAuth) { - mError("%p, msg:%s in mwrite queue, not processed, no write auth", pMsg->ahandle, taosMsg[pMsg->msgType]); + mError("%p, msg:%s in mwrite queue, not processed, no write auth", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); return TSDB_CODE_NO_RIGHTS; } - return (*tsMnodeProcessWriteMsgFp[pMsg->msgType])(pMsg); + return (*tsMnodeProcessWriteMsgFp[pMsg->rpcMsg.msgType])(pMsg); } From a6c3ffd5403e3658af3af802ce685ac2519ddbdb Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 03:40:02 +0000 Subject: [PATCH 08/17] [TD-335] fix invalid read in mwrite queue --- src/dnode/inc/dnodeMgmt.h | 2 +- src/dnode/src/dnodeMPeer.c | 14 +++++++++----- src/dnode/src/dnodeMRead.c | 16 ++++++++++------ src/dnode/src/dnodeMWrite.c | 24 +++++++++++------------- src/dnode/src/dnodeMgmt.c | 8 ++++---- 5 files changed, 35 insertions(+), 29 deletions(-) diff --git a/src/dnode/inc/dnodeMgmt.h b/src/dnode/inc/dnodeMgmt.h index 28844ba0e5..1a788610e5 100644 --- a/src/dnode/inc/dnodeMgmt.h +++ b/src/dnode/inc/dnodeMgmt.h @@ -32,7 +32,7 @@ void* dnodeGetVnodeWal(void *pVnode); void* dnodeGetVnodeTsdb(void *pVnode); void dnodeReleaseVnode(void *pVnode); -void dnodeSendRedirectMsg(int32_t msgType, void *thandle, bool forShell); +void dnodeSendRedirectMsg(SRpcMsg *rpcMsg, bool forShell); void dnodeGetMnodeIpSetForPeer(void *ipSet); void dnodeGetMnodeIpSetForShell(void *ipSe); diff --git a/src/dnode/src/dnodeMPeer.c b/src/dnode/src/dnodeMPeer.c index dec4f5ef59..46e7a0a7e2 100644 --- a/src/dnode/src/dnodeMPeer.c +++ b/src/dnode/src/dnodeMPeer.c @@ -111,7 +111,7 @@ void dnodeFreeMnodePqueue() { void dnodeDispatchToMnodePeerQueue(SRpcMsg *pMsg) { if (!mnodeIsRunning() || tsMPeerQueue == NULL) { - dnodeSendRedirectMsg(pMsg->msgType, pMsg->handle, false); + dnodeSendRedirectMsg(pMsg, false); return; } @@ -120,18 +120,23 @@ void dnodeDispatchToMnodePeerQueue(SRpcMsg *pMsg) { taosWriteQitem(tsMPeerQueue, TAOS_QTYPE_RPC, pPeer); } +static void dnodeFreeMnodePeadMsg(SMnodeMsg *pPeer) { + mnodeCleanupMsg(pPeer); + taosFreeQitem(pPeer); +} + static void dnodeSendRpcMnodePeerRsp(SMnodeMsg *pPeer, int32_t code) { if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; SRpcMsg rpcRsp = { - .handle = pPeer->thandle, + .handle = pPeer->rpcMsg.handle, .pCont = pPeer->rpcRsp.rsp, .contLen = pPeer->rpcRsp.len, .code = code, }; rpcSendResponse(&rpcRsp); - mnodeCleanupMsg(pPeer); + dnodeFreeMnodePeadMsg(pPeer); } static void *dnodeProcessMnodePeerQueue(void *param) { @@ -145,10 +150,9 @@ static void *dnodeProcessMnodePeerQueue(void *param) { break; } - dTrace("%p, msg:%s will be processed in mpeer queue", pPeerMsg->ahandle, taosMsg[pPeerMsg->msgType]); + dTrace("%p, msg:%s will be processed in mpeer queue", pPeerMsg->rpcMsg.ahandle, taosMsg[pPeerMsg->rpcMsg.msgType]); int32_t code = mnodeProcessPeerReq(pPeerMsg); dnodeSendRpcMnodePeerRsp(pPeerMsg, code); - taosFreeQitem(pPeerMsg); } return NULL; diff --git a/src/dnode/src/dnodeMRead.c b/src/dnode/src/dnodeMRead.c index 2ab5f48a9a..9a977ffe83 100644 --- a/src/dnode/src/dnodeMRead.c +++ b/src/dnode/src/dnodeMRead.c @@ -116,7 +116,7 @@ void dnodeFreeMnodeRqueue() { void dnodeDispatchToMnodeReadQueue(SRpcMsg *pMsg) { if (!mnodeIsRunning() || tsMReadQueue == NULL) { - dnodeSendRedirectMsg(pMsg->msgType, pMsg->handle, true); + dnodeSendRedirectMsg(pMsg, true); return; } @@ -125,18 +125,23 @@ void dnodeDispatchToMnodeReadQueue(SRpcMsg *pMsg) { taosWriteQitem(tsMReadQueue, TAOS_QTYPE_RPC, pRead); } +static void dnodeFreeMnodeReadMsg(SMnodeMsg *pRead) { + mnodeCleanupMsg(pRead); + taosFreeQitem(pRead); +} + static void dnodeSendRpcMnodeReadRsp(SMnodeMsg *pRead, int32_t code) { if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; SRpcMsg rpcRsp = { - .handle = pRead->thandle, + .handle = pRead->rpcMsg.handle, .pCont = pRead->rpcRsp.rsp, .contLen = pRead->rpcRsp.len, .code = code, }; rpcSendResponse(&rpcRsp); - mnodeCleanupMsg(pRead); + dnodeFreeMnodeReadMsg(pRead); } static void *dnodeProcessMnodeReadQueue(void *param) { @@ -150,10 +155,9 @@ static void *dnodeProcessMnodeReadQueue(void *param) { break; } - dTrace("%p, msg:%s will be processed in mread queue", pReadMsg->ahandle, taosMsg[pReadMsg->msgType]); + dTrace("%p, msg:%s will be processed in mread queue", pReadMsg->rpcMsg.ahandle, taosMsg[pReadMsg->rpcMsg.msgType]); int32_t code = mnodeProcessRead(pReadMsg); - dnodeSendRpcMnodeReadRsp(pReadMsg, code); - taosFreeQitem(pReadMsg); + dnodeSendRpcMnodeReadRsp(pReadMsg, code); } return NULL; diff --git a/src/dnode/src/dnodeMWrite.c b/src/dnode/src/dnodeMWrite.c index 89c44d829b..b54d295d05 100644 --- a/src/dnode/src/dnodeMWrite.c +++ b/src/dnode/src/dnodeMWrite.c @@ -113,7 +113,7 @@ void dnodeFreeMnodeWqueue() { void dnodeDispatchToMnodeWriteQueue(SRpcMsg *pMsg) { if (!mnodeIsRunning() || tsMWriteQueue == NULL) { - dnodeSendRedirectMsg(pMsg->msgType, pMsg->handle, true); + dnodeSendRedirectMsg(pMsg, true); return; } @@ -122,19 +122,24 @@ void dnodeDispatchToMnodeWriteQueue(SRpcMsg *pMsg) { taosWriteQitem(tsMWriteQueue, TAOS_QTYPE_RPC, pWrite); } +static void dnodeFreeMnodeWriteMsg(SMnodeMsg *pWrite) { + mnodeCleanupMsg(pWrite); + taosFreeQitem(pWrite); +} + void dnodeSendRpcMnodeWriteRsp(void *pRaw, int32_t code) { SMnodeMsg *pWrite = pRaw; if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; SRpcMsg rpcRsp = { - .handle = pWrite->thandle, + .handle = pWrite->rpcMsg.handle, .pCont = pWrite->rpcRsp.rsp, .contLen = pWrite->rpcRsp.len, .code = code, }; rpcSendResponse(&rpcRsp); - mnodeCleanupMsg(pWrite); + dnodeFreeMnodeWriteMsg(pWrite); } static void *dnodeProcessMnodeWriteQueue(void *param) { @@ -148,26 +153,19 @@ static void *dnodeProcessMnodeWriteQueue(void *param) { break; } - dTrace("%p, msg:%s will be processed in mwrite queue", pWriteMsg->ahandle, taosMsg[pWriteMsg->msgType]); + dTrace("%p, msg:%s will be processed in mwrite queue", pWriteMsg->rpcMsg.ahandle, taosMsg[pWriteMsg->rpcMsg.msgType]); int32_t code = mnodeProcessWrite(pWriteMsg); - dnodeSendRpcMnodeWriteRsp(pWriteMsg, code); - taosFreeQitem(pWriteMsg); + dnodeSendRpcMnodeWriteRsp(pWriteMsg, code); } return NULL; } -static void dnodeFreeMnodeWriteMsg(void *pMsg) { - SMnodeMsg *pWrite = pMsg; - mnodeCleanupMsg(pWrite); - taosFreeQitem(pWrite); -} - void dnodeReprocessMnodeWriteMsg(void *pMsg) { SMnodeMsg *pWrite = pMsg; if (!mnodeIsRunning() || tsMWriteQueue == NULL) { - dnodeSendRedirectMsg(pWrite->msgType, pWrite->thandle, true); + dnodeSendRedirectMsg(pMsg, true); dnodeFreeMnodeWriteMsg(pWrite); } else { taosWriteQitem(tsMWriteQueue, TAOS_QTYPE_RPC, pWrite); diff --git a/src/dnode/src/dnodeMgmt.c b/src/dnode/src/dnodeMgmt.c index ec7ff4c66c..31e73eafbc 100644 --- a/src/dnode/src/dnodeMgmt.c +++ b/src/dnode/src/dnodeMgmt.c @@ -609,9 +609,9 @@ int32_t dnodeGetDnodeId() { return tsDnodeCfg.dnodeId; } -void dnodeSendRedirectMsg(int32_t msgType, void *thandle, bool forShell) { +void dnodeSendRedirectMsg(SRpcMsg *rpcMsg, bool forShell) { SRpcConnInfo connInfo; - rpcGetConnInfo(thandle, &connInfo); + rpcGetConnInfo(rpcMsg->handle, &connInfo); SRpcIpSet ipSet = {0}; if (forShell) { @@ -620,7 +620,7 @@ void dnodeSendRedirectMsg(int32_t msgType, void *thandle, bool forShell) { dnodeGetMnodeIpSetForPeer(&ipSet); } - dTrace("msg:%s will be redirected, dnodeIp:%s user:%s, numOfIps:%d inUse:%d", taosMsg[msgType], + dTrace("msg:%s will be redirected, dnodeIp:%s user:%s, numOfIps:%d inUse:%d", taosMsg[rpcMsg->msgType], taosIpStr(connInfo.clientIp), connInfo.user, ipSet.numOfIps, ipSet.inUse); for (int i = 0; i < ipSet.numOfIps; ++i) { @@ -628,5 +628,5 @@ void dnodeSendRedirectMsg(int32_t msgType, void *thandle, bool forShell) { ipSet.port[i] = htons(ipSet.port[i]); } - rpcSendRedirectRsp(thandle, &ipSet); + rpcSendRedirectRsp(rpcMsg->handle, &ipSet); } From 09b68c4a14ece6b3c6bff626b7f932d353078a4d Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 03:50:46 +0000 Subject: [PATCH 09/17] [TD-335] fix refcount error --- src/mnode/src/mnodeVgroup.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c index 0d235f898d..97c3f69719 100644 --- a/src/mnode/src/mnodeVgroup.c +++ b/src/mnode/src/mnodeVgroup.c @@ -331,6 +331,7 @@ int32_t mnodeCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { mPrint("vgId:%d, index:%d, dnode:%d", pVgroup->vgId, i, pVgroup->vnodeGid[i].dnodeId); } + mnodeIncVgroupRef(pVgroup); pMsg->pVgroup = pVgroup; pMsg->expected = pVgroup->numOfVnodes; mnodeSendCreateVgroupMsg(pVgroup, pMsg); From 30e867daa69784c3f311ef76c9aff2ba327044db Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 05:26:21 +0000 Subject: [PATCH 10/17] [TD-335] remove log --- src/mnode/src/mnodeDnode.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c index 8ce710110e..827fef9ed6 100644 --- a/src/mnode/src/mnodeDnode.c +++ b/src/mnode/src/mnodeDnode.c @@ -315,7 +315,7 @@ static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg) { if (pStatus->dnodeId == 0) { mTrace("dnode:%d %s, first access", pDnode->dnodeId, pDnode->dnodeEp); } else { - mTrace("dnode:%d, status received, access times %d", pDnode->dnodeId, pDnode->lastAccess); + //mTrace("dnode:%d, status received, access times %d", pDnode->dnodeId, pDnode->lastAccess); } int32_t openVnodes = htons(pStatus->openVnodes); From 780e3e1bb9e5bb5260f1975be98385d811d274dd Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 06:01:27 +0000 Subject: [PATCH 11/17] [TD-335] fix bug while auto create table --- src/dnode/src/dnodeMPeer.c | 10 +++++----- src/dnode/src/dnodeMRead.c | 5 +++++ src/dnode/src/dnodeMWrite.c | 4 ++++ src/mnode/src/mnodeTable.c | 1 + src/mnode/src/mnodeVgroup.c | 5 +---- 5 files changed, 16 insertions(+), 9 deletions(-) diff --git a/src/dnode/src/dnodeMPeer.c b/src/dnode/src/dnodeMPeer.c index 46e7a0a7e2..f5b0fe26f2 100644 --- a/src/dnode/src/dnodeMPeer.c +++ b/src/dnode/src/dnodeMPeer.c @@ -75,7 +75,7 @@ void dnodeCleanupMnodePeer() { } } - dPrint("dnode mmgmt is closed"); + dPrint("dnode mpeer is closed"); } int32_t dnodeAllocateMnodePqueue() { @@ -93,14 +93,14 @@ int32_t dnodeAllocateMnodePqueue() { pthread_attr_setdetachstate(&thAttr, PTHREAD_CREATE_JOINABLE); if (pthread_create(&pWorker->thread, &thAttr, dnodeProcessMnodePeerQueue, pWorker) != 0) { - dError("failed to create thread to process mmgmt queue, reason:%s", strerror(errno)); + dError("failed to create thread to process mpeer queue, reason:%s", strerror(errno)); } pthread_attr_destroy(&thAttr); - dTrace("dnode mmgmt worker:%d is launched, total:%d", pWorker->workerId, tsMPeerPool.num); + dTrace("dnode mpeer worker:%d is launched, total:%d", pWorker->workerId, tsMPeerPool.num); } - dTrace("dnode mmgmt queue:%p is allocated", tsMPeerQueue); + dTrace("dnode mpeer queue:%p is allocated", tsMPeerQueue); return TSDB_CODE_SUCCESS; } @@ -150,7 +150,7 @@ static void *dnodeProcessMnodePeerQueue(void *param) { break; } - dTrace("%p, msg:%s will be processed in mpeer queue", pPeerMsg->rpcMsg.ahandle, taosMsg[pPeerMsg->rpcMsg.msgType]); + dTrace("msg:%s will be processed in mpeer queue", taosMsg[pPeerMsg->rpcMsg.msgType]); int32_t code = mnodeProcessPeerReq(pPeerMsg); dnodeSendRpcMnodePeerRsp(pPeerMsg, code); } diff --git a/src/dnode/src/dnodeMRead.c b/src/dnode/src/dnodeMRead.c index 9a977ffe83..af93bfd11e 100644 --- a/src/dnode/src/dnodeMRead.c +++ b/src/dnode/src/dnodeMRead.c @@ -132,6 +132,11 @@ static void dnodeFreeMnodeReadMsg(SMnodeMsg *pRead) { static void dnodeSendRpcMnodeReadRsp(SMnodeMsg *pRead, int32_t code) { if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_ACTION_NEED_REPROCESSED) { + // may be a auto create req, should put into write queue + dnodeReprocessMnodeWriteMsg(pRead); + return; + } SRpcMsg rpcRsp = { .handle = pRead->rpcMsg.handle, diff --git a/src/dnode/src/dnodeMWrite.c b/src/dnode/src/dnodeMWrite.c index b54d295d05..655964fb34 100644 --- a/src/dnode/src/dnodeMWrite.c +++ b/src/dnode/src/dnodeMWrite.c @@ -130,6 +130,10 @@ static void dnodeFreeMnodeWriteMsg(SMnodeMsg *pWrite) { void dnodeSendRpcMnodeWriteRsp(void *pRaw, int32_t code) { SMnodeMsg *pWrite = pRaw; if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_ACTION_NEED_REPROCESSED) { + dnodeReprocessMnodeWriteMsg(pWrite); + return; + } SRpcMsg rpcRsp = { .handle = pWrite->rpcMsg.handle, diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c index 7eb6320763..1fa7b02a40 100644 --- a/src/mnode/src/mnodeTable.c +++ b/src/mnode/src/mnodeTable.c @@ -741,6 +741,7 @@ static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *pMsg) { mError("table:%s, failed to get table meta, table not exist", pInfo->tableId); return TSDB_CODE_INVALID_TABLE; } else { + mTrace("table:%s, failed to get table meta, start auto create table ", pInfo->tableId); return mgmtAutoCreateChildTable(pMsg); } } else { diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c index 97c3f69719..36e96dd006 100644 --- a/src/mnode/src/mnodeVgroup.c +++ b/src/mnode/src/mnodeVgroup.c @@ -307,7 +307,6 @@ int32_t mnodeCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { if (balanceAllocVnodes(pVgroup) != 0) { mError("db:%s, no enough dnode to alloc %d vnodes to vgroup", pDb->name, pVgroup->numOfVnodes); free(pVgroup); - mnodeCleanupMsg(pMsg); return TSDB_CODE_NO_ENOUGH_DNODES; } @@ -321,9 +320,7 @@ int32_t mnodeCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { int32_t code = sdbInsertRow(&oper); if (code != TSDB_CODE_SUCCESS) { tfree(pVgroup); - code = TSDB_CODE_SDB_ERROR; - mnodeCleanupMsg(pMsg); - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_SDB_ERROR; } mPrint("vgId:%d, is created in mnode, db:%s replica:%d", pVgroup->vgId, pDb->name, pVgroup->numOfVnodes); From 453590e2ec80c6b8e36313495865c9799e520df6 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 06:44:05 +0000 Subject: [PATCH 12/17] [TD-335] sort include file --- src/client/src/TSDBJNIConnector.c | 2 +- src/common/inc/tulog.h | 2 +- src/dnode/inc/dnodeInt.h | 2 +- src/dnode/inc/dnodeMain.h | 2 +- src/dnode/inc/dnodeMgmt.h | 2 +- src/dnode/inc/dnodePeer.h | 4 ++-- src/dnode/src/dnodeMPeer.c | 1 - src/dnode/src/dnodeMRead.c | 1 - src/dnode/src/dnodeMWrite.c | 1 - src/dnode/src/dnodeMgmt.c | 1 - src/dnode/src/dnodeModule.c | 1 - src/dnode/src/dnodePeer.c | 1 - src/dnode/src/dnodeShell.c | 1 - src/dnode/src/dnodeVRead.c | 5 ++--- src/dnode/src/dnodeVWrite.c | 10 +++++----- src/inc/dnode.h | 27 +++++++++++++-------------- src/inc/mnode.h | 9 +++++---- src/mnode/inc/mnodeInt.h | 4 ++-- src/mnode/src/mnodeDnode.c | 1 - src/mnode/src/mnodePeer.c | 1 - src/mnode/src/mnodeRead.c | 1 - src/mnode/src/mnodeSdb.c | 1 - src/mnode/src/mnodeShow.c | 1 - src/plugins/http/inc/httpLog.h | 2 +- src/plugins/monitor/src/monitorMain.c | 2 +- src/plugins/mqtt/inc/mqttLog.h | 2 +- src/rpc/inc/rpcLog.h | 2 +- src/util/src/ttimer.c | 2 +- src/vnode/inc/vnodeInt.h | 8 ++++---- src/vnode/inc/vnodeLog.h | 18 ++++-------------- src/vnode/src/vnodeMain.c | 10 +++++----- 31 files changed, 52 insertions(+), 75 deletions(-) diff --git a/src/client/src/TSDBJNIConnector.c b/src/client/src/TSDBJNIConnector.c index 802d383152..6ab1b73d1e 100644 --- a/src/client/src/TSDBJNIConnector.c +++ b/src/client/src/TSDBJNIConnector.c @@ -23,7 +23,7 @@ #include "ttime.h" #define jniError(...) { if (jniDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR JNI ", jniDebugFlag, __VA_ARGS__); }} -#define jniWarn(...) { if (jniDebugFlag & DEBUG_WARN) { taosPrintLog("WARN JNI ", jniDebugFlag, __VA_ARGS__); }} +#define jniWarn(...) { if (jniDebugFlag & DEBUG_WARN) { taosPrintLog("WARN JNI ", jniDebugFlag, __VA_ARGS__); }} #define jniTrace(...) { if (jniDebugFlag & DEBUG_TRACE) { taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); }} #define jniPrint(...) { taosPrintLog("JNI ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); } diff --git a/src/common/inc/tulog.h b/src/common/inc/tulog.h index a47e894e31..07120d7cbe 100644 --- a/src/common/inc/tulog.h +++ b/src/common/inc/tulog.h @@ -26,7 +26,7 @@ extern int32_t uDebugFlag; extern int32_t tscEmbedded; #define uError(...) { if (uDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR UTL ", uDebugFlag, __VA_ARGS__); }} -#define uWarn(...) { if (uDebugFlag & DEBUG_WARN) { taosPrintLog("WARN UTL ", uDebugFlag, __VA_ARGS__); }} +#define uWarn(...) { if (uDebugFlag & DEBUG_WARN) { taosPrintLog("WARN UTL ", uDebugFlag, __VA_ARGS__); }} #define uTrace(...) { if (uDebugFlag & DEBUG_TRACE) { taosPrintLog("UTL ", uDebugFlag, __VA_ARGS__); }} #define uDump(x, y) { if (uDebugFlag & DEBUG_DUMP) { taosDumpData(x, y); }} #define uPrint(...) { taosPrintLog("UTL ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); } diff --git a/src/dnode/inc/dnodeInt.h b/src/dnode/inc/dnodeInt.h index 663914a959..34bfe6e4f7 100644 --- a/src/dnode/inc/dnodeInt.h +++ b/src/dnode/inc/dnodeInt.h @@ -25,7 +25,7 @@ extern "C" { extern int32_t dDebugFlag; #define dError(...) { if (dDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR DND ", 255, __VA_ARGS__); }} -#define dWarn(...) { if (dDebugFlag & DEBUG_WARN) { taosPrintLog("WARN DND ", dDebugFlag, __VA_ARGS__); }} +#define dWarn(...) { if (dDebugFlag & DEBUG_WARN) { taosPrintLog("WARN DND ", dDebugFlag, __VA_ARGS__); }} #define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); }} #define dPrint(...) { taosPrintLog("DND ", 255, __VA_ARGS__); } diff --git a/src/dnode/inc/dnodeMain.h b/src/dnode/inc/dnodeMain.h index df7698ffc3..c1480407bd 100644 --- a/src/dnode/inc/dnodeMain.h +++ b/src/dnode/inc/dnodeMain.h @@ -21,7 +21,7 @@ extern "C" { #endif int32_t dnodeInitSystem(); -void dnodeCleanUpSystem(); +void dnodeCleanUpSystem(); #ifdef __cplusplus } diff --git a/src/dnode/inc/dnodeMgmt.h b/src/dnode/inc/dnodeMgmt.h index 1a788610e5..4d15dc5a86 100644 --- a/src/dnode/inc/dnodeMgmt.h +++ b/src/dnode/inc/dnodeMgmt.h @@ -34,7 +34,7 @@ void dnodeReleaseVnode(void *pVnode); void dnodeSendRedirectMsg(SRpcMsg *rpcMsg, bool forShell); void dnodeGetMnodeIpSetForPeer(void *ipSet); -void dnodeGetMnodeIpSetForShell(void *ipSe); +void dnodeGetMnodeIpSetForShell(void *ipSet); #ifdef __cplusplus } diff --git a/src/dnode/inc/dnodePeer.h b/src/dnode/inc/dnodePeer.h index 2ce8d80c0f..0dcf48f232 100644 --- a/src/dnode/inc/dnodePeer.h +++ b/src/dnode/inc/dnodePeer.h @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_DNODE_DNODE_H -#define TDENGINE_DNODE_DNODE_H +#ifndef TDENGINE_DNODE_PEER_H +#define TDENGINE_DNODE_PEER_H #ifdef __cplusplus extern "C" { diff --git a/src/dnode/src/dnodeMPeer.c b/src/dnode/src/dnodeMPeer.c index f5b0fe26f2..da1910a691 100644 --- a/src/dnode/src/dnodeMPeer.c +++ b/src/dnode/src/dnodeMPeer.c @@ -19,7 +19,6 @@ #include "taosmsg.h" #include "tutil.h" #include "tqueue.h" -#include "trpc.h" #include "twal.h" #include "tglobal.h" #include "mnode.h" diff --git a/src/dnode/src/dnodeMRead.c b/src/dnode/src/dnodeMRead.c index af93bfd11e..f22346b61c 100644 --- a/src/dnode/src/dnodeMRead.c +++ b/src/dnode/src/dnodeMRead.c @@ -19,7 +19,6 @@ #include "taosmsg.h" #include "tutil.h" #include "tqueue.h" -#include "trpc.h" #include "twal.h" #include "tglobal.h" #include "mnode.h" diff --git a/src/dnode/src/dnodeMWrite.c b/src/dnode/src/dnodeMWrite.c index 655964fb34..95fa9f0bdd 100644 --- a/src/dnode/src/dnodeMWrite.c +++ b/src/dnode/src/dnodeMWrite.c @@ -20,7 +20,6 @@ #include "tutil.h" #include "ttimer.h" #include "tqueue.h" -#include "trpc.h" #include "twal.h" #include "tglobal.h" #include "mnode.h" diff --git a/src/dnode/src/dnodeMgmt.c b/src/dnode/src/dnodeMgmt.c index 31e73eafbc..04457a9501 100644 --- a/src/dnode/src/dnodeMgmt.c +++ b/src/dnode/src/dnodeMgmt.c @@ -20,7 +20,6 @@ #include "taosmsg.h" #include "ttime.h" #include "ttimer.h" -#include "trpc.h" #include "tsdb.h" #include "twal.h" #include "tsync.h" diff --git a/src/dnode/src/dnodeModule.c b/src/dnode/src/dnodeModule.c index 61c1ec9382..126ec27ed1 100644 --- a/src/dnode/src/dnodeModule.c +++ b/src/dnode/src/dnodeModule.c @@ -17,7 +17,6 @@ #include "os.h" #include "taosdef.h" #include "tglobal.h" -#include "trpc.h" #include "mnode.h" #include "http.h" #include "mqtt.h" diff --git a/src/dnode/src/dnodePeer.c b/src/dnode/src/dnodePeer.c index bde6cd2aa7..9a7b0837e8 100644 --- a/src/dnode/src/dnodePeer.c +++ b/src/dnode/src/dnodePeer.c @@ -22,7 +22,6 @@ #include "os.h" #include "taosmsg.h" #include "tglobal.h" -#include "trpc.h" #include "mnode.h" #include "dnode.h" #include "dnodeInt.h" diff --git a/src/dnode/src/dnodeShell.c b/src/dnode/src/dnodeShell.c index bf40dd4326..b875f465c2 100644 --- a/src/dnode/src/dnodeShell.c +++ b/src/dnode/src/dnodeShell.c @@ -18,7 +18,6 @@ #include "taoserror.h" #include "taosdef.h" #include "taosmsg.h" -#include "trpc.h" #include "tglobal.h" #include "http.h" #include "mnode.h" diff --git a/src/dnode/src/dnodeVRead.c b/src/dnode/src/dnodeVRead.c index c2ca9fcd02..4b1ff84bec 100644 --- a/src/dnode/src/dnodeVRead.c +++ b/src/dnode/src/dnodeVRead.c @@ -19,7 +19,6 @@ #include "taosmsg.h" #include "tutil.h" #include "tqueue.h" -#include "trpc.h" #include "twal.h" #include "tglobal.h" #include "dnodeInt.h" @@ -142,7 +141,7 @@ void dnodeDispatchToVnodeReadQueue(SRpcMsg *pMsg) { } } -void *dnodeAllocateRqueue(void *pVnode) { +void *dnodeAllocateVnodeRqueue(void *pVnode) { taos_queue queue = taosOpenQueue(); if (queue == NULL) return NULL; @@ -172,7 +171,7 @@ void *dnodeAllocateRqueue(void *pVnode) { return queue; } -void dnodeFreeRqueue(void *rqueue) { +void dnodeFreeVnodeRqueue(void *rqueue) { taosCloseQueue(rqueue); // dynamically adjust the number of threads diff --git a/src/dnode/src/dnodeVWrite.c b/src/dnode/src/dnodeVWrite.c index bf4e49e84d..bbddfa0927 100644 --- a/src/dnode/src/dnodeVWrite.c +++ b/src/dnode/src/dnodeVWrite.c @@ -22,9 +22,9 @@ #include "trpc.h" #include "tsdb.h" #include "twal.h" +#include "tdataformat.h" #include "tglobal.h" #include "vnode.h" -#include "tdataformat.h" #include "dnodeInt.h" #include "dnodeVWrite.h" #include "dnodeMgmt.h" @@ -122,7 +122,7 @@ void dnodeDispatchToVnodeWriteQueue(SRpcMsg *pMsg) { } } -void *dnodeAllocateWqueue(void *pVnode) { +void *dnodeAllocateVnodeWqueue(void *pVnode) { SWriteWorker *pWorker = wWorkerPool.writeWorker + wWorkerPool.nextId; void *queue = taosOpenQueue(); if (queue == NULL) return NULL; @@ -157,13 +157,13 @@ void *dnodeAllocateWqueue(void *pVnode) { return queue; } -void dnodeFreeWqueue(void *wqueue) { +void dnodeFreeVnodeWqueue(void *wqueue) { taosCloseQueue(wqueue); // dynamically adjust the number of threads } -void dnodeSendRpcWriteRsp(void *pVnode, void *param, int32_t code) { +void dnodeSendRpcVnodeWriteRsp(void *pVnode, void *param, int32_t code) { SWriteMsg *pWrite = (SWriteMsg *)param; if (code > 0) return; @@ -223,7 +223,7 @@ static void *dnodeProcessWriteQueue(void *param) { taosGetQitem(pWorker->qall, &type, &item); if (type == TAOS_QTYPE_RPC) { pWrite = (SWriteMsg *)item; - dnodeSendRpcWriteRsp(pVnode, item, pWrite->rpcMsg.code); + dnodeSendRpcVnodeWriteRsp(pVnode, item, pWrite->rpcMsg.code); } else { taosFreeQitem(item); vnodeRelease(pVnode); diff --git a/src/inc/dnode.h b/src/inc/dnode.h index ff4cc7f81f..3d3616085d 100644 --- a/src/inc/dnode.h +++ b/src/inc/dnode.h @@ -37,12 +37,6 @@ typedef enum { SDnodeRunStatus dnodeGetRunStatus(); SDnodeStatisInfo dnodeGetStatisInfo(); -void *dnodeAllocateWqueue(void *pVnode); -void dnodeFreeWqueue(void *queue); -void *dnodeAllocateRqueue(void *pVnode); -void dnodeFreeRqueue(void *rqueue); -void dnodeSendRpcWriteRsp(void *pVnode, void *param, int32_t code); - bool dnodeIsFirstDeploy(); char * dnodeGetMnodeMasterEp(); void dnodeGetMnodeIpSetForPeer(void *ipSet); @@ -54,16 +48,21 @@ void dnodeAddClientRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)); void dnodeSendMsgToDnode(SRpcIpSet *ipSet, SRpcMsg *rpcMsg); void dnodeSendMsgToDnodeRecv(SRpcMsg *rpcMsg, SRpcMsg *rpcRsp); -int32_t dnodeAllocateMnodeWqueue(); -void dnodeFreeMnodeWqueue(); -int32_t dnodeAllocateMnodeRqueue(); -void dnodeFreeMnodeRqueue(); +void *dnodeAllocateVnodeWqueue(void *pVnode); +void dnodeFreeVnodeWqueue(void *queue); +void *dnodeAllocateVnodeRqueue(void *pVnode); +void dnodeFreeVnodeRqueue(void *rqueue); +void dnodeSendRpcVnodeWriteRsp(void *pVnode, void *param, int32_t code); + int32_t dnodeAllocateMnodePqueue(); void dnodeFreeMnodePqueue(); - -void dnodeSendRpcMnodeWriteRsp(void *pMsg, int32_t code); -void dnodeReprocessMnodeWriteMsg(void *pMsg); -void dnodeDelayReprocessMnodeWriteMsg(void *pMsg); +int32_t dnodeAllocateMnodeRqueue(); +void dnodeFreeMnodeRqueue(); +int32_t dnodeAllocateMnodeWqueue(); +void dnodeFreeMnodeWqueue(); +void dnodeSendRpcMnodeWriteRsp(void *pMsg, int32_t code); +void dnodeReprocessMnodeWriteMsg(void *pMsg); +void dnodeDelayReprocessMnodeWriteMsg(void *pMsg); #ifdef __cplusplus } diff --git a/src/inc/mnode.h b/src/inc/mnode.h index 513e81a461..6f0c4d6949 100644 --- a/src/inc/mnode.h +++ b/src/inc/mnode.h @@ -20,13 +20,14 @@ extern "C" { #endif +#include "trpc.h" + struct SAcctObj; struct SDnodeObj; struct SUserObj; struct SDbObj; struct SVgObj; struct STableObj; -struct SRpcMsg; typedef struct { int32_t len; @@ -34,13 +35,13 @@ typedef struct { } SMnodeRsp; typedef struct SMnodeMsg { + SRpcMsg rpcMsg; SMnodeRsp rpcRsp; int8_t received; int8_t successed; int8_t expected; int8_t retry; int32_t code; - struct SRpcMsg rpcMsg; struct SAcctObj * pAcct; struct SDnodeObj *pDnode; struct SUserObj * pUser; @@ -49,7 +50,7 @@ typedef struct SMnodeMsg { struct STableObj *pTable; } SMnodeMsg; -void mnodeCreateMsg(SMnodeMsg *pMsg, struct SRpcMsg *rpcMsg); +void mnodeCreateMsg(SMnodeMsg *pMsg, SRpcMsg *rpcMsg); int32_t mnodeInitMsg(SMnodeMsg *pMsg); void mnodeCleanupMsg(SMnodeMsg *pMsg); @@ -62,7 +63,7 @@ bool mnodeIsRunning(); int32_t mnodeProcessRead(SMnodeMsg *pMsg); int32_t mnodeProcessWrite(SMnodeMsg *pMsg); int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg); -void mnodeProcessPeerRsp(struct SRpcMsg *pMsg); +void mnodeProcessPeerRsp(SRpcMsg *pMsg); int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey); #ifdef __cplusplus diff --git a/src/mnode/inc/mnodeInt.h b/src/mnode/inc/mnodeInt.h index 52259d0134..7405cef6f3 100644 --- a/src/mnode/inc/mnodeInt.h +++ b/src/mnode/inc/mnodeInt.h @@ -28,7 +28,7 @@ extern int32_t sdbDebugFlag; // mnode log function #define mError(...) { if (mDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR MND ", 255, __VA_ARGS__); }} -#define mWarn(...) { if (mDebugFlag & DEBUG_WARN) { taosPrintLog("WARN MND ", mDebugFlag, __VA_ARGS__); }} +#define mWarn(...) { if (mDebugFlag & DEBUG_WARN) { taosPrintLog("WARN MND ", mDebugFlag, __VA_ARGS__); }} #define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }} #define mPrint(...) { taosPrintLog("MND ", 255, __VA_ARGS__); } @@ -37,7 +37,7 @@ extern int32_t sdbDebugFlag; #define mLPrint(...) { monitorSaveLog(0, __VA_ARGS__); mPrint(__VA_ARGS__) } #define sdbError(...) { if (sdbDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR MND-SDB ", 255, __VA_ARGS__); }} -#define sdbWarn(...) { if (sdbDebugFlag & DEBUG_WARN) { taosPrintLog("WARN MND-SDB ", sdbDebugFlag, __VA_ARGS__); }} +#define sdbWarn(...) { if (sdbDebugFlag & DEBUG_WARN) { taosPrintLog("WARN MND-SDB ", sdbDebugFlag, __VA_ARGS__); }} #define sdbTrace(...) { if (sdbDebugFlag & DEBUG_TRACE) { taosPrintLog("MND-SDB ", sdbDebugFlag, __VA_ARGS__);}} #define sdbPrint(...) { taosPrintLog("MND-SDB ", 255, __VA_ARGS__); } diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c index 827fef9ed6..c6c0232259 100644 --- a/src/mnode/src/mnodeDnode.c +++ b/src/mnode/src/mnodeDnode.c @@ -15,7 +15,6 @@ #define _DEFAULT_SOURCE #include "os.h" -#include "trpc.h" #include "tgrant.h" #include "tbalance.h" #include "tglobal.h" diff --git a/src/mnode/src/mnodePeer.c b/src/mnode/src/mnodePeer.c index 3594b60cf1..d3699948f2 100644 --- a/src/mnode/src/mnodePeer.c +++ b/src/mnode/src/mnodePeer.c @@ -16,7 +16,6 @@ #define _DEFAULT_SOURCE #include "os.h" #include "taoserror.h" -#include "trpc.h" #include "tsched.h" #include "tsystem.h" #include "tutil.h" diff --git a/src/mnode/src/mnodeRead.c b/src/mnode/src/mnodeRead.c index cc58f89041..0ee917f2d1 100644 --- a/src/mnode/src/mnodeRead.c +++ b/src/mnode/src/mnodeRead.c @@ -15,7 +15,6 @@ #define _DEFAULT_SOURCE #include "os.h" -#include "trpc.h" #include "taosdef.h" #include "tsched.h" #include "tbalance.h" diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c index 3b04be1ea6..3905773d54 100644 --- a/src/mnode/src/mnodeSdb.c +++ b/src/mnode/src/mnodeSdb.c @@ -17,7 +17,6 @@ #include "os.h" #include "taoserror.h" #include "hash.h" -#include "trpc.h" #include "tutil.h" #include "tbalance.h" #include "tqueue.h" diff --git a/src/mnode/src/mnodeShow.c b/src/mnode/src/mnodeShow.c index c29c3dab68..0a522e8f99 100644 --- a/src/mnode/src/mnodeShow.c +++ b/src/mnode/src/mnodeShow.c @@ -17,7 +17,6 @@ #include "os.h" #include "taosmsg.h" #include "taoserror.h" -#include "trpc.h" #include "tsched.h" #include "tutil.h" #include "ttimer.h" diff --git a/src/plugins/http/inc/httpLog.h b/src/plugins/http/inc/httpLog.h index 0e09f277f0..a940dcf6ec 100644 --- a/src/plugins/http/inc/httpLog.h +++ b/src/plugins/http/inc/httpLog.h @@ -21,7 +21,7 @@ extern int32_t httpDebugFlag; #define httpError(...) { if (httpDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR HTP ", 255, __VA_ARGS__); }} -#define httpWarn(...) { if (httpDebugFlag & DEBUG_WARN) { taosPrintLog("WARN HTP ", httpDebugFlag, __VA_ARGS__); }} +#define httpWarn(...) { if (httpDebugFlag & DEBUG_WARN) { taosPrintLog("WARN HTP ", httpDebugFlag, __VA_ARGS__); }} #define httpTrace(...) { if (httpDebugFlag & DEBUG_TRACE) { taosPrintLog("HTP ", httpDebugFlag, __VA_ARGS__); }} #define httpDump(...) { if (httpDebugFlag & DEBUG_TRACE) { taosPrintLongString("HTP ", httpDebugFlag, __VA_ARGS__); }} #define httpPrint(...) { taosPrintLog("HTP ", 255, __VA_ARGS__); } diff --git a/src/plugins/monitor/src/monitorMain.c b/src/plugins/monitor/src/monitorMain.c index fc958c1b1f..0c27233289 100644 --- a/src/plugins/monitor/src/monitorMain.c +++ b/src/plugins/monitor/src/monitorMain.c @@ -28,7 +28,7 @@ #include "monitor.h" #define monitorError(...) { if (monitorDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR MON ", 255, __VA_ARGS__); }} -#define monitorWarn(...) { if (monitorDebugFlag & DEBUG_WARN) { taosPrintLog("WARN MON ", monitorDebugFlag, __VA_ARGS__); }} +#define monitorWarn(...) { if (monitorDebugFlag & DEBUG_WARN) { taosPrintLog("WARN MON ", monitorDebugFlag, __VA_ARGS__); }} #define monitorTrace(...) { if (monitorDebugFlag & DEBUG_TRACE) { taosPrintLog("MON ", monitorDebugFlag, __VA_ARGS__); }} #define monitorPrint(...) { taosPrintLog("MON ", 255, __VA_ARGS__); } diff --git a/src/plugins/mqtt/inc/mqttLog.h b/src/plugins/mqtt/inc/mqttLog.h index 735678a326..a7ae2fc1ae 100644 --- a/src/plugins/mqtt/inc/mqttLog.h +++ b/src/plugins/mqtt/inc/mqttLog.h @@ -26,7 +26,7 @@ extern int32_t mqttDebugFlag; } #define mqttWarn(...) \ if ( mqttDebugFlag & DEBUG_WARN) { \ - taosPrintLog("WARN MQT ", mqttDebugFlag, __VA_ARGS__); \ + taosPrintLog("WARN MQT ", mqttDebugFlag, __VA_ARGS__); \ } #define mqttTrace(...) \ if ( mqttDebugFlag & DEBUG_TRACE) { \ diff --git a/src/rpc/inc/rpcLog.h b/src/rpc/inc/rpcLog.h index 5094d81757..10ef974298 100644 --- a/src/rpc/inc/rpcLog.h +++ b/src/rpc/inc/rpcLog.h @@ -25,7 +25,7 @@ extern "C" { extern int32_t rpcDebugFlag; #define tError(...) { if (rpcDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR RPC ", rpcDebugFlag, __VA_ARGS__); }} -#define tWarn(...) { if (rpcDebugFlag & DEBUG_WARN) { taosPrintLog("WARN RPC ", rpcDebugFlag, __VA_ARGS__); }} +#define tWarn(...) { if (rpcDebugFlag & DEBUG_WARN) { taosPrintLog("WARN RPC ", rpcDebugFlag, __VA_ARGS__); }} #define tTrace(...) { if (rpcDebugFlag & DEBUG_TRACE) { taosPrintLog("RPC ", rpcDebugFlag, __VA_ARGS__); }} #define tDump(x, y) { if (rpcDebugFlag & DEBUG_DUMP) { taosDumpData((unsigned char *)x, y); }} #define tPrint(...) { taosPrintLog("RPC ", 255, __VA_ARGS__); } diff --git a/src/util/src/ttimer.c b/src/util/src/ttimer.c index e6ef73ef57..68db574d82 100644 --- a/src/util/src/ttimer.c +++ b/src/util/src/ttimer.c @@ -27,7 +27,7 @@ #define tmrWarn(...) \ do { if (tmrDebugFlag & DEBUG_WARN) { \ - taosPrintLog("WARN TMR ", tmrDebugFlag, __VA_ARGS__); \ + taosPrintLog("WARN TMR ", tmrDebugFlag, __VA_ARGS__); \ } } while(0) #define tmrTrace(...) \ diff --git a/src/vnode/inc/vnodeInt.h b/src/vnode/inc/vnodeInt.h index dea9369dd8..0168304b51 100644 --- a/src/vnode/inc/vnodeInt.h +++ b/src/vnode/inc/vnodeInt.h @@ -27,10 +27,10 @@ extern "C" { extern int32_t vDebugFlag; -#define vError(...) if (vDebugFlag & DEBUG_ERROR) {taosPrintLog("ERROR VND ", 255, __VA_ARGS__); } -#define vWarn(...) if (vDebugFlag & DEBUG_WARN) {taosPrintLog("WARN VND ", vDebugFlag, __VA_ARGS__); } -#define vTrace(...) if (vDebugFlag & DEBUG_TRACE) {taosPrintLog("VND ", vDebugFlag, __VA_ARGS__); } -#define vPrint(...) {taosPrintLog("VND ", 255, __VA_ARGS__); } +#define vError(...) { if (vDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR VND ", 255, __VA_ARGS__); }} +#define vWarn(...) { if (vDebugFlag & DEBUG_WARN) { taosPrintLog("WARN VND ", vDebugFlag, __VA_ARGS__); }} +#define vTrace(...) { if (vDebugFlag & DEBUG_TRACE) { taosPrintLog("VND ", vDebugFlag, __VA_ARGS__); }} +#define vPrint(...) { taosPrintLog("VND ", 255, __VA_ARGS__); } typedef struct { int32_t vgId; // global vnode group ID diff --git a/src/vnode/inc/vnodeLog.h b/src/vnode/inc/vnodeLog.h index bd8daae0b6..d6794202da 100644 --- a/src/vnode/inc/vnodeLog.h +++ b/src/vnode/inc/vnodeLog.h @@ -24,20 +24,10 @@ extern "C" { extern int32_t dDebugFlag; -#define dError(...) \ - if (dDebugFlag & DEBUG_ERROR) { \ - taosPrintLog("ERROR DND ", 255, __VA_ARGS__); \ - } -#define dWarn(...) \ - if (dDebugFlag & DEBUG_WARN) { \ - taosPrintLog("WARN DND ", dDebugFlag, __VA_ARGS__); \ - } -#define dTrace(...) \ - if (dDebugFlag & DEBUG_TRACE) { \ - taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); \ - } -#define dPrint(...) \ - { taosPrintLog("DND ", 255, __VA_ARGS__); } +#define dError(...) { if (dDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR DND ", 255, __VA_ARGS__); }} +#define dWarn(...) { if (dDebugFlag & DEBUG_WARN) { taosPrintLog("WARN DND ", dDebugFlag, __VA_ARGS__); }} +#define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", dDebugFlag, __VA_ARGS__); }} +#define dPrint(...) { taosPrintLog("DND ", 255, __VA_ARGS__); } #ifdef __cplusplus } diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c index b8bc29550e..b25180f0f0 100644 --- a/src/vnode/src/vnodeMain.c +++ b/src/vnode/src/vnodeMain.c @@ -198,8 +198,8 @@ int32_t vnodeOpen(int32_t vnode, char *rootDir) { pVnode->fversion = pVnode->version; - pVnode->wqueue = dnodeAllocateWqueue(pVnode); - pVnode->rqueue = dnodeAllocateRqueue(pVnode); + pVnode->wqueue = dnodeAllocateVnodeWqueue(pVnode); + pVnode->rqueue = dnodeAllocateVnodeRqueue(pVnode); if (pVnode->wqueue == NULL || pVnode->rqueue == NULL) { vnodeCleanUp(pVnode); return terrno; @@ -245,7 +245,7 @@ int32_t vnodeOpen(int32_t vnode, char *rootDir) { syncInfo.getWalInfo = vnodeGetWalInfo; syncInfo.getFileInfo = vnodeGetFileInfo; syncInfo.writeToCache = vnodeWriteToQueue; - syncInfo.confirmForward = dnodeSendRpcWriteRsp; + syncInfo.confirmForward = dnodeSendRpcVnodeWriteRsp; syncInfo.notifyRole = vnodeNotifyRole; syncInfo.notifyFileSynced = vnodeNotifyFileSynced; pVnode->sync = syncStart(&syncInfo); @@ -404,11 +404,11 @@ static void vnodeCleanUp(SVnodeObj *pVnode) { pVnode->cq = NULL; if (pVnode->wqueue) - dnodeFreeWqueue(pVnode->wqueue); + dnodeFreeVnodeWqueue(pVnode->wqueue); pVnode->wqueue = NULL; if (pVnode->rqueue) - dnodeFreeRqueue(pVnode->rqueue); + dnodeFreeVnodeRqueue(pVnode->rqueue); pVnode->rqueue = NULL; vnodeRelease(pVnode); From 3528ed61d0d1f6bd09f9f2bc01f938091f510851 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 07:09:53 +0000 Subject: [PATCH 13/17] [TD-335] rename mgmt to mnode --- packaging/cfg/taos.cfg | 2 +- src/client/inc/tsclient.h | 4 +- src/client/src/tscParseInsert.c | 2 +- src/client/src/tscServer.c | 6 +-- src/client/src/tscSql.c | 2 +- src/client/src/tscSystem.c | 2 +- src/common/src/tglobal.c | 4 +- src/dnode/src/dnodeMgmt.c | 22 ++++----- src/dnode/src/dnodeModule.c | 18 ++++---- src/inc/mnode.h | 2 +- src/inc/taosdef.h | 2 +- src/mnode/inc/mnodeDnode.h | 2 +- src/mnode/inc/mnodeMnode.h | 2 +- src/mnode/src/mnodeDb.c | 2 +- src/mnode/src/mnodeDnode.c | 6 +-- src/mnode/src/mnodeMain.c | 20 ++++---- src/mnode/src/mnodeMnode.c | 2 +- src/mnode/src/mnodeTable.c | 46 +++++++++---------- src/mnode/src/mnodeVgroup.c | 10 ++-- tests/pytest/util/dnodes.py | 2 +- tests/script/general/alter/count.sim | 2 +- tests/script/general/alter/import.sim | 2 +- tests/script/general/db/backup/keep.sim | 6 +-- tests/script/general/db/delete_reuse1.sim | 8 ++-- tests/script/general/db/delete_reuse2.sim | 8 ++-- tests/script/general/db/delete_writing1.sim | 8 ++-- tests/script/general/import/basic.sim | 8 ++-- tests/script/general/import/commit.sim | 8 ++-- tests/script/general/import/large.sim | 8 ++-- tests/script/general/import/replica1.sim | 8 ++-- tests/script/general/table/delete_reuse1.sim | 8 ++-- tests/script/general/table/delete_reuse2.sim | 8 ++-- tests/script/general/table/delete_writing.sim | 8 ++-- tests/script/sh/clear.sh | 2 +- tests/script/sh/deploy.sh | 2 +- tests/script/tmp/prepare.sim | 8 ++-- tests/script/unique/cluster/balance1.sim | 16 +++---- tests/script/unique/cluster/balance2.sim | 16 +++---- tests/script/unique/cluster/balance3.sim | 16 +++---- tests/script/unique/db/commit.sim | 6 +-- tests/script/unique/db/delete_part.sim | 8 ++-- tests/script/unique/db/replica_add12.sim | 8 ++-- tests/script/unique/db/replica_add13.sim | 8 ++-- tests/script/unique/db/replica_add23.sim | 8 ++-- tests/script/unique/db/replica_part.sim | 6 +-- tests/script/unique/db/replica_reduce21.sim | 6 +-- tests/script/unique/db/replica_reduce31.sim | 6 +-- tests/script/unique/db/replica_reduce32.sim | 6 +-- tests/script/unique/dnode/balance1.sim | 8 ++-- tests/script/unique/dnode/balance2.sim | 10 ++-- tests/script/unique/dnode/balance3.sim | 12 ++--- tests/script/unique/dnode/balancex.sim | 8 ++-- tests/script/unique/dnode/monitor_bug.sim | 4 +- tests/script/unique/dnode/offline1.sim | 6 +-- tests/script/unique/dnode/offline2.sim | 6 +-- tests/script/unique/dnode/remove1.sim | 8 ++-- tests/script/unique/dnode/remove2.sim | 8 ++-- tests/script/unique/dnode/vnode_clean.sim | 8 ++-- tests/script/unique/import/replica2.sim | 8 ++-- tests/script/unique/import/replica3.sim | 8 ++-- .../script/unique/stable/balance_replica1.sim | 4 +- .../script/unique/stream/metrics_balance.sim | 4 +- tests/script/unique/stream/table_balance.sim | 4 +- tests/script/unique/stream/table_move.sim | 8 ++-- tests/script/unique/vnode/many.sim | 8 ++-- tests/script/unique/vnode/replica2_basic2.sim | 8 ++-- tests/script/unique/vnode/replica2_repeat.sim | 8 ++-- tests/script/unique/vnode/replica3_repeat.sim | 8 ++-- 68 files changed, 258 insertions(+), 258 deletions(-) diff --git a/packaging/cfg/taos.cfg b/packaging/cfg/taos.cfg index 38e960eb06..0d2ebf9eda 100644 --- a/packaging/cfg/taos.cfg +++ b/packaging/cfg/taos.cfg @@ -155,7 +155,7 @@ # maxVnodeConnections 10000 # mnode take into account while balance, for cluster version only -# mgmtEqualVnodeNum 4 +# mnodeEqualVnodeNum 4 # number of seconds allowed for a dnode to be offline, for cluster version only # offlineThreshold 864000 diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h index 08536a505d..c04c31dfb7 100644 --- a/src/client/inc/tsclient.h +++ b/src/client/inc/tsclient.h @@ -284,8 +284,8 @@ typedef struct { typedef struct STscObj { void * signature; void * pTimer; - char mgmtIp[TSDB_USER_LEN]; - uint16_t mgmtPort; + char mnodeIp[TSDB_USER_LEN]; + uint16_t mnodePort; char user[TSDB_USER_LEN]; char pass[TSDB_KEY_LEN]; char acctId[TSDB_DB_NAME_LEN]; diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c index 9202203fac..79872e22c8 100644 --- a/src/client/src/tscParseInsert.c +++ b/src/client/src/tscParseInsert.c @@ -1361,7 +1361,7 @@ int tsParseSql(SSqlObj *pSql, bool initialParse) { /* * the pRes->code may be modified or released by another thread in tscTableMetaCallBack function, * so do NOT use pRes->code to determine if the getTableMeta/getMetricMeta function - * invokes new threads to get data from mgmt node or simply retrieves data from cache. + * invokes new threads to get data from mnode or simply retrieves data from cache. * * do NOT assign return code to pRes->code for the same reason since it may be released by another thread * pRes->code = ret; diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c index a1c50b1518..417108dfce 100644 --- a/src/client/src/tscServer.c +++ b/src/client/src/tscServer.c @@ -60,10 +60,10 @@ static void tscSetDnodeIpList(SSqlObj* pSql, SCMVgroupInfo* pVgroupInfo) { void tscPrintMgmtIp() { if (tscMgmtIpSet.numOfIps <= 0) { - tscError("invalid mgmt IP list:%d", tscMgmtIpSet.numOfIps); + tscError("invalid mnode IP list:%d", tscMgmtIpSet.numOfIps); } else { for (int i = 0; i < tscMgmtIpSet.numOfIps; ++i) { - tscTrace("mgmt index:%d %s:%d", i, tscMgmtIpSet.fqdn[i], tscMgmtIpSet.port[i]); + tscTrace("mnode index:%d %s:%d", i, tscMgmtIpSet.fqdn[i], tscMgmtIpSet.port[i]); } } } @@ -78,7 +78,7 @@ void tscSetMgmtIpList(SRpcIpSet *pIpList) { void tscUpdateIpSet(void *ahandle, SRpcIpSet *pIpSet) { tscMgmtIpSet = *pIpSet; - tscTrace("mgmt IP list is changed for ufp is called, numOfIps:%d inUse:%d", tscMgmtIpSet.numOfIps, tscMgmtIpSet.inUse); + tscTrace("mnode IP list is changed for ufp is called, numOfIps:%d inUse:%d", tscMgmtIpSet.numOfIps, tscMgmtIpSet.inUse); for (int32_t i = 0; i < tscMgmtIpSet.numOfIps; ++i) { tscTrace("index:%d fqdn:%s port:%d", i, tscMgmtIpSet.fqdn[i], tscMgmtIpSet.port[i]); } diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c index 7a6cce4d7f..a9ec33c078 100644 --- a/src/client/src/tscSql.c +++ b/src/client/src/tscSql.c @@ -88,7 +88,7 @@ STscObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con strncpy(pObj->user, user, TSDB_USER_LEN); taosEncryptPass((uint8_t *)pass, strlen(pass), pObj->pass); - pObj->mgmtPort = port ? port : tsDnodeShellPort; + pObj->mnodePort = port ? port : tsDnodeShellPort; if (db) { int32_t len = strlen(db); diff --git a/src/client/src/tscSystem.c b/src/client/src/tscSystem.c index 5d56fef1e9..2ca53bade1 100644 --- a/src/client/src/tscSystem.c +++ b/src/client/src/tscSystem.c @@ -116,7 +116,7 @@ void taos_init_imp() { } if (tscSetMgmtIpListFromCfg(tsFirst, tsSecond) < 0) { - tscError("failed to init mgmt IP list"); + tscError("failed to init mnode IP list"); return; } diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c index bb822053d4..4630ea48c9 100644 --- a/src/common/src/tglobal.c +++ b/src/common/src/tglobal.c @@ -427,7 +427,7 @@ static void doInitGlobalConfig() { cfg.unitType = TAOS_CFG_UTYPE_NONE; taosInitConfigOption(cfg); - // 0-any; 1-mgmt; 2-dnode + // 0-any; 1-mnode; 2-dnode cfg.option = "alternativeRole"; cfg.ptr = &tsAlternativeRole; cfg.valType = TAOS_CFG_VTYPE_INT32; @@ -875,7 +875,7 @@ static void doInitGlobalConfig() { taosInitConfigOption(cfg); // module configs - cfg.option = "mgmtEqualVnodeNum"; + cfg.option = "mnodeEqualVnodeNum"; cfg.ptr = &tsMnodeEqualVnodeNum; cfg.valType = TAOS_CFG_VTYPE_INT32; cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW; diff --git a/src/dnode/src/dnodeMgmt.c b/src/dnode/src/dnodeMgmt.c index 04457a9501..f6be375396 100644 --- a/src/dnode/src/dnodeMgmt.c +++ b/src/dnode/src/dnodeMgmt.c @@ -363,10 +363,10 @@ static void dnodeUpdateMnodeInfos(SDMMnodeInfos *pMnodes) { static bool dnodeReadMnodeInfos() { char ipFile[TSDB_FILENAME_LEN] = {0}; - sprintf(ipFile, "%s/mgmtIpList.json", tsDnodeDir); + sprintf(ipFile, "%s/mnodeIpList.json", tsDnodeDir); FILE *fp = fopen(ipFile, "r"); if (!fp) { - dTrace("failed to read mnode mgmtIpList.json, file not exist"); + dTrace("failed to read mnodeIpList.json, file not exist"); return false; } @@ -377,39 +377,39 @@ static bool dnodeReadMnodeInfos() { if (len <= 0) { free(content); fclose(fp); - dError("failed to read mnode mgmtIpList.json, content is null"); + dError("failed to read mnodeIpList.json, content is null"); return false; } cJSON* root = cJSON_Parse(content); if (root == NULL) { - dError("failed to read mnode mgmtIpList.json, invalid json format"); + dError("failed to read mnodeIpList.json, invalid json format"); goto PARSE_OVER; } cJSON* inUse = cJSON_GetObjectItem(root, "inUse"); if (!inUse || inUse->type != cJSON_Number) { - dError("failed to read mnode mgmtIpList.json, inUse not found"); + dError("failed to read mnodeIpList.json, inUse not found"); goto PARSE_OVER; } tsDMnodeInfos.inUse = inUse->valueint; cJSON* nodeNum = cJSON_GetObjectItem(root, "nodeNum"); if (!nodeNum || nodeNum->type != cJSON_Number) { - dError("failed to read mnode mgmtIpList.json, nodeNum not found"); + dError("failed to read mnodeIpList.json, nodeNum not found"); goto PARSE_OVER; } tsDMnodeInfos.nodeNum = nodeNum->valueint; cJSON* nodeInfos = cJSON_GetObjectItem(root, "nodeInfos"); if (!nodeInfos || nodeInfos->type != cJSON_Array) { - dError("failed to read mnode mgmtIpList.json, nodeInfos not found"); + dError("failed to read mnodeIpList.json, nodeInfos not found"); goto PARSE_OVER; } int size = cJSON_GetArraySize(nodeInfos); if (size != tsDMnodeInfos.nodeNum) { - dError("failed to read mnode mgmtIpList.json, nodeInfos size not matched"); + dError("failed to read mnodeIpList.json, nodeInfos size not matched"); goto PARSE_OVER; } @@ -419,14 +419,14 @@ static bool dnodeReadMnodeInfos() { cJSON *nodeId = cJSON_GetObjectItem(nodeInfo, "nodeId"); if (!nodeId || nodeId->type != cJSON_Number) { - dError("failed to read mnode mgmtIpList.json, nodeId not found"); + dError("failed to read mnodeIpList.json, nodeId not found"); goto PARSE_OVER; } tsDMnodeInfos.nodeInfos[i].nodeId = nodeId->valueint; cJSON *nodeEp = cJSON_GetObjectItem(nodeInfo, "nodeEp"); if (!nodeEp || nodeEp->type != cJSON_String || nodeEp->valuestring == NULL) { - dError("failed to read mnode mgmtIpList.json, nodeName not found"); + dError("failed to read mnodeIpList.json, nodeName not found"); goto PARSE_OVER; } strncpy(tsDMnodeInfos.nodeInfos[i].nodeEp, nodeEp->valuestring, TSDB_EP_LEN); @@ -448,7 +448,7 @@ PARSE_OVER: static void dnodeSaveMnodeInfos() { char ipFile[TSDB_FILENAME_LEN] = {0}; - sprintf(ipFile, "%s/mgmtIpList.json", tsDnodeDir); + sprintf(ipFile, "%s/mnodeIpList.json", tsDnodeDir); FILE *fp = fopen(ipFile, "w"); if (!fp) return; diff --git a/src/dnode/src/dnodeModule.c b/src/dnode/src/dnodeModule.c index 126ec27ed1..16ede53532 100644 --- a/src/dnode/src/dnodeModule.c +++ b/src/dnode/src/dnodeModule.c @@ -45,12 +45,12 @@ static void dnodeUnSetModuleStatus(int32_t module) { } static void dnodeAllocModules() { - tsModule[TSDB_MOD_MGMT].enable = false; - tsModule[TSDB_MOD_MGMT].name = "mgmt"; - tsModule[TSDB_MOD_MGMT].initFp = mnodeInitSystem; - tsModule[TSDB_MOD_MGMT].cleanUpFp = mnodeCleanupSystem; - tsModule[TSDB_MOD_MGMT].startFp = mnodeStartSystem; - tsModule[TSDB_MOD_MGMT].stopFp = mgmtStopSystem; + tsModule[TSDB_MOD_MNODE].enable = false; + tsModule[TSDB_MOD_MNODE].name = "mnode"; + tsModule[TSDB_MOD_MNODE].initFp = mnodeInitSystem; + tsModule[TSDB_MOD_MNODE].cleanUpFp = mnodeCleanupSystem; + tsModule[TSDB_MOD_MNODE].startFp = mnodeStartSystem; + tsModule[TSDB_MOD_MNODE].stopFp = mnodeStopSystem; tsModule[TSDB_MOD_HTTP].enable = (tsEnableHttpModule == 1); tsModule[TSDB_MOD_HTTP].name = "http"; @@ -93,8 +93,8 @@ void dnodeCleanUpModules() { } } - if (tsModule[TSDB_MOD_MGMT].enable && tsModule[TSDB_MOD_MGMT].cleanUpFp) { - (*tsModule[TSDB_MOD_MGMT].cleanUpFp)(); + if (tsModule[TSDB_MOD_MNODE].enable && tsModule[TSDB_MOD_MNODE].cleanUpFp) { + (*tsModule[TSDB_MOD_MNODE].cleanUpFp)(); } } @@ -124,7 +124,7 @@ void dnodeStartModules() { } void dnodeProcessModuleStatus(uint32_t moduleStatus) { - for (int32_t module = TSDB_MOD_MGMT; module < TSDB_MOD_HTTP; ++module) { + for (int32_t module = TSDB_MOD_MNODE; module < TSDB_MOD_HTTP; ++module) { bool enableModule = moduleStatus & (1 << module); if (!tsModule[module].enable && enableModule) { dPrint("module status:%u is received, start %s module", tsModuleStatus, tsModule[module].name); diff --git a/src/inc/mnode.h b/src/inc/mnode.h index 6f0c4d6949..bbb6fc5385 100644 --- a/src/inc/mnode.h +++ b/src/inc/mnode.h @@ -57,7 +57,7 @@ void mnodeCleanupMsg(SMnodeMsg *pMsg); int32_t mnodeInitSystem(); int32_t mnodeStartSystem(); void mnodeCleanupSystem(); -void mgmtStopSystem(); +void mnodeStopSystem(); void sdbUpdateSync(); bool mnodeIsRunning(); int32_t mnodeProcessRead(SMnodeMsg *pMsg); diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h index b87a6b3118..ce50fcbcf0 100644 --- a/src/inc/taosdef.h +++ b/src/inc/taosdef.h @@ -373,7 +373,7 @@ typedef enum { } ETableType; typedef enum { - TSDB_MOD_MGMT, + TSDB_MOD_MNODE, TSDB_MOD_HTTP, TSDB_MOD_MONITOR, TSDB_MOD_MQTT, diff --git a/src/mnode/inc/mnodeDnode.h b/src/mnode/inc/mnodeDnode.h index 75a1e29b0b..2b12a29390 100644 --- a/src/mnode/inc/mnodeDnode.h +++ b/src/mnode/inc/mnodeDnode.h @@ -28,7 +28,7 @@ typedef enum { } EDnodeStatus; int32_t mnodeInitDnodes(); -void mgmtCleanupDnodes(); +void mnodeCleanupDnodes(); char* mnodeGetDnodeStatusStr(int32_t dnodeStatus); void mgmtMonitorDnodeModule(); diff --git a/src/mnode/inc/mnodeMnode.h b/src/mnode/inc/mnodeMnode.h index 14ea992206..c75deac594 100644 --- a/src/mnode/inc/mnodeMnode.h +++ b/src/mnode/inc/mnodeMnode.h @@ -29,7 +29,7 @@ typedef enum { } EMnodeStatus; int32_t mnodeInitMnodes(); -void mgmtCleanupMnodes(); +void mnodeCleanupMnodes(); int32_t mnodeAddMnode(int32_t dnodeId); int32_t mnodeDropMnode(int32_t dnodeId); diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c index 1220988221..b904e06e97 100644 --- a/src/mnode/src/mnodeDb.c +++ b/src/mnode/src/mnodeDb.c @@ -381,7 +381,7 @@ bool mnodeCheckIsMonitorDB(char *db, char *monitordb) { } #if 0 -void mgmtPrintVgroups(SDbObj *pDb, char *oper) { +void mnodePrintVgroups(SDbObj *pDb, char *oper) { mPrint("db:%s, vgroup link from head, oper:%s", pDb->name, oper); SVgObj *pVgroup = pDb->pHead; while (pVgroup != NULL) { diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c index c6c0232259..5aaa2049f1 100644 --- a/src/mnode/src/mnodeDnode.c +++ b/src/mnode/src/mnodeDnode.c @@ -169,7 +169,7 @@ int32_t mnodeInitDnodes() { return 0; } -void mgmtCleanupDnodes() { +void mnodeCleanupDnodes() { sdbCloseTable(tsDnodeSdb); } @@ -671,8 +671,8 @@ int32_t mnodeRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pC pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; switch (moduleType) { - case TSDB_MOD_MGMT: - strcpy(pWrite, "mgmt"); + case TSDB_MOD_MNODE: + strcpy(pWrite, "mnode"); break; case TSDB_MOD_HTTP: strcpy(pWrite, "http"); diff --git a/src/mnode/src/mnodeMain.c b/src/mnode/src/mnodeMain.c index f1be6a8a87..ac11947757 100644 --- a/src/mnode/src/mnodeMain.c +++ b/src/mnode/src/mnodeMain.c @@ -43,11 +43,11 @@ static bool mnodeNeedStart() ; int32_t mnodeStartSystem() { if (tsMgmtIsRunning) { - mPrint("TDengine mgmt module already started..."); + mPrint("mnode module already started..."); return 0; } - mPrint("starting to initialize TDengine mgmt ..."); + mPrint("starting to initialize mnode ..."); struct stat dirstat; if (stat(tsMnodeDir, &dirstat) < 0) { mkdir(tsMnodeDir, 0755); @@ -114,7 +114,7 @@ int32_t mnodeStartSystem() { grantReset(TSDB_GRANT_ALL, 0); tsMgmtIsRunning = true; - mPrint("TDengine mgmt is initialized successfully"); + mPrint("mnode is initialized successfully"); return 0; } @@ -126,7 +126,7 @@ int32_t mnodeInitSystem() { } void mnodeCleanupSystem() { - mPrint("starting to clean up mgmt"); + mPrint("starting to clean up mnode"); tsMgmtIsRunning = false; dnodeFreeMnodeWqueue(); @@ -137,24 +137,24 @@ void mnodeCleanupSystem() { grantCleanUp(); balanceCleanUp(); sdbCleanUp(); - mgmtCleanupMnodes(); + mnodeCleanupMnodes(); mnodeCleanupTables(); mnodeCleanupVgroups(); mnodeCleanupDbs(); - mgmtCleanupDnodes(); + mnodeCleanupDnodes(); mnodeCleanupUsers(); mnodeCleanupAccts(); - mPrint("mgmt is cleaned up"); + mPrint("mnode is cleaned up"); } -void mgmtStopSystem() { +void mnodeStopSystem() { if (sdbIsMaster()) { - mTrace("it is a master mgmt node, it could not be stopped"); + mTrace("it is a master mnode, it could not be stopped"); return; } mnodeCleanupSystem(); - mPrint("mgmt file is removed"); + mPrint("mnode file is removed"); remove(tsMnodeDir); } diff --git a/src/mnode/src/mnodeMnode.c b/src/mnode/src/mnodeMnode.c index 3fababf023..151bd69c6d 100644 --- a/src/mnode/src/mnodeMnode.c +++ b/src/mnode/src/mnodeMnode.c @@ -161,7 +161,7 @@ int32_t mnodeInitMnodes() { return TSDB_CODE_SUCCESS; } -void mgmtCleanupMnodes() { +void mnodeCleanupMnodes() { sdbCloseTable(tsMnodeSdb); mnodeMnodeDestroyLock(); } diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c index 1fa7b02a40..4ce8c88281 100644 --- a/src/mnode/src/mnodeTable.c +++ b/src/mnode/src/mnodeTable.c @@ -80,14 +80,14 @@ static int32_t mnodeProcessTableCfgMsg(SMnodeMsg *mnodeMsg); static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *mnodeMsg); static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg); static int32_t mnodeGetChildTableMeta(SMnodeMsg *pMsg); -static int32_t mgmtAutoCreateChildTable(SMnodeMsg *pMsg); +static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg); static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *mnodeMsg); static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg); static int32_t mnodeFindSuperTableColumnIndex(SSuperTableObj *pStable, char *colName); -static void mgmtDestroyChildTable(SChildTableObj *pTable) { +static void mnodeDestroyChildTable(SChildTableObj *pTable) { tfree(pTable->info.tableId); tfree(pTable->schema); tfree(pTable->sql); @@ -95,7 +95,7 @@ static void mgmtDestroyChildTable(SChildTableObj *pTable) { } static int32_t mnodeChildTableActionDestroy(SSdbOper *pOper) { - mgmtDestroyChildTable(pOper->pObj); + mnodeDestroyChildTable(pOper->pObj); return TSDB_CODE_SUCCESS; } @@ -248,7 +248,7 @@ static int32_t mnodeChildTableActionDecode(SSdbOper *pOper) { int32_t schemaSize = pTable->numOfColumns * sizeof(SSchema); pTable->schema = (SSchema *)malloc(schemaSize); if (pTable->schema == NULL) { - mgmtDestroyChildTable(pTable); + mnodeDestroyChildTable(pTable); return TSDB_CODE_INVALID_TABLE_TYPE; } memcpy(pTable->schema, pOper->rowData + len, schemaSize); @@ -257,7 +257,7 @@ static int32_t mnodeChildTableActionDecode(SSdbOper *pOper) { if (pTable->sqlLen != 0) { pTable->sql = malloc(pTable->sqlLen); if (pTable->sql == NULL) { - mgmtDestroyChildTable(pTable); + mnodeDestroyChildTable(pTable); return TSDB_CODE_SERV_OUT_OF_MEMORY; } memcpy(pTable->sql, pOper->rowData + len, pTable->sqlLen); @@ -395,7 +395,7 @@ static void mnodeRemoveTableFromStable(SSuperTableObj *pStable, SChildTableObj * mnodeDecVgroupRef(pVgroup); } -static void mgmtDestroySuperTable(SSuperTableObj *pStable) { +static void mnodeDestroySuperTable(SSuperTableObj *pStable) { if (pStable->vgHash != NULL) { taosHashCleanup(pStable->vgHash); pStable->vgHash = NULL; @@ -406,7 +406,7 @@ static void mgmtDestroySuperTable(SSuperTableObj *pStable) { } static int32_t mnodeSuperTableActionDestroy(SSdbOper *pOper) { - mgmtDestroySuperTable(pOper->pObj); + mnodeDestroySuperTable(pOper->pObj); return TSDB_CODE_SUCCESS; } @@ -489,7 +489,7 @@ static int32_t mnodeSuperTableActionDecode(SSdbOper *pOper) { int32_t schemaSize = sizeof(SSchema) * (pStable->numOfColumns + pStable->numOfTags); pStable->schema = malloc(schemaSize); if (pStable->schema == NULL) { - mgmtDestroySuperTable(pStable); + mnodeDestroySuperTable(pStable); return TSDB_CODE_NOT_SUPER_TABLE; } @@ -646,7 +646,7 @@ void mnodeCleanupTables() { } // todo move to name.h, add length of table name -static void mgmtExtractTableName(char* tableId, char* name) { +static void mnodeExtractTableName(char* tableId, char* name) { int pos = -1; int num = 0; for (pos = 0; tableId[pos] != 0; ++pos) { @@ -742,7 +742,7 @@ static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *pMsg) { return TSDB_CODE_INVALID_TABLE; } else { mTrace("table:%s, failed to get table meta, start auto create table ", pInfo->tableId); - return mgmtAutoCreateChildTable(pMsg); + return mnodeAutoCreateChildTable(pMsg); } } else { if (pMsg->pTable->type != TSDB_SUPER_TABLE) { @@ -799,7 +799,7 @@ static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) { int32_t code = sdbInsertRow(&oper); if (code != TSDB_CODE_SUCCESS) { - mgmtDestroySuperTable(pStable); + mnodeDestroySuperTable(pStable); mError("table:%s, failed to create, sdb error", pCreate->tableId); return TSDB_CODE_SDB_ERROR; } else { @@ -821,7 +821,7 @@ static int32_t mnodeProcessDropSuperTableMsg(SMnodeMsg *pMsg) { pDrop->contLen = htonl(sizeof(SMDDropSTableMsg)); pDrop->vgId = htonl(pVgroup->vgId); pDrop->uid = htobe64(pStable->uid); - mgmtExtractTableName(pStable->info.tableId, pDrop->tableId); + mnodeExtractTableName(pStable->info.tableId, pDrop->tableId); mPrint("stable:%s, send drop stable msg to vgId:%d", pStable->info.tableId, pVgroup->vgId); SRpcIpSet ipSet = mnodeGetIpSetFromVgroup(pVgroup); @@ -1146,7 +1146,7 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, } memset(stableName, 0, tListLen(stableName)); - mgmtExtractTableName(pTable->info.tableId, stableName); + mnodeExtractTableName(pTable->info.tableId, stableName); if (pShow->payloadLen > 0 && patternMatch(pShow->payload, stableName, TSDB_TABLE_NAME_LEN, &info) != TSDB_PATTERN_MATCH) { mnodeDecTableRef(pTable); @@ -1325,7 +1325,7 @@ static void mnodeProcessDropSuperTableRsp(SRpcMsg *rpcMsg) { mPrint("drop stable rsp received, result:%s", tstrerror(rpcMsg->code)); } -static void *mgmtBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SChildTableObj *pTable) { +static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SChildTableObj *pTable) { STagData * pTagData = NULL; int32_t tagDataLen = 0; int32_t totalCols = 0; @@ -1346,7 +1346,7 @@ static void *mgmtBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SChildTableOb return NULL; } - mgmtExtractTableName(pTable->info.tableId, pCreate->tableId); + mnodeExtractTableName(pTable->info.tableId, pCreate->tableId); pCreate->contLen = htonl(contLen); pCreate->vgId = htonl(pTable->vgId); pCreate->tableType = pTable->info.type; @@ -1356,7 +1356,7 @@ static void *mgmtBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SChildTableOb pCreate->uid = htobe64(pTable->uid); if (pTable->info.type == TSDB_CHILD_TABLE) { - mgmtExtractTableName(pTable->superTable->info.tableId, pCreate->superTableId); + mnodeExtractTableName(pTable->superTable->info.tableId, pCreate->superTableId); pCreate->numOfColumns = htons(pTable->superTable->numOfColumns); pCreate->numOfTags = htons(pTable->superTable->numOfTags); pCreate->sversion = htonl(pTable->superTable->sversion); @@ -1516,7 +1516,7 @@ static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) { return terrno; } - SMDCreateTableMsg *pMDCreate = mgmtBuildCreateChildTableMsg(pCreate, (SChildTableObj *) pMsg->pTable); + SMDCreateTableMsg *pMDCreate = mnodeBuildCreateChildTableMsg(pCreate, (SChildTableObj *) pMsg->pTable); if (pMDCreate == NULL) { return terrno; } @@ -1723,7 +1723,7 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) { return TSDB_CODE_SUCCESS; } -static int32_t mgmtAutoCreateChildTable(SMnodeMsg *pMsg) { +static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg) { SCMTableInfoMsg *pInfo = pMsg->rpcMsg.pCont; STagData* pTag = (STagData*)pInfo->tags; @@ -1879,7 +1879,7 @@ static int32_t mnodeProcessTableCfgMsg(SMnodeMsg *pMsg) { } SMDCreateTableMsg *pMDCreate = NULL; - pMDCreate = mgmtBuildCreateChildTableMsg(NULL, (SChildTableObj *) pTable); + pMDCreate = mnodeBuildCreateChildTableMsg(NULL, (SChildTableObj *) pTable); if (pMDCreate == NULL) { mnodeDecTableRef(pTable); return terrno; @@ -2098,7 +2098,7 @@ static int32_t mnodeGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void return 0; } -static void mgmtVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_t capacity, SShowObj *pShow) { +static 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); @@ -2132,7 +2132,7 @@ static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows char tableName[TSDB_TABLE_NAME_LEN + 1] = {0}; // pattern compare for table name - mgmtExtractTableName(pTable->info.tableId, tableName); + mnodeExtractTableName(pTable->info.tableId, tableName); if (pShow->payloadLen > 0 && patternMatch(pShow->payload, tableName, TSDB_TABLE_NAME_LEN, &info) != TSDB_PATTERN_MATCH) { mnodeDecTableRef(pTable); @@ -2163,7 +2163,7 @@ static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows memset(tableName, 0, tListLen(tableName)); if (pTable->info.type == TSDB_CHILD_TABLE) { - mgmtExtractTableName(pTable->superTable->info.tableId, tableName); + mnodeExtractTableName(pTable->superTable->info.tableId, tableName); STR_WITH_MAXSIZE_TO_VARSTR(pWrite, tableName, TSDB_TABLE_NAME_LEN); } @@ -2176,7 +2176,7 @@ static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows pShow->numOfReads += numOfRows; const int32_t NUM_OF_COLUMNS = 4; - mgmtVacuumResult(data, NUM_OF_COLUMNS, numOfRows, rows, pShow); + mnodeVacuumResult(data, NUM_OF_COLUMNS, numOfRows, rows, pShow); mnodeDecDbRef(pDb); return numOfRows; diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c index 36e96dd006..c8ff6566b6 100644 --- a/src/mnode/src/mnodeVgroup.c +++ b/src/mnode/src/mnodeVgroup.c @@ -284,7 +284,7 @@ void mnodeUpdateVgroupStatus(SVgObj *pVgroup, SDnodeObj *pDnode, SVnodeLoad *pVl } if (pVload->cfgVersion != pVgroup->pDb->cfgVersion || pVload->replica != pVgroup->numOfVnodes) { - mError("dnode:%d, vgId:%d, vnode cfgVersion:%d repica:%d not match with mgmt cfgVersion:%d replica:%d", + mError("dnode:%d, vgId:%d, vnode cfgVersion:%d repica:%d not match with mnode cfgVersion:%d replica:%d", pDnode->dnodeId, pVload->vgId, pVload->cfgVersion, pVload->replica, pVgroup->pDb->cfgVersion, pVgroup->numOfVnodes); mnodeSendCreateVgroupMsg(pVgroup, NULL); @@ -532,7 +532,7 @@ void mnodeRemoveTableFromVgroup(SVgObj *pVgroup, SChildTableObj *pTable) { mnodeDecVgroupRef(pVgroup); } -SMDCreateVnodeMsg *mgmtBuildCreateVnodeMsg(SVgObj *pVgroup) { +SMDCreateVnodeMsg *mnodeBuildCreateVnodeMsg(SVgObj *pVgroup) { SDbObj *pDb = pVgroup->pDb; if (pDb == NULL) return NULL; @@ -595,7 +595,7 @@ SRpcIpSet mnodeGetIpSetFromIp(char *ep) { void mnodeSendCreateVnodeMsg(SVgObj *pVgroup, SRpcIpSet *ipSet, void *ahandle) { mTrace("vgId:%d, send create vnode:%d msg, ahandle:%p", pVgroup->vgId, pVgroup->vgId, ahandle); - SMDCreateVnodeMsg *pCreate = mgmtBuildCreateVnodeMsg(pVgroup); + SMDCreateVnodeMsg *pCreate = mnodeBuildCreateVnodeMsg(pVgroup); SRpcMsg rpcMsg = { .handle = ahandle, .pCont = pCreate, @@ -648,7 +648,7 @@ static void mnodeProcessCreateVnodeRsp(SRpcMsg *rpcMsg) { } } -static SMDDropVnodeMsg *mgmtBuildDropVnodeMsg(int32_t vgId) { +static SMDDropVnodeMsg *mnodeBuildDropVnodeMsg(int32_t vgId) { SMDDropVnodeMsg *pDrop = rpcMallocCont(sizeof(SMDDropVnodeMsg)); if (pDrop == NULL) return NULL; @@ -657,7 +657,7 @@ static SMDDropVnodeMsg *mgmtBuildDropVnodeMsg(int32_t vgId) { } void mnodeSendDropVnodeMsg(int32_t vgId, SRpcIpSet *ipSet, void *ahandle) { - SMDDropVnodeMsg *pDrop = mgmtBuildDropVnodeMsg(vgId); + SMDDropVnodeMsg *pDrop = mnodeBuildDropVnodeMsg(vgId); SRpcMsg rpcMsg = { .handle = ahandle, .pCont = pDrop, diff --git a/tests/pytest/util/dnodes.py b/tests/pytest/util/dnodes.py index e9f0dad076..998c996ca2 100644 --- a/tests/pytest/util/dnodes.py +++ b/tests/pytest/util/dnodes.py @@ -159,7 +159,7 @@ class TDDnode: self.cfg("dataDir", self.dataDir) self.cfg("logDir", self.logDir) self.cfg("numOfLogLines", "100000000") - self.cfg("mgmtEqualVnodeNum", "0") + self.cfg("mnodeEqualVnodeNum", "0") self.cfg("clog", "1") self.cfg("statusInterval", "1") self.cfg("numOfTotalVnodes", "64") diff --git a/tests/script/general/alter/count.sim b/tests/script/general/alter/count.sim index a42fde74b7..11b2f6e244 100644 --- a/tests/script/general/alter/count.sim +++ b/tests/script/general/alter/count.sim @@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1 system sh/cfg.sh -n dnode1 -c wallevel -v 0 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 print ========= start dnode1 as master system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/alter/import.sim b/tests/script/general/alter/import.sim index 6129765513..801e716e8c 100644 --- a/tests/script/general/alter/import.sim +++ b/tests/script/general/alter/import.sim @@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1 system sh/cfg.sh -n dnode1 -c wallevel -v 0 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 print ========= start dnode1 as master system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/db/backup/keep.sim b/tests/script/general/db/backup/keep.sim index 4899acdd21..f48ce0e414 100644 --- a/tests/script/general/db/backup/keep.sim +++ b/tests/script/general/db/backup/keep.sim @@ -12,9 +12,9 @@ system sh/cfg.sh -n dnode3 -c walLevel -v 0 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 print ========= start dnode1 as master system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/db/delete_reuse1.sim b/tests/script/general/db/delete_reuse1.sim index 1e4baeb576..75a4cfaff0 100644 --- a/tests/script/general/db/delete_reuse1.sim +++ b/tests/script/general/db/delete_reuse1.sim @@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/general/db/delete_reuse2.sim b/tests/script/general/db/delete_reuse2.sim index d2fcaad838..103242ee1b 100644 --- a/tests/script/general/db/delete_reuse2.sim +++ b/tests/script/general/db/delete_reuse2.sim @@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/general/db/delete_writing1.sim b/tests/script/general/db/delete_writing1.sim index 58fe68dd5f..01914e91a8 100644 --- a/tests/script/general/db/delete_writing1.sim +++ b/tests/script/general/db/delete_writing1.sim @@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/general/import/basic.sim b/tests/script/general/import/basic.sim index 2b72d55cda..b6e064c845 100644 --- a/tests/script/general/import/basic.sim +++ b/tests/script/general/import/basic.sim @@ -9,10 +9,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 10 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000 diff --git a/tests/script/general/import/commit.sim b/tests/script/general/import/commit.sim index 64833fcd61..93bd93cf21 100644 --- a/tests/script/general/import/commit.sim +++ b/tests/script/general/import/commit.sim @@ -9,10 +9,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 10 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000 diff --git a/tests/script/general/import/large.sim b/tests/script/general/import/large.sim index 6f6889a226..751eef785b 100644 --- a/tests/script/general/import/large.sim +++ b/tests/script/general/import/large.sim @@ -9,10 +9,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 10 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000 diff --git a/tests/script/general/import/replica1.sim b/tests/script/general/import/replica1.sim index 61f563ba8e..771f2a8cbb 100644 --- a/tests/script/general/import/replica1.sim +++ b/tests/script/general/import/replica1.sim @@ -10,10 +10,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 10 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000 diff --git a/tests/script/general/table/delete_reuse1.sim b/tests/script/general/table/delete_reuse1.sim index 94f5bdb287..4727796a62 100644 --- a/tests/script/general/table/delete_reuse1.sim +++ b/tests/script/general/table/delete_reuse1.sim @@ -14,10 +14,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/general/table/delete_reuse2.sim b/tests/script/general/table/delete_reuse2.sim index 1a9c80cff0..9dfc0c5d4e 100644 --- a/tests/script/general/table/delete_reuse2.sim +++ b/tests/script/general/table/delete_reuse2.sim @@ -14,10 +14,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/general/table/delete_writing.sim b/tests/script/general/table/delete_writing.sim index 73d028928f..ac056f2212 100644 --- a/tests/script/general/table/delete_writing.sim +++ b/tests/script/general/table/delete_writing.sim @@ -14,10 +14,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/sh/clear.sh b/tests/script/sh/clear.sh index 714ff43580..3be31d15f9 100755 --- a/tests/script/sh/clear.sh +++ b/tests/script/sh/clear.sh @@ -106,7 +106,7 @@ echo "monitor 0" >> $TAOS_CFG echo "numOfThreadsPerCore 2.0" >> $TAOS_CFG echo "defaultPass taosdata" >> $TAOS_CFG echo "numOfLogLines 100000000" >> $TAOS_CFG -echo "mgmtEqualVnodeNum 0" >> $TAOS_CFG +echo "mnodeEqualVnodeNum 0" >> $TAOS_CFG echo "clog 0" >> $TAOS_CFG echo "statusInterval 1" >> $TAOS_CFG echo "numOfTotalVnodes 4" >> $TAOS_CFG diff --git a/tests/script/sh/deploy.sh b/tests/script/sh/deploy.sh index b3134938cb..f8e123369f 100755 --- a/tests/script/sh/deploy.sh +++ b/tests/script/sh/deploy.sh @@ -115,7 +115,7 @@ echo "http 0" >> $TAOS_CFG echo "numOfThreadsPerCore 2.0" >> $TAOS_CFG echo "defaultPass taosdata" >> $TAOS_CFG echo "numOfLogLines 100000000" >> $TAOS_CFG -echo "mgmtEqualVnodeNum 0" >> $TAOS_CFG +echo "mnodeEqualVnodeNum 0" >> $TAOS_CFG echo "clog 2" >> $TAOS_CFG echo "statusInterval 1" >> $TAOS_CFG echo "numOfTotalVnodes 4" >> $TAOS_CFG diff --git a/tests/script/tmp/prepare.sim b/tests/script/tmp/prepare.sim index 1db643c5c9..be9e255eb8 100644 --- a/tests/script/tmp/prepare.sim +++ b/tests/script/tmp/prepare.sim @@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/unique/cluster/balance1.sim b/tests/script/unique/cluster/balance1.sim index 424a80d25a..9130493a93 100644 --- a/tests/script/unique/cluster/balance1.sim +++ b/tests/script/unique/cluster/balance1.sim @@ -26,14 +26,14 @@ system sh/cfg.sh -n dnode6 -c numOfMpeers -v 3 system sh/cfg.sh -n dnode7 -c numOfMpeers -v 3 system sh/cfg.sh -n dnode8 -c numOfMpeers -v 3 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode5 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode6 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode7 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode8 -c mgmtEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode5 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode6 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode7 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode8 -c mnodeEqualVnodeNum -v 0 system sh/cfg.sh -n dnode1 -c wallevel -v 1 system sh/cfg.sh -n dnode2 -c wallevel -v 1 diff --git a/tests/script/unique/cluster/balance2.sim b/tests/script/unique/cluster/balance2.sim index 08fdd233e0..56c0d538b6 100644 --- a/tests/script/unique/cluster/balance2.sim +++ b/tests/script/unique/cluster/balance2.sim @@ -35,14 +35,14 @@ system sh/cfg.sh -n dnode6 -c wallevel -v 1 system sh/cfg.sh -n dnode7 -c wallevel -v 1 system sh/cfg.sh -n dnode8 -c wallevel -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode5 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode6 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode7 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode8 -c mgmtEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode5 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode6 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode7 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode8 -c mnodeEqualVnodeNum -v 0 print ============== step1 print ========= start dnode1 diff --git a/tests/script/unique/cluster/balance3.sim b/tests/script/unique/cluster/balance3.sim index 407adc7f3b..346f027526 100644 --- a/tests/script/unique/cluster/balance3.sim +++ b/tests/script/unique/cluster/balance3.sim @@ -27,14 +27,14 @@ system sh/cfg.sh -n dnode6 -c numOfMpeers -v 3 system sh/cfg.sh -n dnode7 -c numOfMpeers -v 3 system sh/cfg.sh -n dnode8 -c numOfMpeers -v 3 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode5 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode6 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode7 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode8 -c mgmtEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode5 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode6 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode7 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode8 -c mnodeEqualVnodeNum -v 0 system sh/cfg.sh -n dnode1 -c wallevel -v 1 system sh/cfg.sh -n dnode2 -c wallevel -v 1 diff --git a/tests/script/unique/db/commit.sim b/tests/script/unique/db/commit.sim index 5bf6ea6f10..95a6b92bb2 100644 --- a/tests/script/unique/db/commit.sim +++ b/tests/script/unique/db/commit.sim @@ -9,9 +9,9 @@ system sh/cfg.sh -n dnode3 -c walLevel -v 2 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 print ========= start dnode1 as master system sh/exec_up.sh -n dnode1 -s start diff --git a/tests/script/unique/db/delete_part.sim b/tests/script/unique/db/delete_part.sim index 179d729d8d..1bd103137b 100644 --- a/tests/script/unique/db/delete_part.sim +++ b/tests/script/unique/db/delete_part.sim @@ -14,10 +14,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/unique/db/replica_add12.sim b/tests/script/unique/db/replica_add12.sim index b0de807fca..ce7121db2e 100644 --- a/tests/script/unique/db/replica_add12.sim +++ b/tests/script/unique/db/replica_add12.sim @@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/unique/db/replica_add13.sim b/tests/script/unique/db/replica_add13.sim index 9f66faab0a..b2bfef2b58 100644 --- a/tests/script/unique/db/replica_add13.sim +++ b/tests/script/unique/db/replica_add13.sim @@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/unique/db/replica_add23.sim b/tests/script/unique/db/replica_add23.sim index 2d293183af..6df09d0cac 100644 --- a/tests/script/unique/db/replica_add23.sim +++ b/tests/script/unique/db/replica_add23.sim @@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/unique/db/replica_part.sim b/tests/script/unique/db/replica_part.sim index 76e3eaabbe..6a41c430ea 100644 --- a/tests/script/unique/db/replica_part.sim +++ b/tests/script/unique/db/replica_part.sim @@ -10,9 +10,9 @@ system sh/cfg.sh -n dnode3 -c wallevel -v 2 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode3 -c numOfTotalVnodes -v 4 diff --git a/tests/script/unique/db/replica_reduce21.sim b/tests/script/unique/db/replica_reduce21.sim index 3a324c604a..931382d8c4 100644 --- a/tests/script/unique/db/replica_reduce21.sim +++ b/tests/script/unique/db/replica_reduce21.sim @@ -10,9 +10,9 @@ system sh/cfg.sh -n dnode3 -c wallevel -v 2 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode3 -c numOfTotalVnodes -v 4 diff --git a/tests/script/unique/db/replica_reduce31.sim b/tests/script/unique/db/replica_reduce31.sim index fdb5e3c1dc..22c89d91b9 100644 --- a/tests/script/unique/db/replica_reduce31.sim +++ b/tests/script/unique/db/replica_reduce31.sim @@ -10,9 +10,9 @@ system sh/cfg.sh -n dnode3 -c wallevel -v 2 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode3 -c numOfTotalVnodes -v 4 diff --git a/tests/script/unique/db/replica_reduce32.sim b/tests/script/unique/db/replica_reduce32.sim index 83b5cb7a5b..54069cb133 100644 --- a/tests/script/unique/db/replica_reduce32.sim +++ b/tests/script/unique/db/replica_reduce32.sim @@ -10,9 +10,9 @@ system sh/cfg.sh -n dnode3 -c wallevel -v 2 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode3 -c numOfTotalVnodes -v 4 diff --git a/tests/script/unique/dnode/balance1.sim b/tests/script/unique/dnode/balance1.sim index 9a598e1704..a6be723d7c 100644 --- a/tests/script/unique/dnode/balance1.sim +++ b/tests/script/unique/dnode/balance1.sim @@ -10,10 +10,10 @@ system sh/cfg.sh -n dnode2 -c balanceInterval -v 10 system sh/cfg.sh -n dnode3 -c balanceInterval -v 10 system sh/cfg.sh -n dnode4 -c balanceInterval -v 10 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c wallevel -v 2 system sh/cfg.sh -n dnode2 -c wallevel -v 2 diff --git a/tests/script/unique/dnode/balance2.sim b/tests/script/unique/dnode/balance2.sim index f039579012..c60ac14517 100644 --- a/tests/script/unique/dnode/balance2.sim +++ b/tests/script/unique/dnode/balance2.sim @@ -6,11 +6,11 @@ system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 system sh/deploy.sh -n dnode5 -i 5 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode5 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode5 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c wallevel -v 1 system sh/cfg.sh -n dnode2 -c wallevel -v 1 diff --git a/tests/script/unique/dnode/balance3.sim b/tests/script/unique/dnode/balance3.sim index acb0d033d4..f0bf0c7c2b 100644 --- a/tests/script/unique/dnode/balance3.sim +++ b/tests/script/unique/dnode/balance3.sim @@ -7,12 +7,12 @@ system sh/deploy.sh -n dnode4 -i 4 system sh/deploy.sh -n dnode5 -i 5 system sh/deploy.sh -n dnode6 -i 6 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode5 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode6 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode5 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode6 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c wallevel -v 1 system sh/cfg.sh -n dnode2 -c wallevel -v 1 diff --git a/tests/script/unique/dnode/balancex.sim b/tests/script/unique/dnode/balancex.sim index 202c9b5396..14b0982678 100644 --- a/tests/script/unique/dnode/balancex.sim +++ b/tests/script/unique/dnode/balancex.sim @@ -5,10 +5,10 @@ system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c wallevel -v 1 system sh/cfg.sh -n dnode2 -c wallevel -v 1 diff --git a/tests/script/unique/dnode/monitor_bug.sim b/tests/script/unique/dnode/monitor_bug.sim index 8726caf1db..a20185240f 100644 --- a/tests/script/unique/dnode/monitor_bug.sim +++ b/tests/script/unique/dnode/monitor_bug.sim @@ -3,8 +3,8 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c wallevel -v 1 system sh/cfg.sh -n dnode2 -c wallevel -v 1 diff --git a/tests/script/unique/dnode/offline1.sim b/tests/script/unique/dnode/offline1.sim index 5e4ab65be3..9d068e8358 100644 --- a/tests/script/unique/dnode/offline1.sim +++ b/tests/script/unique/dnode/offline1.sim @@ -12,9 +12,9 @@ system sh/cfg.sh -n dnode1 -c balanceInterval -v 5 system sh/cfg.sh -n dnode2 -c balanceInterval -v 5 system sh/cfg.sh -n dnode3 -c balanceInterval -v 5 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c wallevel -v 1 system sh/cfg.sh -n dnode2 -c wallevel -v 1 diff --git a/tests/script/unique/dnode/offline2.sim b/tests/script/unique/dnode/offline2.sim index 9d8ba8bf9d..e9c1218e1f 100644 --- a/tests/script/unique/dnode/offline2.sim +++ b/tests/script/unique/dnode/offline2.sim @@ -12,9 +12,9 @@ system sh/cfg.sh -n dnode1 -c balanceInterval -v 5 system sh/cfg.sh -n dnode2 -c balanceInterval -v 5 system sh/cfg.sh -n dnode3 -c balanceInterval -v 5 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c wallevel -v 1 system sh/cfg.sh -n dnode2 -c wallevel -v 1 diff --git a/tests/script/unique/dnode/remove1.sim b/tests/script/unique/dnode/remove1.sim index 6b23014b03..2eb1fe4ae7 100644 --- a/tests/script/unique/dnode/remove1.sim +++ b/tests/script/unique/dnode/remove1.sim @@ -5,10 +5,10 @@ system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c wallevel -v 1 system sh/cfg.sh -n dnode2 -c wallevel -v 1 diff --git a/tests/script/unique/dnode/remove2.sim b/tests/script/unique/dnode/remove2.sim index 42cb9e5485..db77a8e05d 100644 --- a/tests/script/unique/dnode/remove2.sim +++ b/tests/script/unique/dnode/remove2.sim @@ -5,10 +5,10 @@ system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c wallevel -v 2 system sh/cfg.sh -n dnode2 -c wallevel -v 2 diff --git a/tests/script/unique/dnode/vnode_clean.sim b/tests/script/unique/dnode/vnode_clean.sim index d46e1a751e..d42fbf4e2d 100644 --- a/tests/script/unique/dnode/vnode_clean.sim +++ b/tests/script/unique/dnode/vnode_clean.sim @@ -5,10 +5,10 @@ system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c wallevel -v 1 system sh/cfg.sh -n dnode2 -c wallevel -v 1 diff --git a/tests/script/unique/import/replica2.sim b/tests/script/unique/import/replica2.sim index 70097a5022..3f21fcf00d 100644 --- a/tests/script/unique/import/replica2.sim +++ b/tests/script/unique/import/replica2.sim @@ -10,10 +10,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 10 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000 diff --git a/tests/script/unique/import/replica3.sim b/tests/script/unique/import/replica3.sim index ad236bfb0c..8eb2df9942 100644 --- a/tests/script/unique/import/replica3.sim +++ b/tests/script/unique/import/replica3.sim @@ -10,10 +10,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 10 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 10 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 10 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000 diff --git a/tests/script/unique/stable/balance_replica1.sim b/tests/script/unique/stable/balance_replica1.sim index 9257ba79be..4269c2fc7f 100644 --- a/tests/script/unique/stable/balance_replica1.sim +++ b/tests/script/unique/stable/balance_replica1.sim @@ -9,8 +9,8 @@ system sh/cfg.sh -n dnode1 -c balanceInterval -v 10 system sh/cfg.sh -n dnode2 -c balanceInterval -v 10 system sh/cfg.sh -n dnode1 -c walLevel -v 2 system sh/cfg.sh -n dnode2 -c walLevel -v 2 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 0 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 diff --git a/tests/script/unique/stream/metrics_balance.sim b/tests/script/unique/stream/metrics_balance.sim index e711baf206..6ca5de96f6 100644 --- a/tests/script/unique/stream/metrics_balance.sim +++ b/tests/script/unique/stream/metrics_balance.sim @@ -12,8 +12,8 @@ system sh/cfg.sh -n dnode1 -c balanceInterval -v 10 system sh/cfg.sh -n dnode2 -c balanceInterval -v 10 system sh/cfg.sh -n dnode1 -c walLevel -v 0 system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 0 system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxTablesPerVnode -v 4 system sh/cfg.sh -n dnode1 -c tableMetaKeepTimer -v 5 diff --git a/tests/script/unique/stream/table_balance.sim b/tests/script/unique/stream/table_balance.sim index 7e33005b9b..9cb87557d1 100644 --- a/tests/script/unique/stream/table_balance.sim +++ b/tests/script/unique/stream/table_balance.sim @@ -12,8 +12,8 @@ system sh/cfg.sh -n dnode1 -c balanceInterval -v 10 system sh/cfg.sh -n dnode2 -c balanceInterval -v 10 system sh/cfg.sh -n dnode1 -c walLevel -v 0 system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 0 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode1 -c numOfMPeers -v 2 diff --git a/tests/script/unique/stream/table_move.sim b/tests/script/unique/stream/table_move.sim index 54cd3195db..41fbcae4ce 100644 --- a/tests/script/unique/stream/table_move.sim +++ b/tests/script/unique/stream/table_move.sim @@ -30,10 +30,10 @@ system sh/cfg.sh -n dnode2 -c wallevel -v 1 system sh/cfg.sh -n dnode3 -c wallevel -v 1 system sh/cfg.sh -n dnode4 -c wallevel -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 0 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 0 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 0 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 diff --git a/tests/script/unique/vnode/many.sim b/tests/script/unique/vnode/many.sim index bb3e8813bd..2b4ec01c2d 100644 --- a/tests/script/unique/vnode/many.sim +++ b/tests/script/unique/vnode/many.sim @@ -12,10 +12,10 @@ system sh/cfg.sh -n dnode1 -c numofMpeers -v 1 system sh/cfg.sh -n dnode2 -c numofMpeers -v 1 system sh/cfg.sh -n dnode3 -c numofMpeers -v 1 system sh/cfg.sh -n dnode4 -c numofMpeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode3 -c numOfTotalVnodes -v 4 diff --git a/tests/script/unique/vnode/replica2_basic2.sim b/tests/script/unique/vnode/replica2_basic2.sim index 041db8249a..114ac9b29f 100644 --- a/tests/script/unique/vnode/replica2_basic2.sim +++ b/tests/script/unique/vnode/replica2_basic2.sim @@ -15,10 +15,10 @@ system sh/cfg.sh -n dnode2 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode3 -c numOfMPeers -v 1 system sh/cfg.sh -n dnode4 -c numOfMPeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 diff --git a/tests/script/unique/vnode/replica2_repeat.sim b/tests/script/unique/vnode/replica2_repeat.sim index a6bd226484..57f51316ad 100644 --- a/tests/script/unique/vnode/replica2_repeat.sim +++ b/tests/script/unique/vnode/replica2_repeat.sim @@ -12,10 +12,10 @@ system sh/cfg.sh -n dnode1 -c numofMpeers -v 1 system sh/cfg.sh -n dnode2 -c numofMpeers -v 1 system sh/cfg.sh -n dnode3 -c numofMpeers -v 1 system sh/cfg.sh -n dnode4 -c numofMpeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/exec_up.sh -n dnode1 -s start sql connect diff --git a/tests/script/unique/vnode/replica3_repeat.sim b/tests/script/unique/vnode/replica3_repeat.sim index 2f311a5d7a..a6f423bf9a 100644 --- a/tests/script/unique/vnode/replica3_repeat.sim +++ b/tests/script/unique/vnode/replica3_repeat.sim @@ -12,10 +12,10 @@ system sh/cfg.sh -n dnode1 -c numofMpeers -v 1 system sh/cfg.sh -n dnode2 -c numofMpeers -v 1 system sh/cfg.sh -n dnode3 -c numofMpeers -v 1 system sh/cfg.sh -n dnode4 -c numofMpeers -v 1 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 4 -system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 4 +system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 4 system sh/exec_up.sh -n dnode1 -s start From 0b4a5b130fc069caae2a625096328046fa689a2d Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 10:17:38 +0000 Subject: [PATCH 14/17] [TD-354] add sql parser for stream table --- src/inc/taosdef.h | 1 + src/mnode/src/mnodeProfile.c | 137 +++-------------------------------- src/mnode/src/mnodeShow.c | 66 ++++++++++------- src/mnode/src/mnodeTable.c | 131 +++++++++++++++++++++++++++++++-- src/vnode/src/vnodeWrite.c | 7 +- 5 files changed, 179 insertions(+), 163 deletions(-) diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h index ce50fcbcf0..b2bfe7c590 100644 --- a/src/inc/taosdef.h +++ b/src/inc/taosdef.h @@ -203,6 +203,7 @@ void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size); #define TSDB_COL_NAME_LEN 64 #define TSDB_MAX_SAVED_SQL_LEN TSDB_MAX_COLUMNS * 64 #define TSDB_MAX_SQL_LEN TSDB_PAYLOAD_SIZE +#define TSDB_MAX_SQL_SHOW_LEN 256 #define TSDB_MAX_ALLOWED_SQL_LEN (8*1024*1024U) // sql length should be less than 6mb #define TSDB_MAX_BYTES_PER_ROW TSDB_MAX_COLUMNS * 64 diff --git a/src/mnode/src/mnodeProfile.c b/src/mnode/src/mnodeProfile.c index 4cb560e066..a37f5436c6 100644 --- a/src/mnode/src/mnodeProfile.c +++ b/src/mnode/src/mnodeProfile.c @@ -346,123 +346,6 @@ int32_t mnodeGetStreams(SShowObj *pShow, void *pConn) { return 0; } -int32_t mnodeGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { - int32_t cols = 0; - SSchema *pSchema = pMeta->schema; - - pShow->bytes[cols] = TSDB_USER_LEN; - 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 + 14; - pSchema[cols].type = TSDB_DATA_TYPE_BINARY; - strcpy(pSchema[cols].name, "ip:port:id"); - 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_INT; - strcpy(pSchema[cols].name, "time(us)"); - pSchema[cols].bytes = htons(pShow->bytes[cols]); - cols++; - - pShow->bytes[cols] = TSDB_SHOW_SQL_LEN; - 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->pIter = NULL; - pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; - - mnodeGetStreams(pShow, pConn); - return 0; -} - -int32_t mnodeRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn) { - int32_t numOfRows = 0; - char *pWrite; - int32_t cols = 0; - - SStreamShow *pStreamShow = (SStreamShow *)pShow->pIter; - - if (rows > pStreamShow->numOfStreams - pStreamShow->index) rows = pStreamShow->numOfStreams - pStreamShow->index; - - while (numOfRows < rows) { - SStreamDesc *pNode = pStreamShow->sdesc + pStreamShow->index; - SCDesc *pCDesc = pStreamShow->cdesc[pStreamShow->index]; - cols = 0; - - pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - strcpy(pWrite, pCDesc->user); - cols++; - - pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - uint32_t ip = pCDesc->ip; - sprintf(pWrite, "%d.%d.%d.%d:%hu:%d", ip & 0xFF, (ip >> 8) & 0xFF, (ip >> 16) & 0xFF, ip >> 24, htons(pCDesc->port), - pNode->streamId); - cols++; - - pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - *(int64_t *)pWrite = pNode->ctime; - cols++; - - pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - *(int64_t *)pWrite = pNode->stime; - cols++; - - pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - *(int64_t *)pWrite = pNode->useconds; - cols++; - - pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - strcpy(pWrite, pNode->sql); - cols++; - - pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - *(int32_t *)pWrite = pNode->num; - cols++; - - numOfRows++; - pStreamShow->index++; - } - - if (numOfRows == 0) { - tfree(pStreamShow->cdesc); - tfree(pStreamShow->connInfo); - tfree(pStreamShow); - } - - pShow->numOfReads += numOfRows; - return numOfRows; -} int32_t mnodeKillStream(char *qidstr, void *pConn) { // char *temp, *chr, idstr[64]; @@ -750,18 +633,16 @@ int32_t mnodeProcessKillConnectionMsg(SMnodeMsg *pMsg) { } int32_t mnodeInitProfile() { - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mnodeGetQueryMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mnodeRetrieveQueries); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mnodeGetConnsMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mnodeRetrieveConns); - mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_STREAMS, mnodeGetStreamMeta); - mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMS, mnodeRetrieveStreams); - mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mnodeProcessKillQueryMsg); - mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mnodeProcessKillStreamMsg); - mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_CONN, mnodeProcessKillConnectionMsg); + // mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_QUERIES, mnodeGetQueryMeta); + // mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_QUERIES, mnodeRetrieveQueries); + // mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_CONNS, mnodeGetConnsMeta); + // mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_CONNS, mnodeRetrieveConns); + + // mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_QUERY, mnodeProcessKillQueryMsg); + // mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_STREAM, mnodeProcessKillStreamMsg); + // mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_KILL_CONN, mnodeProcessKillConnectionMsg); return 0; } -void mnodeCleanupProfile() { -} +void mnodeCleanupProfile() {} diff --git a/src/mnode/src/mnodeShow.c b/src/mnode/src/mnodeShow.c index 0a522e8f99..0973163cf9 100644 --- a/src/mnode/src/mnodeShow.c +++ b/src/mnode/src/mnodeShow.c @@ -47,9 +47,10 @@ static int32_t mnodeProcessConnectMsg(SMnodeMsg *mnodeMsg); static int32_t mnodeProcessUseMsg(SMnodeMsg *mnodeMsg); static void mnodeFreeShowObj(void *data); -static bool mnodeCheckQhandle(uint64_t qhandle); -static void *mnodeSaveQhandle(void *qhandle, int32_t size); -static void mnodeFreeQhandle(void *qhandle, bool forceRemove); +static bool mnodeCheckShowObj(SShowObj *pShow); +static bool mnodeCheckShowFinished(SShowObj *pShow); +static void *mnodeSaveShowObj(SShowObj *pShow, int32_t size); +static void mnodeCleanupShowObj(void *pShow, bool forceRemove); extern void *tsMnodeTmr; static void *tsQhandleCache = NULL; @@ -129,7 +130,7 @@ static int32_t mnodeProcessShowMsg(SMnodeMsg *pMsg) { strcpy(pShow->db, pShowMsg->db); memcpy(pShow->payload, pShowMsg->payload, pShow->payloadLen); - pShow = mnodeSaveQhandle(pShow, showObjSize); + pShow = mnodeSaveShowObj(pShow, showObjSize); if (pShow == NULL) { return TSDB_CODE_SERV_OUT_OF_MEMORY; } @@ -143,7 +144,7 @@ static int32_t mnodeProcessShowMsg(SMnodeMsg *pMsg) { return TSDB_CODE_SUCCESS; } else { mError("show:%p, type:%s, failed to get meta, reason:%s", pShow, mnodeGetShowType(pShowMsg->type), tstrerror(code)); - mnodeFreeQhandle(pShow, true); + mnodeCleanupShowObj(pShow, true); return code; } } @@ -155,17 +156,24 @@ static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { SRetrieveTableMsg *pRetrieve = pMsg->rpcMsg.pCont; pRetrieve->qhandle = htobe64(pRetrieve->qhandle); + SShowObj *pShow = (SShowObj *)pRetrieve->qhandle; + mTrace("show:%p, type:%s, retrieve data", pShow, mnodeGetShowType(pShow->type)); + /* * in case of server restart, apps may hold qhandle created by server before * restart, which is actually invalid, therefore, signature check is required. */ - if (!mnodeCheckQhandle(pRetrieve->qhandle)) { - mError("retrieve:%p, qhandle:%p is invalid", pRetrieve, pRetrieve->qhandle); + if (!mnodeCheckShowObj(pShow)) { + mError("retrieve:%p, qhandle:%p is invalid", pRetrieve, pShow); return TSDB_CODE_INVALID_QHANDLE; } - - SShowObj *pShow = (SShowObj *)pRetrieve->qhandle; - mTrace("show:%p, type:%s, retrieve data", pShow, mnodeGetShowType(pShow->type)); + + if (mnodeCheckShowFinished(pShow)) { + mTrace("retrieve:%p, qhandle:%p already read finished, numOfReads:%d numOfRows:%d", pRetrieve, pShow, pShow->numOfReads, pShow->numOfRows); + pShow->numOfReads = pShow->numOfRows; + //mnodeCleanupShowObj(pShow, true); + //return TSDB_CODE_SUCCESS; + } if ((pRetrieve->free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) { rowsToRead = pShow->numOfRows - pShow->numOfReads; @@ -190,7 +198,7 @@ static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { if (rowsRead < 0) { rpcFreeCont(pRsp); - mnodeFreeQhandle(pShow, false); + mnodeCleanupShowObj(pShow, false); assert(false); return TSDB_CODE_ACTION_IN_PROGRESS; } @@ -202,11 +210,11 @@ static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { pMsg->rpcRsp.len = size; if (rowsToRead == 0) { - mnodeFreeQhandle(pShow, true); + mnodeCleanupShowObj(pShow, true); } else { - mnodeFreeQhandle(pShow, false); + mnodeCleanupShowObj(pShow, false); } - + return TSDB_CODE_SUCCESS; } @@ -301,23 +309,29 @@ static int32_t mnodeProcessUseMsg(SMnodeMsg *pMsg) { return code; } -static bool mnodeCheckQhandle(uint64_t qhandle) { - void *pSaved = taosCacheAcquireByData(tsQhandleCache, (void *)qhandle); - if (pSaved == (void *)qhandle) { - mTrace("show:%p, is retrieved", qhandle); +static bool mnodeCheckShowFinished(SShowObj *pShow) { + if (pShow->pIter == NULL && pShow->numOfReads != 0) { + return true; + } + return false; +} + +static bool mnodeCheckShowObj(SShowObj *pShow) { + SShowObj *pSaved = taosCacheAcquireByData(tsQhandleCache, pShow); + if (pSaved == pShow) { return true; } else { - mTrace("show:%p, is already released", qhandle); + mTrace("show:%p, is already released", pShow); return false; } } -static void *mnodeSaveQhandle(void *qhandle, int32_t size) { +static void *mnodeSaveShowObj(SShowObj *pShow, int32_t size) { if (tsQhandleCache != NULL) { char key[24]; - sprintf(key, "show:%p", qhandle); - void *newQhandle = taosCachePut(tsQhandleCache, key, qhandle, size, 60); - free(qhandle); + sprintf(key, "show:%p", pShow); + SShowObj *newQhandle = taosCachePut(tsQhandleCache, key, pShow, size, 60); + free(pShow); mTrace("show:%p, is saved", newQhandle); return newQhandle; @@ -332,7 +346,7 @@ static void mnodeFreeShowObj(void *data) { mTrace("show:%p, is destroyed", pShow); } -static void mnodeFreeQhandle(void *qhandle, bool forceRemove) { - mTrace("show:%p, is released, force:%s", qhandle, forceRemove ? "true" : "false"); - taosCacheRelease(tsQhandleCache, &qhandle, forceRemove); +static void mnodeCleanupShowObj(void *pShow, bool forceRemove) { + mTrace("show:%p, is released, force:%s", pShow, forceRemove ? "true" : "false"); + taosCacheRelease(tsQhandleCache, &pShow, forceRemove); } diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c index 4ce8c88281..c444fd1455 100644 --- a/src/mnode/src/mnodeTable.c +++ b/src/mnode/src/mnodeTable.c @@ -59,9 +59,11 @@ static void mnodeRemoveTableFromStable(SSuperTableObj *pStable, SChildTableOb 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 mnodeRetrieveShowSuperTables(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 mnodeGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); +static int32_t mnodeRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn); + static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *mnodeMsg); static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg); static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg); @@ -567,7 +569,9 @@ int32_t mnodeInitTables() { mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_TABLE, mnodeRetrieveShowTables); mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_METRIC, mnodeGetShowSuperTableMeta); mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_METRIC, mnodeRetrieveShowSuperTables); - + mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_STREAMS, mnodeGetStreamMeta); + mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_STREAMS, mnodeRetrieveStreams); + return TSDB_CODE_SUCCESS; } @@ -1386,7 +1390,10 @@ static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SChildTableO if (pTable->info.type == TSDB_CHILD_TABLE && pMsg != NULL) { memcpy(pCreate->data + totalCols * sizeof(SSchema), pTagData->data, tagDataLen); - memcpy(pCreate->data + totalCols * sizeof(SSchema) + tagDataLen, pTable->sql, pTable->sqlLen); + } + + if (pTable->info.type == TSDB_STREAM_TABLE && pMsg != NULL) { + memcpy(pCreate->data + totalCols * sizeof(SSchema), pTable->sql, pTable->sqlLen); } return pCreate; @@ -1516,7 +1523,7 @@ static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) { return terrno; } - SMDCreateTableMsg *pMDCreate = mnodeBuildCreateChildTableMsg(pCreate, (SChildTableObj *) pMsg->pTable); + SMDCreateTableMsg *pMDCreate = mnodeBuildCreateChildTableMsg(pCreate, (SChildTableObj *)pMsg->pTable); if (pMDCreate == NULL) { return terrno; } @@ -1879,7 +1886,7 @@ static int32_t mnodeProcessTableCfgMsg(SMnodeMsg *pMsg) { } SMDCreateTableMsg *pMDCreate = NULL; - pMDCreate = mnodeBuildCreateChildTableMsg(NULL, (SChildTableObj *) pTable); + pMDCreate = mnodeBuildCreateChildTableMsg(NULL, (SChildTableObj *)pTable); if (pMDCreate == NULL) { mnodeDecTableRef(pTable); return terrno; @@ -2248,3 +2255,115 @@ static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg) { return code; } + +static int32_t mnodeGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { + SDbObj *pDb = mnodeGetDb(pShow->db); + if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED; + + int32_t cols = 0; + SSchema *pSchema = pMeta->schema; + + pShow->bytes[cols] = TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE; + pSchema[cols].type = TSDB_DATA_TYPE_BINARY; + 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 mnodeRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, void *pConn) { + SDbObj *pDb = mnodeGetDb(pShow->db); + if (pDb == NULL) return 0; + + + int32_t numOfRows = 0; + SChildTableObj *pTable = NULL; + SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER; + + char prefix[64] = {0}; + strcpy(prefix, pDb->name); + strcat(prefix, TS_PATH_DELIMITER); + int32_t prefixLen = strlen(prefix); + + 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 + 1] = {0}; + + // pattern compare for table name + mnodeExtractTableName(pTable->info.tableId, tableName); + + if (pShow->payloadLen > 0 && patternMatch(pShow->payload, tableName, TSDB_TABLE_NAME_LEN, &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, TSDB_TABLE_NAME_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; + STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pTable->sql, TSDB_MAX_SQL_SHOW_LEN); + cols++; + + numOfRows++; + mnodeDecTableRef(pTable); + } + + pShow->numOfReads += numOfRows; + const int32_t NUM_OF_COLUMNS = 4; + + mnodeVacuumResult(data, NUM_OF_COLUMNS, numOfRows, rows, pShow); + mnodeDecDbRef(pDb); + + return numOfRows; +} \ No newline at end of file diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c index 6854dd3c78..6d65d10335 100644 --- a/src/vnode/src/vnodeWrite.c +++ b/src/vnode/src/vnodeWrite.c @@ -106,8 +106,7 @@ static int32_t vnodeProcessSubmitMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pR static int32_t vnodeProcessCreateTableMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pRet) { SMDCreateTableMsg *pTable = pCont; int32_t code = 0; - char sql[1024] = "\0"; - + vTrace("vgId:%d, table:%s, start to create", pVnode->vgId, pTable->tableId); int16_t numOfColumns = htons(pTable->numOfColumns); int16_t numOfTags = htons(pTable->numOfTags); @@ -152,8 +151,10 @@ static int32_t vnodeProcessCreateTableMsg(SVnodeObj *pVnode, void *pCont, SRspRe tsdbTableSetTagValue(&tCfg, dataRow, false); } + // only normal has sql string if (pTable->tableType == TSDB_STREAM_TABLE) { - // TODO: set sql value + char *sql = pTable->data + totalCols * sizeof(SSchema); + vTrace("vgId:%d, table:%s is creating, sql:%s", pVnode->vgId, pTable->tableId, sql); tsdbTableSetStreamSql(&tCfg, sql, false); } From fe22dcf99bf78ca93b0dd3f2f83a348f6a07527c Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 12:24:02 +0000 Subject: [PATCH 15/17] [TD-335] fix bug while get mnode ipset --- src/dnode/src/dnodeMgmt.c | 13 ++++-- src/mnode/src/mnodeMnode.c | 46 +++++++++---------- src/mnode/src/mnodeSdb.c | 2 +- tests/script/sh/deploy.sh | 7 ++- .../dn3_mn1_replica2_wal1_AddDelDnode.sim | 8 ++-- 5 files changed, 40 insertions(+), 36 deletions(-) diff --git a/src/dnode/src/dnodeMgmt.c b/src/dnode/src/dnodeMgmt.c index f6be375396..c4a07518ea 100644 --- a/src/dnode/src/dnodeMgmt.c +++ b/src/dnode/src/dnodeMgmt.c @@ -284,7 +284,7 @@ static int32_t dnodeProcessConfigDnodeMsg(SRpcMsg *pMsg) { } void dnodeUpdateMnodeIpSetForPeer(SRpcIpSet *pIpSet) { - dPrint("mnode IP list is changed, numOfIps:%d inUse:%d", pIpSet->numOfIps, pIpSet->inUse); + dPrint("mnode IP list for peer is changed, numOfIps:%d inUse:%d", pIpSet->numOfIps, pIpSet->inUse); for (int i = 0; i < pIpSet->numOfIps; ++i) { dPrint("mnode index:%d %s:%u", i, pIpSet->fqdn[i], pIpSet->port[i]) } @@ -344,17 +344,24 @@ static void dnodeUpdateMnodeInfos(SDMMnodeInfos *pMnodes) { if (!(mnodesChanged || mnodesNotInit)) return; memcpy(&tsDMnodeInfos, pMnodes, sizeof(SDMMnodeInfos)); + dPrint("mnode infos is changed, nodeNum:%d inUse:%d", tsDMnodeInfos.nodeNum, tsDMnodeInfos.inUse); + for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) { + dPrint("mnode index:%d, %s", tsDMnodeInfos.nodeInfos[i].nodeId, tsDMnodeInfos.nodeInfos[i].nodeEp); + } tsDMnodeIpSetForPeer.inUse = tsDMnodeInfos.inUse; tsDMnodeIpSetForPeer.numOfIps = tsDMnodeInfos.nodeNum; for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) { taosGetFqdnPortFromEp(tsDMnodeInfos.nodeInfos[i].nodeEp, tsDMnodeIpSetForPeer.fqdn[i], &tsDMnodeIpSetForPeer.port[i]); tsDMnodeIpSetForPeer.port[i] += TSDB_PORT_DNODEDNODE; + dPrint("mnode index:%d, for peer %s %d", i, tsDMnodeIpSetForPeer.fqdn[i], tsDMnodeIpSetForPeer.port[i]); } - dPrint("mnodes is changed, nodeNum:%d inUse:%d", tsDMnodeInfos.nodeNum, tsDMnodeInfos.inUse); + tsDMnodeIpSetForShell.inUse = tsDMnodeInfos.inUse; + tsDMnodeIpSetForShell.numOfIps = tsDMnodeInfos.nodeNum; for (int32_t i = 0; i < tsDMnodeInfos.nodeNum; i++) { - dPrint("mnode:%d, %s", tsDMnodeInfos.nodeInfos[i].nodeId, tsDMnodeInfos.nodeInfos[i].nodeEp); + taosGetFqdnPortFromEp(tsDMnodeInfos.nodeInfos[i].nodeEp, tsDMnodeIpSetForShell.fqdn[i], &tsDMnodeIpSetForShell.port[i]); + dPrint("mnode index:%d, for shell %s %d", i, tsDMnodeIpSetForShell.fqdn[i], tsDMnodeIpSetForShell.port[i]); } dnodeSaveMnodeInfos(); diff --git a/src/mnode/src/mnodeMnode.c b/src/mnode/src/mnodeMnode.c index 151bd69c6d..de1826a174 100644 --- a/src/mnode/src/mnodeMnode.c +++ b/src/mnode/src/mnodeMnode.c @@ -33,8 +33,8 @@ static void * tsMnodeSdb = NULL; static int32_t tsMnodeUpdateSize = 0; -static SRpcIpSet tsMnodeRpcIpSetForShell; -static SRpcIpSet tsMnodeRpcIpSetForPeer; +static SRpcIpSet tsMnodeIpSetForShell; +static SRpcIpSet tsMnodeIpSetForPeer; static SDMMnodeInfos tsMnodeInfos; static int32_t mnodeGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); static int32_t mnodeRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn); @@ -202,17 +202,13 @@ char *mnodeGetMnodeRoleStr(int32_t role) { } void mnodeUpdateMnodeIpSet() { - SRpcIpSet *ipSetForShell = &tsMnodeRpcIpSetForShell; - SRpcIpSet *ipSetForPeer = &tsMnodeRpcIpSetForPeer; - SDMMnodeInfos *mnodes = &tsMnodeInfos; - mPrint("update mnodes ipset, numOfIps:%d ", mnodeGetMnodesNum()); mnodeMnodeWrLock(); - memset(ipSetForShell, 0, sizeof(SRpcIpSet)); - memset(ipSetForPeer, 0, sizeof(SRpcIpSet)); - memset(mnodes, 0, sizeof(SDMMnodeInfos)); + memset(&tsMnodeIpSetForShell, 0, sizeof(SRpcIpSet)); + memset(&tsMnodeIpSetForPeer, 0, sizeof(SRpcIpSet)); + memset(&tsMnodeInfos, 0, sizeof(SDMMnodeInfos)); int32_t index = 0; void * pIter = NULL; @@ -223,22 +219,24 @@ void mnodeUpdateMnodeIpSet() { SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId); if (pDnode != NULL) { - strcpy(ipSetForShell->fqdn[ipSetForShell->numOfIps], pDnode->dnodeFqdn); - ipSetForShell->port[ipSetForShell->numOfIps] = htons(pDnode->dnodePort); + strcpy(tsMnodeIpSetForShell.fqdn[index], pDnode->dnodeFqdn); + tsMnodeIpSetForShell.port[index] = htons(pDnode->dnodePort); + mTrace("mnode:%d, for shell fqdn:%s %d", pDnode->dnodeId, tsMnodeIpSetForShell.fqdn[index], htons(tsMnodeIpSetForShell.port[index])); - strcpy(ipSetForPeer->fqdn[ipSetForPeer->numOfIps], pDnode->dnodeFqdn); - ipSetForPeer->port[ipSetForPeer->numOfIps] = htons(pDnode->dnodePort + TSDB_PORT_DNODEDNODE); + strcpy(tsMnodeIpSetForPeer.fqdn[index], pDnode->dnodeFqdn); + tsMnodeIpSetForPeer.port[index] = htons(pDnode->dnodePort + TSDB_PORT_DNODEDNODE); + mTrace("mnode:%d, for peer fqdn:%s %d", pDnode->dnodeId, tsMnodeIpSetForPeer.fqdn[index], htons(tsMnodeIpSetForPeer.port[index])); - mnodes->nodeInfos[index].nodeId = htonl(pMnode->mnodeId); - strcpy(mnodes->nodeInfos[index].nodeEp, pDnode->dnodeEp); + tsMnodeInfos.nodeInfos[index].nodeId = htonl(pMnode->mnodeId); + strcpy(tsMnodeInfos.nodeInfos[index].nodeEp, pDnode->dnodeEp); if (pMnode->role == TAOS_SYNC_ROLE_MASTER) { - ipSetForShell->inUse = index; - ipSetForPeer->inUse = index; - mnodes->inUse = index; + tsMnodeIpSetForShell.inUse = index; + tsMnodeIpSetForPeer.inUse = index; + tsMnodeInfos.inUse = index; } - mPrint("mnode:%d, ep:%s %s", index, pDnode->dnodeEp, pMnode->role == TAOS_SYNC_ROLE_MASTER ? "master" : ""); + mPrint("mnode:%d, ep:%s %s", pDnode->dnodeId, pDnode->dnodeEp, pMnode->role == TAOS_SYNC_ROLE_MASTER ? "master" : ""); index++; } @@ -246,9 +244,9 @@ void mnodeUpdateMnodeIpSet() { mnodeDecMnodeRef(pMnode); } - mnodes->nodeNum = index; - ipSetForPeer->numOfIps = index; - ipSetForPeer->numOfIps = index; + tsMnodeInfos.nodeNum = index; + tsMnodeIpSetForShell.numOfIps = index; + tsMnodeIpSetForPeer.numOfIps = index; sdbFreeIter(pIter); @@ -257,13 +255,13 @@ void mnodeUpdateMnodeIpSet() { void mnodeGetMnodeIpSetForPeer(SRpcIpSet *ipSet) { mnodeMnodeRdLock(); - *ipSet = tsMnodeRpcIpSetForShell; + *ipSet = tsMnodeIpSetForPeer; mnodeMnodeUnLock(); } void mnodeGetMnodeIpSetForShell(SRpcIpSet *ipSet) { mnodeMnodeRdLock(); - *ipSet = tsMnodeRpcIpSetForShell; + *ipSet = tsMnodeIpSetForShell; mnodeMnodeUnLock(); } diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c index 3905773d54..3fdb1b0dfe 100644 --- a/src/mnode/src/mnodeSdb.c +++ b/src/mnode/src/mnodeSdb.c @@ -186,7 +186,7 @@ void sdbUpdateMnodeRoles() { SNodesRole roles = {0}; syncGetNodesRole(tsSdbObj.sync, &roles); - sdbPrint("update mnodes:%d sync roles", tsSdbObj.cfg.replica); + sdbPrint("update mnodes sync roles, total:%d", tsSdbObj.cfg.replica); for (int32_t i = 0; i < tsSdbObj.cfg.replica; ++i) { SMnodeObj *pMnode = mnodeGetMnode(roles.nodeId[i]); if (pMnode != NULL) { diff --git a/tests/script/sh/deploy.sh b/tests/script/sh/deploy.sh index f8e123369f..8e7490db55 100755 --- a/tests/script/sh/deploy.sh +++ b/tests/script/sh/deploy.sh @@ -96,17 +96,16 @@ echo "second ${HOSTNAME}:7200" >> $TAOS_CFG echo "serverPort ${NODE}" >> $TAOS_CFG echo "dataDir $DATA_DIR" >> $TAOS_CFG echo "logDir $LOG_DIR" >> $TAOS_CFG -echo "debugFlag 135" >> $TAOS_CFG echo "dDebugFlag 135" >> $TAOS_CFG -echo "mDebugFlag 135" >> $TAOS_CFG +echo "mDebugFlag 199" >> $TAOS_CFG echo "sdbDebugFlag 135" >> $TAOS_CFG echo "rpcDebugFlag 135" >> $TAOS_CFG echo "tmrDebugFlag 131" >> $TAOS_CFG echo "cDebugFlag 135" >> $TAOS_CFG echo "httpDebugFlag 135" >> $TAOS_CFG echo "monitorDebugFlag 131" >> $TAOS_CFG -echo "udebugFlag 131" >> $TAOS_CFG -echo "jnidebugFlag 131" >> $TAOS_CFG +echo "udebugFlag 135" >> $TAOS_CFG +echo "jnidebugFlag 135" >> $TAOS_CFG echo "sdebugFlag 135" >> $TAOS_CFG echo "qdebugFlag 135" >> $TAOS_CFG echo "monitor 0" >> $TAOS_CFG diff --git a/tests/script/unique/arbitrator/dn3_mn1_replica2_wal1_AddDelDnode.sim b/tests/script/unique/arbitrator/dn3_mn1_replica2_wal1_AddDelDnode.sim index 583134c761..eabaefd678 100644 --- a/tests/script/unique/arbitrator/dn3_mn1_replica2_wal1_AddDelDnode.sim +++ b/tests/script/unique/arbitrator/dn3_mn1_replica2_wal1_AddDelDnode.sim @@ -29,10 +29,10 @@ system sh/cfg.sh -n dnode3 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode4 -c numOfTotalVnodes -v 4 system sh/cfg.sh -n dnode5 -c numOfTotalVnodes -v 4 -system sh/cfg.sh -n dnode1 -c mgmtEqualVnodeNum -v 200 -#system sh/cfg.sh -n dnode2 -c mgmtEqualVnodeNum -v 200 -#system sh/cfg.sh -n dnode3 -c mgmtEqualVnodeNum -v 200 -#system sh/cfg.sh -n dnode4 -c mgmtEqualVnodeNum -v 200 +system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 200 +#system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 200 +#system sh/cfg.sh -n dnode3 -c mnodeEqualVnodeNum -v 200 +#system sh/cfg.sh -n dnode4 -c mnodeEqualVnodeNum -v 200 system sh/cfg.sh -n dnode1 -c arbitrator -v $arbitrator system sh/cfg.sh -n dnode2 -c arbitrator -v $arbitrator From 8fa2f79be4dd6c59c9206e8e079ab08f0595542e Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 12:24:17 +0000 Subject: [PATCH 16/17] [TD-335] log --- tests/script/sh/deploy.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/script/sh/deploy.sh b/tests/script/sh/deploy.sh index 8e7490db55..db40fb0457 100755 --- a/tests/script/sh/deploy.sh +++ b/tests/script/sh/deploy.sh @@ -97,7 +97,7 @@ echo "serverPort ${NODE}" >> $TAOS_CFG echo "dataDir $DATA_DIR" >> $TAOS_CFG echo "logDir $LOG_DIR" >> $TAOS_CFG echo "dDebugFlag 135" >> $TAOS_CFG -echo "mDebugFlag 199" >> $TAOS_CFG +echo "mDebugFlag 135" >> $TAOS_CFG echo "sdbDebugFlag 135" >> $TAOS_CFG echo "rpcDebugFlag 135" >> $TAOS_CFG echo "tmrDebugFlag 131" >> $TAOS_CFG From abc947cecd7eca6ff42d11d7e164981dfab177e3 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 14:37:30 +0000 Subject: [PATCH 17/17] [TD-335] rename some functions --- src/dnode/inc/dnodeMPeer.h | 4 ++-- src/dnode/src/dnodeMPeer.c | 4 ++-- src/dnode/src/dnodeVRead.c | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/dnode/inc/dnodeMPeer.h b/src/dnode/inc/dnodeMPeer.h index cdbb4a210c..9a48703110 100644 --- a/src/dnode/inc/dnodeMPeer.h +++ b/src/dnode/inc/dnodeMPeer.h @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#ifndef TDENGINE_DNODE_MMGMT_H -#define TDENGINE_DNODE_MMGMT_H +#ifndef TDENGINE_DNODE_MPEER_H +#define TDENGINE_DNODE_MPEER_H #ifdef __cplusplus extern "C" { diff --git a/src/dnode/src/dnodeMPeer.c b/src/dnode/src/dnodeMPeer.c index da1910a691..e3ba5fcf01 100644 --- a/src/dnode/src/dnodeMPeer.c +++ b/src/dnode/src/dnodeMPeer.c @@ -119,7 +119,7 @@ void dnodeDispatchToMnodePeerQueue(SRpcMsg *pMsg) { taosWriteQitem(tsMPeerQueue, TAOS_QTYPE_RPC, pPeer); } -static void dnodeFreeMnodePeadMsg(SMnodeMsg *pPeer) { +static void dnodeFreeMnodePeerMsg(SMnodeMsg *pPeer) { mnodeCleanupMsg(pPeer); taosFreeQitem(pPeer); } @@ -135,7 +135,7 @@ static void dnodeSendRpcMnodePeerRsp(SMnodeMsg *pPeer, int32_t code) { }; rpcSendResponse(&rpcRsp); - dnodeFreeMnodePeadMsg(pPeer); + dnodeFreeMnodePeerMsg(pPeer); } static void *dnodeProcessMnodePeerQueue(void *param) { diff --git a/src/dnode/src/dnodeVRead.c b/src/dnode/src/dnodeVRead.c index 4b1ff84bec..1ff868d0ff 100644 --- a/src/dnode/src/dnodeVRead.c +++ b/src/dnode/src/dnodeVRead.c @@ -92,7 +92,7 @@ void dnodeCleanupVnodeRead() { } void dnodeDispatchToVnodeReadQueue(SRpcMsg *pMsg) { - int32_t mnodeMsgNum = 0; + int32_t queuedMsgNum = 0; int32_t leftLen = pMsg->contLen; char *pCont = (char *) pMsg->pCont; void *pVnode; @@ -124,12 +124,12 @@ void dnodeDispatchToVnodeReadQueue(SRpcMsg *pMsg) { // next vnode leftLen -= pHead->contLen; pCont -= pHead->contLen; - mnodeMsgNum++; + queuedMsgNum++; taosWriteQitem(queue, TAOS_QTYPE_RPC, pRead); } - if (mnodeMsgNum == 0) { + if (queuedMsgNum == 0) { SRpcMsg rpcRsp = { .handle = pMsg->handle, .pCont = NULL,