From f15668cb7df09ce39608e359abb6ed62aa12893e Mon Sep 17 00:00:00 2001 From: Tao Liu Date: Fri, 22 May 2020 02:35:37 +0000 Subject: [PATCH 01/39] [non-jira]change tsdb tag mechanism --- src/common/inc/tdataformat.h | 38 ++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h index 51a5dad486..eef2e51cc2 100644 --- a/src/common/inc/tdataformat.h +++ b/src/common/inc/tdataformat.h @@ -198,6 +198,44 @@ void tdPopDataColsPoints(SDataCols *pCols, int pointsToPop); //!!!! int tdMergeDataCols(SDataCols *target, SDataCols *src, int rowsToMerge); void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, SDataCols *src2, int *iter2, int tRows); + +// ----------------- Tag row structure + +/* A tag row, the format is like below: ++----------+-------------------------------------------------------------+---------------------------------+ +| int16 | int16 | int64 | int16 | int64 | ...| int16 | int64 | char | ++----------+-------------------------------------------------------------+---------------------------------+ +| ncols | colId1 | offset1 | colId2 | offset2 | ...| colIdN | offsetN | values | ++----------+-------------------------------------------------------------+---------------------------------+ + */ +typedef void *STagRowRaw; + +#define TD_TAG_ROW_HEAD_SIZE sizeof(int16_t) + +#define tagRowNum(r) (*(int16_t *)(r)) +#define tagRowArray(r) POINTER_SHIFT(r, TD_TAG_ROW_HEAD_SIZE) +//#define dataRowKey(r) (*(TSKEY *)(dataRowTuple(r))) +//#define dataRowSetLen(r, l) (dataRowLen(r) = (l)) +//#define dataRowCpy(dst, r) memcpy((dst), (r), dataRowLen(r)) +//#define dataRowMaxBytesFromSchema(s) (schemaTLen(s) + TD_DATA_ROW_HEAD_SIZE) + +typedef struct { + int16_t colId; // column ID + union{ + int64_t tagOffset; + int64_t tagValue; + }; +} STagCol; + +typedef struct { + int16_t nCols; // Total columns allocated + STagCol tagCols[]; +} STagRow; + + + + + #ifdef __cplusplus } #endif From 0f43e08f591d65812d38df9eeca994a41e751794 Mon Sep 17 00:00:00 2001 From: Tao Liu Date: Sat, 23 May 2020 03:37:07 +0000 Subject: [PATCH 02/39] [TD-90]Tag Schema --- src/common/inc/tdataformat.h | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h index eef2e51cc2..30fb18bb95 100644 --- a/src/common/inc/tdataformat.h +++ b/src/common/inc/tdataformat.h @@ -208,7 +208,7 @@ void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, SD | ncols | colId1 | offset1 | colId2 | offset2 | ...| colIdN | offsetN | values | +----------+-------------------------------------------------------------+---------------------------------+ */ -typedef void *STagRowRaw; + #define TD_TAG_ROW_HEAD_SIZE sizeof(int16_t) @@ -221,20 +221,20 @@ typedef void *STagRowRaw; typedef struct { int16_t colId; // column ID - union{ - int64_t tagOffset; - int64_t tagValue; - }; + int16_t colLen; // if col type is binary/Nchar, this is the length of binary/Nchar + int64_t valueOrOffset; //to store value for numeric col or offset for binary/Nchar } STagCol; typedef struct { - int16_t nCols; // Total columns allocated - STagCol tagCols[]; + int32_t len; + void * pBinaryData; // Space to store the binary and Nchar value + int16_t ncols; // Total columns allocated + STagCol tagCols[]; } STagRow; - - - +int tdInsertTagCol(SDataRow *row, void *value, int32_t bytes, int16_t colId); +int tdQuerTagByID(SDataRow row, void *value, int16_t colId); +SDataRow tdNewTagRowFromSchema(STSchema *pSchema); #ifdef __cplusplus } From df01a390d4fbd2f7832bf0e57183e95fd5623efe Mon Sep 17 00:00:00 2001 From: Tao Liu Date: Sat, 23 May 2020 09:40:46 +0000 Subject: [PATCH 03/39] [TD-90] developing --- src/common/inc/tdataformat.h | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h index 30fb18bb95..4c3e578a9a 100644 --- a/src/common/inc/tdataformat.h +++ b/src/common/inc/tdataformat.h @@ -221,20 +221,28 @@ void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, SD typedef struct { int16_t colId; // column ID - int16_t colLen; // if col type is binary/Nchar, this is the length of binary/Nchar - int64_t valueOrOffset; //to store value for numeric col or offset for binary/Nchar + int8_t colType; + int8_t colLen; // if col type is binary/Nchar, this is the length of binary/Nchar + int16_t offset; //to store value for numeric col or offset for binary/Nchar } STagCol; typedef struct { int32_t len; - void * pBinaryData; // Space to store the binary and Nchar value + void * pData; // Space to store the tag value int16_t ncols; // Total columns allocated STagCol tagCols[]; } STagRow; -int tdInsertTagCol(SDataRow *row, void *value, int32_t bytes, int16_t colId); -int tdQuerTagByID(SDataRow row, void *value, int16_t colId); + +#define tagColSize(r) (sizeof(STagCol) + r.colLen) + +int tdInsertTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId); //insert tag value and update all the information +int tdDeleteTagCol(SDataRow row, int16_t colId); // delete tag value and update all the information +int tdQuerTagByID(SDataRow row, int16_t colId, void *value); //if find tag, return value length, else return -1; +int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes); + SDataRow tdNewTagRowFromSchema(STSchema *pSchema); +STSchema *tdGetSchemaFromData(SDataRow *row); #ifdef __cplusplus } From eb6b6e0c746c2968a77cfe8243f315e1f2dc2315 Mon Sep 17 00:00:00 2001 From: Tao Liu Date: Sun, 24 May 2020 08:48:51 +0000 Subject: [PATCH 04/39] [TD-90] alter tag function develop --- src/common/inc/tdataformat.h | 20 ++++++++++-------- src/common/src/tdataformat.c | 39 ++++++++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+), 8 deletions(-) diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h index 4c3e578a9a..0aec948015 100644 --- a/src/common/inc/tdataformat.h +++ b/src/common/inc/tdataformat.h @@ -202,11 +202,15 @@ void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, SD // ----------------- Tag row structure /* A tag row, the format is like below: -+----------+-------------------------------------------------------------+---------------------------------+ -| int16 | int16 | int64 | int16 | int64 | ...| int16 | int64 | char | -+----------+-------------------------------------------------------------+---------------------------------+ -| ncols | colId1 | offset1 | colId2 | offset2 | ...| colIdN | offsetN | values | -+----------+-------------------------------------------------------------+---------------------------------+ ++----------+----------------------------------------------------------------+ +| STagRow | STagCol | STagCol | STagCol | STagCol | ...| STagCol | STagCol | ++----------+----------------------------------------------------------------+ + +pData ++----------+----------------------------------------------------------------+ +| value 1 | value 2 | value 3 | value 4 | ....|value n | ++----------+----------------------------------------------------------------+ + */ @@ -221,8 +225,8 @@ void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, SD typedef struct { int16_t colId; // column ID - int8_t colType; - int8_t colLen; // if col type is binary/Nchar, this is the length of binary/Nchar + int16_t colType; + int16_t colLen; // if col type is binary/Nchar, this is the length of binary/Nchar int16_t offset; //to store value for numeric col or offset for binary/Nchar } STagCol; @@ -238,7 +242,7 @@ typedef struct { int tdInsertTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId); //insert tag value and update all the information int tdDeleteTagCol(SDataRow row, int16_t colId); // delete tag value and update all the information -int tdQuerTagByID(SDataRow row, int16_t colId, void *value); //if find tag, return value length, else return -1; +int tdQuerTagByID(SDataRow row, int16_t colId, void *value, int16_t *type, int16_t *len); //if find tag, 0, else return -1; int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes); SDataRow tdNewTagRowFromSchema(STSchema *pSchema); diff --git a/src/common/src/tdataformat.c b/src/common/src/tdataformat.c index 9d81cd07af..3df94452d8 100644 --- a/src/common/src/tdataformat.c +++ b/src/common/src/tdataformat.c @@ -151,6 +151,26 @@ SDataRow tdNewDataRowFromSchema(STSchema *pSchema) { return row; } +int tdInsertTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId){ //insert tag value and update all the information + return 0; +}; + +int tdDeleteTagCol(SDataRow row, int16_t colId){ // delete tag value and update all the information + return o; +}; + +int tdQuerTagByID(SDataRow row, int16_t colId, void *value, int16_t *type, int16_t *len){ //if find tag, 0, else return -1; + return 0; +}; + +int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes){ + return 0; +}; + +SDataRow tdNewTagRowFromSchema(STSchema *pSchema) { + //todo +} + /** * Free the SDataRow object */ @@ -183,6 +203,25 @@ int tdAppendColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int32_ return 0; } +int tdAppendColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int32_t offset) { + ASSERT(value != NULL); + int32_t toffset = offset + TD_DATA_ROW_HEAD_SIZE; + char * ptr = POINTER_SHIFT(row, dataRowLen(row)); + + switch (type) { + case TSDB_DATA_TYPE_BINARY: + case TSDB_DATA_TYPE_NCHAR: + *(VarDataOffsetT *)POINTER_SHIFT(row, toffset) = dataRowLen(row); + memcpy(ptr, value, varDataTLen(value)); + dataRowLen(row) += varDataTLen(value); + break; + default: + memcpy(POINTER_SHIFT(row, toffset), value, TYPE_BYTES[type]); + break; + } + + return 0; +} SDataRow tdDataRowDup(SDataRow row) { SDataRow trow = malloc(dataRowLen(row)); From 406e170f59fb336406b173c7a7b9a3cb30d85577 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Mon, 25 May 2020 19:05:52 +0800 Subject: [PATCH 05/39] [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 fbc50a3da38563a032abf3b9ffa83935c698c453 Mon Sep 17 00:00:00 2001 From: Tao Liu Date: Tue, 26 May 2020 11:02:05 +0000 Subject: [PATCH 06/39] [TD-90] tag schema develop --- src/common/inc/tdataformat.h | 17 ++-- src/common/src/tdataformat.c | 151 ++++++++++++++++++++++++++++------- src/tsdb/src/tsdbMeta.c | 28 ++++--- src/tsdb/src/tsdbRead.c | 16 ++-- src/vnode/src/vnodeWrite.c | 6 +- 5 files changed, 162 insertions(+), 56 deletions(-) diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h index 0aec948015..b1dda88d50 100644 --- a/src/common/inc/tdataformat.h +++ b/src/common/inc/tdataformat.h @@ -226,13 +226,13 @@ pData typedef struct { int16_t colId; // column ID int16_t colType; - int16_t colLen; // if col type is binary/Nchar, this is the length of binary/Nchar - int16_t offset; //to store value for numeric col or offset for binary/Nchar + uint16_t offset; //to store value for numeric col or offset for binary/Nchar } STagCol; typedef struct { - int32_t len; + int32_t len; void * pData; // Space to store the tag value + uint16_t dataLen; int16_t ncols; // Total columns allocated STagCol tagCols[]; } STagRow; @@ -242,10 +242,13 @@ typedef struct { int tdInsertTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId); //insert tag value and update all the information int tdDeleteTagCol(SDataRow row, int16_t colId); // delete tag value and update all the information -int tdQuerTagByID(SDataRow row, int16_t colId, void *value, int16_t *type, int16_t *len); //if find tag, 0, else return -1; -int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes); - -SDataRow tdNewTagRowFromSchema(STSchema *pSchema); +void * tdQueryTagByID(SDataRow row, int16_t colId, int16_t *type); //if find tag, 0, else return -1; +int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int16_t colId); +SDataRow tdTagRowDup(SDataRow row); +void tdFreeTagRow(SDataRow row); +SDataRow tdTagRowDecode(SDataRow row); +int tdTagRowCpy(SDataRow dst, SDataRow src); +void * tdNewTagRowFromSchema(STSchema *pSchema, int16_t numofTags); STSchema *tdGetSchemaFromData(SDataRow *row); #ifdef __cplusplus diff --git a/src/common/src/tdataformat.c b/src/common/src/tdataformat.c index 3df94452d8..822a92322a 100644 --- a/src/common/src/tdataformat.c +++ b/src/common/src/tdataformat.c @@ -14,6 +14,7 @@ */ #include "tdataformat.h" #include "wchar.h" +#include "talgo.h" /** * Create a SSchema object with nCols columns @@ -152,25 +153,136 @@ SDataRow tdNewDataRowFromSchema(STSchema *pSchema) { } int tdInsertTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId){ //insert tag value and update all the information + //todo return 0; }; int tdDeleteTagCol(SDataRow row, int16_t colId){ // delete tag value and update all the information - return o; -}; - -int tdQuerTagByID(SDataRow row, int16_t colId, void *value, int16_t *type, int16_t *len){ //if find tag, 0, else return -1; - return 0; -}; - -int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes){ + //todo return 0; }; -SDataRow tdNewTagRowFromSchema(STSchema *pSchema) { - //todo +static int compTagVal(const void *key1, const void *key2) { + if (*(int16_t *)key1 > *(int16_t *)key2) { + return 1; + } else if (*(int16_t *)key1 == *(int16_t *)key2) { + return 0; + } else { + return -1; + } } +void * tdQueryTagByID(SDataRow row, int16_t colId, int16_t *type) { //if find tag, 0, else return -1; + //todo + ASSERT(((STagRow *)row)->pData != NULL); + + STagCol *pBase = ((STagRow *)row)->tagCols; + int16_t nCols = ((STagRow *)row)->ncols; + + STagCol * stCol = taosbsearch(&colId, pBase, nCols, sizeof(STagCol), compTagVal, TD_EQ); + if (NULL == stCol) { + return NULL; + } + + void * pData = ((STagRow *)row)->pData; + *type = stCol->colType; + + return pData + stCol->offset; +}; + +int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int16_t colId){ + ASSERT(value != NULL); + //ASSERT(bytes-2 == varDataTLen(value)); + ASSERT(row != NULL); + STagRow *pTagrow = row; + + pTagrow->tagCols[pTagrow->ncols].colId = colId; + pTagrow->tagCols[pTagrow->ncols].colType = type; + pTagrow->tagCols[pTagrow->ncols].offset = pTagrow->dataLen; + + switch (type) { + case TSDB_DATA_TYPE_BINARY: + case TSDB_DATA_TYPE_NCHAR: + memcpy((char *)pTagrow->pData + pTagrow->dataLen, value, varDataTLen(value)); + pTagrow->dataLen += varDataTLen(value); + break; + default: + memcpy((char *)pTagrow->pData + pTagrow->dataLen, value, TYPE_BYTES[type]); + pTagrow->dataLen += TYPE_BYTES[type]; + break; + } + + pTagrow->ncols++; + + return 0; +}; + +void * tdNewTagRowFromSchema(STSchema *pSchema, int16_t numofTags) { + int32_t size = sizeof(STagRow) + numofTags * sizeof(STagCol); + + STagRow *row = malloc(size); + if (row == NULL) return NULL; + + int32_t datasize = pSchema->tlen - pSchema->flen; + row->pData = malloc(datasize); + if (NULL == row->pData) { + free(row); + return NULL; + } + + row->len = size; + row->dataLen = 0; + row->ncols = 0; + return row; +} +/** + * free tag row + */ + +void tdFreeTagRow(SDataRow row) { + if (row) { + free(((STagRow *)row)->pData); + free(row); + } +} + +SDataRow tdTagRowDup(SDataRow row) { + STagRow *trow = malloc(dataRowLen(row)); + if (trow == NULL) return NULL; + + dataRowCpy(trow, row); + trow->pData = malloc(trow->dataLen); + if (NULL == trow->pData) { + free(trow); + return NULL; + } + memcpy(trow->pData, ((STagRow *)row)->pData, trow->dataLen); + return trow; +} + +SDataRow tdTagRowDecode(SDataRow row) { + STagRow *trow = malloc(dataRowLen(row)); + if (trow == NULL) return NULL; + + dataRowCpy(trow, row); + trow->pData = malloc(trow->dataLen); + if (NULL == trow->pData) { + free(trow); + return NULL; + } + char * pData = (char *)row + dataRowLen(row) + sizeof(int32_t); + memcpy(trow->pData, pData, trow->dataLen); + return trow; +} + +int tdTagRowCpy(SDataRow dst, SDataRow src) { + if (src == NULL) return -1; + + dataRowCpy(dst, src); + void * pData = dst + dataRowLen(src); + memcpy(pData, ((STagRow *)src)->pData, ((STagRow *)src)->dataLen); + return 0; +} /** * Free the SDataRow object */ @@ -203,25 +315,6 @@ int tdAppendColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int32_ return 0; } -int tdAppendColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int32_t offset) { - ASSERT(value != NULL); - int32_t toffset = offset + TD_DATA_ROW_HEAD_SIZE; - char * ptr = POINTER_SHIFT(row, dataRowLen(row)); - - switch (type) { - case TSDB_DATA_TYPE_BINARY: - case TSDB_DATA_TYPE_NCHAR: - *(VarDataOffsetT *)POINTER_SHIFT(row, toffset) = dataRowLen(row); - memcpy(ptr, value, varDataTLen(value)); - dataRowLen(row) += varDataTLen(value); - break; - default: - memcpy(POINTER_SHIFT(row, toffset), value, TYPE_BYTES[type]); - break; - } - - return 0; -} SDataRow tdDataRowDup(SDataRow row) { SDataRow trow = malloc(dataRowLen(row)); diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c index 356e9c77f1..c16bb74df8 100644 --- a/src/tsdb/src/tsdbMeta.c +++ b/src/tsdb/src/tsdbMeta.c @@ -54,7 +54,7 @@ void *tsdbEncodeTable(STable *pTable, int *contLen) { ptr = tdEncodeSchema(ptr, pTable->schema); ptr = tdEncodeSchema(ptr, pTable->tagSchema); } else if (pTable->type == TSDB_CHILD_TABLE) { - dataRowCpy(ptr, pTable->tagVal); + tdTagRowCpy(ptr, pTable->tagVal); } else { ptr = tdEncodeSchema(ptr, pTable->schema); } @@ -96,7 +96,7 @@ STable *tsdbDecodeTable(void *cont, int contLen) { pTable->schema = tdDecodeSchema(&ptr); pTable->tagSchema = tdDecodeSchema(&ptr); } else if (pTable->type == TSDB_CHILD_TABLE) { - pTable->tagVal = tdDataRowDup(ptr); + pTable->tagVal = tdTagRowDecode(ptr); } else { pTable->schema = tdDecodeSchema(&ptr); } @@ -114,8 +114,10 @@ static char* getTagIndexKey(const void* pData) { SDataRow row = elem->pTable->tagVal; STSchema* pSchema = tsdbGetTableTagSchema(elem->pMeta, elem->pTable); STColumn* pCol = &pSchema->columns[DEFAULT_TAG_INDEX_COLUMN]; - - return tdGetRowDataOfCol(row, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset); + int16_t type = 0; + void * res = tdQueryTagByID(row, pCol->colId,&type); + ASSERT(type == pCol->type); + return res; } int tsdbRestoreTable(void *pHandle, void *cont, int contLen) { @@ -255,8 +257,9 @@ int32_t tsdbGetTableTagVal(TsdbRepoT* repo, STableId* id, int32_t colId, int16_t } SDataRow row = (SDataRow)pTable->tagVal; - char* d = tdGetRowDataOfCol(row, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset); - + int16_t tagtype = 0; + char* d = tdQueryTagByID(row, pCol->colId, &tagtype); + //ASSERT((int8_t)tagtype == pCol->type) *val = d; *type = pCol->type; *bytes = pCol->bytes; @@ -321,7 +324,7 @@ int tsdbCreateTable(TsdbRepoT *repo, STableCfg *pCfg) { if (super->pIndex == NULL) { tdFreeSchema(super->schema); tdFreeSchema(super->tagSchema); - tdFreeDataRow(super->tagVal); + tdFreeTagRow(super->tagVal); free(super); return -1; } @@ -346,7 +349,7 @@ int tsdbCreateTable(TsdbRepoT *repo, STableCfg *pCfg) { if (IS_CREATE_STABLE(pCfg)) { // TSDB_CHILD_TABLE table->type = TSDB_CHILD_TABLE; table->superUid = pCfg->superUid; - table->tagVal = tdDataRowDup(pCfg->tagValues); + table->tagVal = tdTagRowDup(pCfg->tagValues); } else { // TSDB_NORMAL_TABLE table->type = TSDB_NORMAL_TABLE; table->superUid = -1; @@ -433,7 +436,7 @@ static void tsdbFreeMemTable(SMemTable *pMemTable) { static int tsdbFreeTable(STable *pTable) { // TODO: finish this function if (pTable->type == TSDB_CHILD_TABLE) { - tdFreeDataRow(pTable->tagVal); + tdFreeTagRow(pTable->tagVal); } else { tdFreeSchema(pTable->schema); } @@ -571,7 +574,9 @@ static int tsdbRemoveTableFromIndex(STsdbMeta *pMeta, STable *pTable) { STSchema* pSchema = tsdbGetTableTagSchema(pMeta, pTable); STColumn* pCol = &pSchema->columns[DEFAULT_TAG_INDEX_COLUMN]; - char* key = tdGetRowDataOfCol(pTable->tagVal, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset); + int16_t tagtype = 0; + char* key = tdQueryTagByID(pTable->tagVal, pCol->colId, &tagtype); + ASSERT(pCol->type == tagtype); SArray* res = tSkipListGet(pSTable->pIndex, key); size_t size = taosArrayGetSize(res); @@ -602,7 +607,8 @@ static int tsdbEstimateTableEncodeSize(STable *pTable) { size += tdGetSchemaEncodeSize(pTable->schema); size += tdGetSchemaEncodeSize(pTable->tagSchema); } else if (pTable->type == TSDB_CHILD_TABLE) { - size += dataRowLen(pTable->tagVal); + STagRow *pTagRow = (STagRow *)(pTable->tagVal); + size += dataRowLen(pTable->tagVal) + pTagRow->dataLen; } else { size += tdGetSchemaEncodeSize(pTable->schema); } diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c index ad3da226f6..4912f6f2e8 100644 --- a/src/tsdb/src/tsdbRead.c +++ b/src/tsdb/src/tsdbRead.c @@ -1746,9 +1746,9 @@ int32_t tableGroupComparFn(const void *p1, const void *p2, const void *param) { STColumn* pCol = schemaColAt(pTableGroupSupp->pTagSchema, colIndex); bytes = pCol->bytes; type = pCol->type; - - f1 = tdGetRowDataOfCol(pTable1->tagVal, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset); - f2 = tdGetRowDataOfCol(pTable2->tagVal, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset); + int16_t tgtype1, tgtype2 = 0; + f1 = tdQueryTagByID(pTable1->tagVal, pCol->colId, &tgtype1); + f2 = tdQueryTagByID(pTable2->tagVal, pCol->colId, &tgtype2); } int32_t ret = doCompare(f1, f2, type, bytes); @@ -1836,10 +1836,12 @@ bool indexedNodeFilterFp(const void* pNode, void* param) { val = (char*) elem->pTable->name; type = TSDB_DATA_TYPE_BINARY; } else { - STSchema* pTSchema = (STSchema*) pInfo->param; // todo table schema is identical to stable schema?? - - int32_t offset = pTSchema->columns[pInfo->colIndex].offset; - val = tdGetRowDataOfCol(elem->pTable->tagVal, pInfo->sch.type, TD_DATA_ROW_HEAD_SIZE + offset); +// STSchema* pTSchema = (STSchema*) pInfo->param; // todo table schema is identical to stable schema?? + int16_t type; + // int32_t offset = pTSchema->columns[pInfo->colIndex].offset; + // val = tdGetRowDataOfCol(elem->pTable->tagVal, pInfo->sch.type, TD_DATA_ROW_HEAD_SIZE + offset); + val = tdQueryTagByID(elem->pTable->tagVal, pInfo->colIndex, &type); + // ASSERT(pInfo->sch.type == type); } int32_t ret = 0; diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c index 9c415d6af7..96ca19e129 100644 --- a/src/vnode/src/vnodeWrite.c +++ b/src/vnode/src/vnodeWrite.c @@ -139,11 +139,13 @@ static int32_t vnodeProcessCreateTableMsg(SVnodeObj *pVnode, void *pCont, SRspRe char *pTagData = pTable->data + totalCols * sizeof(SSchema); int accumBytes = 0; - dataRow = tdNewDataRowFromSchema(pDestTagSchema); + //dataRow = tdNewDataRowFromSchema(pDestTagSchema); + dataRow = tdNewTagRowFromSchema(pDestTagSchema, numOfTags); for (int i = 0; i < numOfTags; i++) { STColumn *pTCol = schemaColAt(pDestTagSchema, i); - tdAppendColVal(dataRow, pTagData + accumBytes, pTCol->type, pTCol->bytes, pTCol->offset); +// tdAppendColVal(dataRow, pTagData + accumBytes, pTCol->type, pTCol->bytes, pTCol->offset); + tdAppendTagColVal(dataRow, pTagData + accumBytes, pTCol->type, pTCol->bytes, pTCol->colId); accumBytes += htons(pSchema[i + numOfColumns].bytes); } tsdbTableSetTagValue(&tCfg, dataRow, false); From 3b54b74554b278fa168a30543fc937f76c1007f5 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Tue, 26 May 2020 20:08:51 +0800 Subject: [PATCH 07/39] [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 08/39] [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 3882d0fa2d4f455f08e9a2a37518234096ecb778 Mon Sep 17 00:00:00 2001 From: Tao Liu Date: Tue, 26 May 2020 13:46:50 +0000 Subject: [PATCH 09/39] [TD-90]tagschema develop --- src/common/src/tdataformat.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/common/src/tdataformat.c b/src/common/src/tdataformat.c index 38d82f628b..5359d98535 100644 --- a/src/common/src/tdataformat.c +++ b/src/common/src/tdataformat.c @@ -162,10 +162,10 @@ int tdDeleteTagCol(SDataRow row, int16_t colId){ // delete tag value and updat return 0; }; -static int compTagVal(const void *key1, const void *key2) { - if (*(int16_t *)key1 > *(int16_t *)key2) { +static int compTagId(const void *key1, const void *key2) { + if (((STagCol *)key1)->colId > ((STagCol *)key2)->colId) { return 1; - } else if (*(int16_t *)key1 == *(int16_t *)key2) { + } else if (((STagCol *)key1)->colId == ((STagCol *)key2)->colId) { return 0; } else { return -1; @@ -178,8 +178,9 @@ void * tdQueryTagByID(SDataRow row, int16_t colId, int16_t *type) { //if find t STagCol *pBase = ((STagRow *)row)->tagCols; int16_t nCols = ((STagRow *)row)->ncols; + STagCol key = {colId,0,0}; - STagCol * stCol = taosbsearch(&colId, pBase, nCols, sizeof(STagCol), compTagVal, TD_EQ); + STagCol * stCol = taosbsearch(&key, pBase, nCols, sizeof(STagCol), compTagId, TD_EQ); if (NULL == stCol) { return NULL; } @@ -270,7 +271,7 @@ SDataRow tdTagRowDecode(SDataRow row) { free(trow); return NULL; } - char * pData = (char *)row + dataRowLen(row) + sizeof(int32_t); + char * pData = (char *)row + dataRowLen(row); memcpy(trow->pData, pData, trow->dataLen); return trow; } From 36daff8edca00c168c7867d67dc271ee77fc05f2 Mon Sep 17 00:00:00 2001 From: Tao Liu Date: Wed, 27 May 2020 02:47:00 +0000 Subject: [PATCH 10/39] [TD-90] tagschema develop --- src/common/src/tdataformat.c | 4 ---- src/tsdb/src/tsdbRead.c | 4 ++-- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/src/common/src/tdataformat.c b/src/common/src/tdataformat.c index 5359d98535..6a567c6e6c 100644 --- a/src/common/src/tdataformat.c +++ b/src/common/src/tdataformat.c @@ -173,13 +173,10 @@ static int compTagId(const void *key1, const void *key2) { } void * tdQueryTagByID(SDataRow row, int16_t colId, int16_t *type) { //if find tag, 0, else return -1; - //todo ASSERT(((STagRow *)row)->pData != NULL); - STagCol *pBase = ((STagRow *)row)->tagCols; int16_t nCols = ((STagRow *)row)->ncols; STagCol key = {colId,0,0}; - STagCol * stCol = taosbsearch(&key, pBase, nCols, sizeof(STagCol), compTagId, TD_EQ); if (NULL == stCol) { return NULL; @@ -196,7 +193,6 @@ int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int //ASSERT(bytes-2 == varDataTLen(value)); ASSERT(row != NULL); STagRow *pTagrow = row; - pTagrow->tagCols[pTagrow->ncols].colId = colId; pTagrow->tagCols[pTagrow->ncols].colType = type; pTagrow->tagCols[pTagrow->ncols].offset = pTagrow->dataLen; diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c index 720479130b..2220ebfd88 100644 --- a/src/tsdb/src/tsdbRead.c +++ b/src/tsdb/src/tsdbRead.c @@ -1847,10 +1847,10 @@ bool indexedNodeFilterFp(const void* pNode, void* param) { int16_t type; // int32_t offset = pTSchema->columns[pInfo->colIndex].offset; // val = tdGetRowDataOfCol(elem->pTable->tagVal, pInfo->sch.type, TD_DATA_ROW_HEAD_SIZE + offset); - val = tdQueryTagByID(elem->pTable->tagVal, pInfo->colIndex, &type); + val = tdQueryTagByID(elem->pTable->tagVal, pInfo->sch.colId, &type); // ASSERT(pInfo->sch.type == type); } - + //todo :the val is possible to be null, so check it out carefully int32_t ret = 0; if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) { if (pInfo->optr == TSDB_RELATION_IN) { From 9c11c959d519b3471e568bbfd2d15dd3ef282aea Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 27 May 2020 03:28:12 +0000 Subject: [PATCH 11/39] fix option uint print --- src/common/src/tglobal.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c index 763b3f5c22..b5252502a3 100644 --- a/src/common/src/tglobal.c +++ b/src/common/src/tglobal.c @@ -607,7 +607,7 @@ static void doInitGlobalConfig() { cfg.minValue = TSDB_MIN_CACHE_BLOCK_SIZE; cfg.maxValue = TSDB_MAX_CACHE_BLOCK_SIZE; cfg.ptrLength = 0; - cfg.unitType = TAOS_CFG_UTYPE_BYTE; + cfg.unitType = TAOS_CFG_UTYPE_Mb; taosInitConfigOption(cfg); cfg.option = "blocks"; @@ -617,7 +617,7 @@ static void doInitGlobalConfig() { cfg.minValue = TSDB_MIN_TOTAL_BLOCKS; cfg.maxValue = TSDB_MAX_TOTAL_BLOCKS; cfg.ptrLength = 0; - cfg.unitType = TAOS_CFG_UTYPE_BYTE; + cfg.unitType = TAOS_CFG_UTYPE_NONE; taosInitConfigOption(cfg); cfg.option = "days"; From 89da3e1479974f3fc72f0d586c2e8db2adf26e49 Mon Sep 17 00:00:00 2001 From: freemine Date: Wed, 27 May 2020 11:53:57 +0800 Subject: [PATCH 12/39] bugfix: alloc space for holding null-terminator --- src/query/src/qExecutor.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c index 47ad633e34..72d018d315 100644 --- a/src/query/src/qExecutor.c +++ b/src/query/src/qExecutor.c @@ -5298,7 +5298,7 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList, if (pColFilter->filterstr) { pColFilter->len = htobe64(pFilterMsg->len); - pColFilter->pz = (int64_t) calloc(1, pColFilter->len); + pColFilter->pz = (int64_t) calloc(1, pColFilter->len + 1 * TSDB_NCHAR_SIZE); // note: null-terminator memcpy((void *)pColFilter->pz, pMsg, pColFilter->len); pMsg += (pColFilter->len + 1); } else { From 6390536449ff7d3a42ae5e48a98150a5c19c0693 Mon Sep 17 00:00:00 2001 From: Tao Liu Date: Wed, 27 May 2020 04:01:34 +0000 Subject: [PATCH 13/39] [TD-90] add insert and modify tag schema --- src/common/inc/tdataformat.h | 2 +- src/common/src/tdataformat.c | 23 ++++++++++++++++++++--- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h index 497279fb27..528e9b2825 100644 --- a/src/common/inc/tdataformat.h +++ b/src/common/inc/tdataformat.h @@ -259,7 +259,7 @@ typedef struct { #define tagColSize(r) (sizeof(STagCol) + r.colLen) -int tdInsertTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId); //insert tag value and update all the information +int tdSetTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId); //insert tag value and update all the information int tdDeleteTagCol(SDataRow row, int16_t colId); // delete tag value and update all the information void * tdQueryTagByID(SDataRow row, int16_t colId, int16_t *type); //if find tag, 0, else return -1; int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int16_t colId); diff --git a/src/common/src/tdataformat.c b/src/common/src/tdataformat.c index 6a567c6e6c..8c6e26d5e1 100644 --- a/src/common/src/tdataformat.c +++ b/src/common/src/tdataformat.c @@ -152,8 +152,10 @@ SDataRow tdNewDataRowFromSchema(STSchema *pSchema) { return row; } -int tdInsertTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId){ //insert tag value and update all the information - //todo +int tdSetTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId){ //insert/update tag value and update all the information + ASSERT(((STagRow *)row)->pData != NULL); + //STagCol * stCol = tdQueryTagColByID() + return 0; }; @@ -172,7 +174,22 @@ static int compTagId(const void *key1, const void *key2) { } } -void * tdQueryTagByID(SDataRow row, int16_t colId, int16_t *type) { //if find tag, 0, else return -1; +/** + * Find tag structure by colId, if find, return tag structure, else return NULL; + */ +STagCol * tdQueryTagColByID(SDataRow row, int16_t colId, int flags) { //if find tag, 0, else return -1; + ASSERT(((STagRow *)row)->pData != NULL); + STagCol *pBase = ((STagRow *)row)->tagCols; + int16_t nCols = ((STagRow *)row)->ncols; + STagCol key = {colId,0,0}; + STagCol * stCol = taosbsearch(&key, pBase, nCols, sizeof(STagCol), compTagId, flags); + return stCol; +}; + +/** +* Find tag value by colId, if find, return tag value, else return NULL; +*/ +void * tdQueryTagByID(SDataRow row, int16_t colId, int16_t *type) { ASSERT(((STagRow *)row)->pData != NULL); STagCol *pBase = ((STagRow *)row)->tagCols; int16_t nCols = ((STagRow *)row)->ncols; From 056b24c724690bd4b1a50bf8aaf83aa108f98d65 Mon Sep 17 00:00:00 2001 From: Tao Liu Date: Wed, 27 May 2020 09:06:13 +0000 Subject: [PATCH 14/39] [TD-90] fix invalid read --- src/common/src/tdataformat.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/common/src/tdataformat.c b/src/common/src/tdataformat.c index 8c6e26d5e1..922c8bdea0 100644 --- a/src/common/src/tdataformat.c +++ b/src/common/src/tdataformat.c @@ -237,7 +237,7 @@ void * tdNewTagRowFromSchema(STSchema *pSchema, int16_t numofTags) { STagRow *row = malloc(size); if (row == NULL) return NULL; - int32_t datasize = pSchema->tlen - pSchema->flen; + int32_t datasize = pSchema->tlen; row->pData = malloc(datasize); if (NULL == row->pData) { free(row); From 83c75d875ef9b198f8ed62c3b1afe58da3744241 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 27 May 2020 09:11:28 +0000 Subject: [PATCH 15/39] TD-354 --- src/inc/tsdb.h | 2 + src/tsdb/inc/tsdbMain.h | 5 +- src/tsdb/src/tsdbMain.c | 17 +++- src/tsdb/src/tsdbMeta.c | 183 ++++++++++++++++++++----------------- src/util/inc/tcoding.h | 22 +++++ src/vnode/src/vnodeWrite.c | 6 ++ 6 files changed, 146 insertions(+), 89 deletions(-) diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h index bee68b81f5..341dee1476 100644 --- a/src/inc/tsdb.h +++ b/src/inc/tsdb.h @@ -92,6 +92,7 @@ typedef struct { STSchema * schema; STSchema * tagSchema; SDataRow tagValues; + char * sql; } STableCfg; int tsdbInitTableCfg(STableCfg *config, ETableType type, uint64_t uid, int32_t tid); @@ -101,6 +102,7 @@ int tsdbTableSetTagSchema(STableCfg *config, STSchema *pSchema, bool dup); int tsdbTableSetTagValue(STableCfg *config, SDataRow row, bool dup); int tsdbTableSetName(STableCfg *config, char *name, bool dup); int tsdbTableSetSName(STableCfg *config, char *sname, bool dup); +int tsdbTableSetStreamSql(STableCfg *config, char *sql, bool dup); void tsdbClearTableCfg(STableCfg *config); int32_t tsdbGetTableTagVal(TsdbRepoT *repo, STableId* id, int32_t colId, int16_t *type, int16_t *bytes, char **val); diff --git a/src/tsdb/inc/tsdbMain.h b/src/tsdb/inc/tsdbMain.h index 63d3eb349b..0839e0f8ff 100644 --- a/src/tsdb/inc/tsdbMain.h +++ b/src/tsdb/inc/tsdbMain.h @@ -85,12 +85,13 @@ typedef struct STable { TSKEY lastKey; // lastkey inserted in this table, initialized as 0, TODO: make a structure struct STable *next; // TODO: remove the next struct STable *prev; - tstr * name; // NOTE: there a flexible string here + tstr * name; // NOTE: there a flexible string here + char * sql; } STable; #define TSDB_GET_TABLE_LAST_KEY(tb) ((tb)->lastKey) -void * tsdbEncodeTable(STable *pTable, int *contLen); +void tsdbEncodeTable(STable *pTable, char *buf, int *contLen); STable *tsdbDecodeTable(void *cont, int contLen); void tsdbFreeEncode(void *cont); diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c index 27473e805c..bddb3fcaff 100644 --- a/src/tsdb/src/tsdbMain.c +++ b/src/tsdb/src/tsdbMain.c @@ -446,7 +446,7 @@ int32_t tsdbInsertData(TsdbRepoT *repo, SSubmitMsg *pMsg, SShellSubmitRspMsg * p */ int tsdbInitTableCfg(STableCfg *config, ETableType type, uint64_t uid, int32_t tid) { if (config == NULL) return -1; - if (type != TSDB_NORMAL_TABLE && type != TSDB_CHILD_TABLE) return -1; + if (type != TSDB_CHILD_TABLE && type != TSDB_NORMAL_TABLE && type != TSDB_STREAM_TABLE) return -1; memset((void *)config, 0, sizeof(STableCfg)); @@ -455,6 +455,7 @@ int tsdbInitTableCfg(STableCfg *config, ETableType type, uint64_t uid, int32_t t config->tableId.uid = uid; config->tableId.tid = tid; config->name = NULL; + config->sql = NULL; return 0; } @@ -540,12 +541,26 @@ int tsdbTableSetSName(STableCfg *config, char *sname, bool dup) { return 0; } +int tsdbTableSetStreamSql(STableCfg *config, char *sql, bool dup) { + if (config->type != TSDB_STREAM_TABLE) return -1; + + if (dup) { + config->sql = strdup(sql); + if (config->sql == NULL) return -1; + } else { + config->sql = sql; + } + + return 0; +} + void tsdbClearTableCfg(STableCfg *config) { if (config->schema) tdFreeSchema(config->schema); if (config->tagSchema) tdFreeSchema(config->tagSchema); if (config->tagValues) tdFreeDataRow(config->tagValues); tfree(config->name); tfree(config->sname); + tfree(config->sql); } int tsdbInitSubmitBlkIter(SSubmitBlk *pBlock, SSubmitBlkIter *pIter) { diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c index 95680f95c4..427e15de37 100644 --- a/src/tsdb/src/tsdbMeta.c +++ b/src/tsdb/src/tsdbMeta.c @@ -15,7 +15,6 @@ static int32_t tsdbCheckTableCfg(STableCfg *pCfg); static int tsdbAddTableToMeta(STsdbMeta *pMeta, STable *pTable, bool addIdx); static int tsdbAddTableIntoIndex(STsdbMeta *pMeta, STable *pTable); static int tsdbRemoveTableFromIndex(STsdbMeta *pMeta, STable *pTable); -static int tsdbEstimateTableEncodeSize(STable *pTable); static int tsdbRemoveTableFromMeta(STsdbMeta *pMeta, STable *pTable, bool rmFromIdx); /** @@ -28,16 +27,10 @@ static int tsdbRemoveTableFromMeta(STsdbMeta *pMeta, STable *pTable, bool rm * @return binary content for success * NULL fro failure */ -void *tsdbEncodeTable(STable *pTable, int *contLen) { - if (pTable == NULL) return NULL; +void tsdbEncodeTable(STable *pTable, char *buf, int *contLen) { + if (pTable == NULL) return; - *contLen = tsdbEstimateTableEncodeSize(pTable); - if (*contLen < 0) return NULL; - - void *ret = calloc(1, *contLen); - if (ret == NULL) return NULL; - - void *ptr = ret; + void *ptr = buf; T_APPEND_MEMBER(ptr, pTable, STable, type); // Encode name, todo refactor *(int *)ptr = varDataLen(pTable->name); @@ -59,7 +52,11 @@ void *tsdbEncodeTable(STable *pTable, int *contLen) { ptr = tdEncodeSchema(ptr, pTable->schema); } - return ret; + if (pTable->type == TSDB_STREAM_TABLE) { + ptr = taosEncodeString(ptr, pTable->sql); + } + + *contLen = (char *)ptr - buf; } /** @@ -97,10 +94,15 @@ STable *tsdbDecodeTable(void *cont, int contLen) { pTable->tagSchema = tdDecodeSchema(&ptr); } else if (pTable->type == TSDB_CHILD_TABLE) { pTable->tagVal = tdDataRowDup(ptr); + ptr = POINTER_SHIFT(ptr, dataRowLen(pTable->tagVal)); } else { pTable->schema = tdDecodeSchema(&ptr); } + if (pTable->type == TSDB_STREAM_TABLE) { + ptr = taosDecodeString(ptr, &(pTable->sql)); + } + return pTable; } @@ -211,7 +213,7 @@ int32_t tsdbFreeMeta(STsdbMeta *pMeta) { } STSchema *tsdbGetTableSchema(STsdbMeta *pMeta, STable *pTable) { - if (pTable->type == TSDB_NORMAL_TABLE || pTable->type == TSDB_SUPER_TABLE) { + if (pTable->type == TSDB_NORMAL_TABLE || pTable->type == TSDB_SUPER_TABLE || pTable->type == TSDB_STREAM_TABLE) { return pTable->schema; } else if (pTable->type == TSDB_CHILD_TABLE) { STable *pSuper = tsdbGetTableByUid(pMeta, pTable->superUid); @@ -283,6 +285,67 @@ char* tsdbGetTableName(TsdbRepoT *repo, const STableId* id, int16_t* bytes) { } } +static STable *tsdbNewTable(STableCfg *pCfg, bool isSuper) { + STable *pTable = NULL; + size_t tsize = 0; + + pTable = (STable *)calloc(1, sizeof(STable)); + if (pTable == NULL) { + terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + goto _err; + } + + pTable->type = pCfg->type; + tsize = strnlen(pCfg->sname, TSDB_TABLE_NAME_LEN); + pTable->name = calloc(1, tsize + VARSTR_HEADER_SIZE + 1); + if (pTable->name == NULL) { + terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + goto _err; + } + STR_WITH_SIZE_TO_VARSTR(pTable->name, pCfg->sname, tsize); + + if (isSuper) { + pTable->type = TSDB_SUPER_TABLE; + pTable->tableId.uid = pCfg->superUid; + pTable->tableId.tid = -1; + pTable->superUid = TSDB_INVALID_SUPER_TABLE_ID; + pTable->schema = tdDupSchema(pCfg->schema); + pTable->tagSchema = tdDupSchema(pCfg->tagSchema); + + STColumn *pColSchema = schemaColAt(pTable->tagSchema, 0); + pTable->pIndex = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, pColSchema->type, pColSchema->bytes, 1, 0, 1, + getTagIndexKey); // Allow duplicate key, no lock + if (pTable->pIndex == NULL) { + terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + goto _err; + } + } else { + pTable->type = pCfg->type; + pTable->tableId.uid = pCfg->tableId.uid; + pTable->tableId.tid = pCfg->tableId.tid; + pTable->lastKey = TSKEY_INITIAL_VAL; + + if (pCfg->type == TSDB_CHILD_TABLE) { + pTable->superUid = pCfg->superUid; + pTable->tagVal = tdDataRowDup(pCfg->tagValues); + } else if (pCfg->type == TSDB_NORMAL_TABLE) { + pTable->superUid = -1; + pTable->schema = tdDupSchema(pCfg->schema); + } else { + ASSERT(pCfg->type == TSDB_STREAM_TABLE); + pTable->superUid = -1; + pTable->schema = tdDupSchema(pCfg->schema); + pTable->sql = strdup(pCfg->sql); + } + } + + return pTable; + +_err: + tsdbFreeTable(pTable); + return NULL; +} + int tsdbCreateTable(TsdbRepoT *repo, STableCfg *pCfg) { STsdbRepo *pRepo = (STsdbRepo *)repo; STsdbMeta *pMeta = pRepo->tsdbMeta; @@ -303,61 +366,19 @@ int tsdbCreateTable(TsdbRepoT *repo, STableCfg *pCfg) { super = tsdbGetTableByUid(pMeta, pCfg->superUid); if (super == NULL) { // super table not exists, try to create it newSuper = 1; - // TODO: use function to implement create table object - super = (STable *)calloc(1, sizeof(STable)); + super = tsdbNewTable(pCfg, true); if (super == NULL) return -1; - - super->type = TSDB_SUPER_TABLE; - super->tableId.uid = pCfg->superUid; - super->tableId.tid = -1; - super->superUid = TSDB_INVALID_SUPER_TABLE_ID; - super->schema = tdDupSchema(pCfg->schema); - super->tagSchema = tdDupSchema(pCfg->tagSchema); - super->tagVal = NULL; - - // todo refactor extract method - size_t size = strnlen(pCfg->sname, TSDB_TABLE_NAME_LEN); - super->name = calloc(1, size + VARSTR_HEADER_SIZE + 1); - STR_WITH_SIZE_TO_VARSTR(super->name, pCfg->sname, size); - - // index the first tag column - STColumn* pColSchema = schemaColAt(super->tagSchema, 0); - super->pIndex = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, pColSchema->type, pColSchema->bytes, - 1, 0, 1, getTagIndexKey); // Allow duplicate key, no lock - - if (super->pIndex == NULL) { - tdFreeSchema(super->schema); - tdFreeSchema(super->tagSchema); - tdFreeDataRow(super->tagVal); - free(super); - return -1; - } } else { if (super->type != TSDB_SUPER_TABLE) return -1; } } - STable *table = (STable *)calloc(1, sizeof(STable)); + STable *table = tsdbNewTable(pCfg, false); if (table == NULL) { - if (newSuper) tsdbFreeTable(super); - return -1; - } - - table->tableId = pCfg->tableId; - - size_t size = strnlen(pCfg->name, TSDB_TABLE_NAME_LEN); - table->name = calloc(1, size + VARSTR_HEADER_SIZE + 1); - STR_WITH_SIZE_TO_VARSTR(table->name, pCfg->name, size); - - table->lastKey = 0; - if (IS_CREATE_STABLE(pCfg)) { // TSDB_CHILD_TABLE - table->type = TSDB_CHILD_TABLE; - table->superUid = pCfg->superUid; - table->tagVal = tdDataRowDup(pCfg->tagValues); - } else { // TSDB_NORMAL_TABLE - table->type = TSDB_NORMAL_TABLE; - table->superUid = -1; - table->schema = tdDupSchema(pCfg->schema); + if (newSuper) { + tsdbFreeTable(super); + return -1; + } } // Register to meta @@ -372,15 +393,15 @@ int tsdbCreateTable(TsdbRepoT *repo, STableCfg *pCfg) { // Write to meta file int bufLen = 0; + char *buf = malloc(4096); if (newSuper) { - void *buf = tsdbEncodeTable(super, &bufLen); + tsdbEncodeTable(super, buf, &bufLen); tsdbInsertMetaRecord(pMeta->mfh, super->tableId.uid, buf, bufLen); - tsdbFreeEncode(buf); } - void *buf = tsdbEncodeTable(table, &bufLen); + tsdbEncodeTable(table, buf, &bufLen); tsdbInsertMetaRecord(pMeta->mfh, table->tableId.uid, buf, bufLen); - tsdbFreeEncode(buf); + tfree(buf); return 0; } @@ -438,13 +459,18 @@ static void tsdbFreeMemTable(SMemTable *pMemTable) { } static int tsdbFreeTable(STable *pTable) { - // TODO: finish this function + if (pTable == NULL) return 0; + if (pTable->type == TSDB_CHILD_TABLE) { tdFreeDataRow(pTable->tagVal); } else { tdFreeSchema(pTable->schema); } + if (pTable->type == TSDB_STREAM_TABLE) { + tfree(pTable->sql); + } + // Free content if (TSDB_TABLE_IS_SUPER_TABLE(pTable)) { tdFreeSchema(pTable->tagSchema); @@ -491,6 +517,9 @@ static int tsdbAddTableToMeta(STsdbMeta *pMeta, STable *pTable, bool addIdx) { if (pTable->type == TSDB_CHILD_TABLE && addIdx) { // add STABLE to the index tsdbAddTableIntoIndex(pMeta, pTable); } + if (pTable->type == TSDB_STREAM_TABLE && addIdx) { + // TODO + } pMeta->nTables++; } @@ -522,7 +551,6 @@ static int tsdbRemoveTableFromMeta(STsdbMeta *pMeta, STable *pTable, bool rmFrom tSkipListDestroyIter(pIter); - // TODO: Remove the table from the list if (pTable->prev != NULL) { pTable->prev->next = pTable->next; if (pTable->next != NULL) { @@ -536,6 +564,9 @@ static int tsdbRemoveTableFromMeta(STsdbMeta *pMeta, STable *pTable, bool rmFrom if (pTable->type == TSDB_CHILD_TABLE && rmFromIdx) { tsdbRemoveTableFromIndex(pMeta, pTable); } + if (pTable->type == TSDB_STREAM_TABLE && rmFromIdx) { + // TODO + } pMeta->nTables--; } @@ -598,26 +629,6 @@ static int tsdbRemoveTableFromIndex(STsdbMeta *pMeta, STable *pTable) { return 0; } -static int tsdbEstimateTableEncodeSize(STable *pTable) { - int size = 0; - size += T_MEMBER_SIZE(STable, type); - size += sizeof(int) + varDataLen(pTable->name); - size += T_MEMBER_SIZE(STable, tableId); - size += T_MEMBER_SIZE(STable, superUid); - size += T_MEMBER_SIZE(STable, sversion); - - if (pTable->type == TSDB_SUPER_TABLE) { - size += tdGetSchemaEncodeSize(pTable->schema); - size += tdGetSchemaEncodeSize(pTable->tagSchema); - } else if (pTable->type == TSDB_CHILD_TABLE) { - size += dataRowLen(pTable->tagVal); - } else { - size += tdGetSchemaEncodeSize(pTable->schema); - } - - return size; -} - char *getTSTupleKey(const void * data) { SDataRow row = (SDataRow)data; return POINTER_SHIFT(row, TD_DATA_ROW_HEAD_SIZE); diff --git a/src/util/inc/tcoding.h b/src/util/inc/tcoding.h index b4f7f596c5..cc9caf71d0 100644 --- a/src/util/inc/tcoding.h +++ b/src/util/inc/tcoding.h @@ -217,6 +217,28 @@ static FORCE_INLINE void *taosDecodeVariant64(void *buf, uint64_t *value) { return NULL; // error happened } +static FORCE_INLINE void *taosEncodeString(void *buf, char *value) { + size_t size = strlen(value); + + buf = taosEncodeVariant64(buf, size); + memcpy(buf, value, size); + + return POINTER_SHIFT(buf, size); +} + +static FORCE_INLINE void *taosDecodeString(void *buf, char **value) { + uint64_t size = 0; + + buf = taosDecodeVariant64(buf, &size); + *value = (char *)malloc(size + 1); + if (*value == NULL) return NULL; + memcpy(*value, buf, size); + + (*value)[size] = '\0'; + + return POINTER_SHIFT(buf, size); +} + #ifdef __cplusplus } #endif diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c index 9c415d6af7..25cd0983e5 100644 --- a/src/vnode/src/vnodeWrite.c +++ b/src/vnode/src/vnodeWrite.c @@ -106,6 +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); @@ -149,6 +150,11 @@ static int32_t vnodeProcessCreateTableMsg(SVnodeObj *pVnode, void *pCont, SRspRe tsdbTableSetTagValue(&tCfg, dataRow, false); } + if (pTable->tableType == TSDB_STREAM_TABLE) { + // TODO: set sql value + tsdbTableSetStreamSql(&tCfg, sql, false); + } + code = tsdbCreateTable(pVnode->tsdb, &tCfg); tdFreeDataRow(dataRow); tfree(pDestTagSchema); From cf6872796b965202907d083794424645ed72a844 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Wed, 27 May 2020 10:10:16 +0000 Subject: [PATCH 16/39] [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 160725945f5bdb8d5582ade19d9eafba78a7c5ef Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 27 May 2020 10:40:08 +0000 Subject: [PATCH 17/39] fix name bug --- src/tsdb/src/tsdbMeta.c | 25 +++++++++++++++++-------- 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c index 427e15de37..8345dc5f8b 100644 --- a/src/tsdb/src/tsdbMeta.c +++ b/src/tsdb/src/tsdbMeta.c @@ -296,13 +296,6 @@ static STable *tsdbNewTable(STableCfg *pCfg, bool isSuper) { } pTable->type = pCfg->type; - tsize = strnlen(pCfg->sname, TSDB_TABLE_NAME_LEN); - pTable->name = calloc(1, tsize + VARSTR_HEADER_SIZE + 1); - if (pTable->name == NULL) { - terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; - goto _err; - } - STR_WITH_SIZE_TO_VARSTR(pTable->name, pCfg->sname, tsize); if (isSuper) { pTable->type = TSDB_SUPER_TABLE; @@ -312,8 +305,16 @@ static STable *tsdbNewTable(STableCfg *pCfg, bool isSuper) { pTable->schema = tdDupSchema(pCfg->schema); pTable->tagSchema = tdDupSchema(pCfg->tagSchema); + tsize = strnlen(pCfg->sname, TSDB_TABLE_NAME_LEN); + pTable->name = calloc(1, tsize + VARSTR_HEADER_SIZE + 1); + if (pTable->name == NULL) { + terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + goto _err; + } + STR_WITH_SIZE_TO_VARSTR(pTable->name, pCfg->sname, tsize); + STColumn *pColSchema = schemaColAt(pTable->tagSchema, 0); - pTable->pIndex = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, pColSchema->type, pColSchema->bytes, 1, 0, 1, + pTable->pIndex = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, pColSchema->type, pColSchema->bytes, 1, 0, 0, getTagIndexKey); // Allow duplicate key, no lock if (pTable->pIndex == NULL) { terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; @@ -325,6 +326,14 @@ static STable *tsdbNewTable(STableCfg *pCfg, bool isSuper) { pTable->tableId.tid = pCfg->tableId.tid; pTable->lastKey = TSKEY_INITIAL_VAL; + tsize = strnlen(pCfg->name, TSDB_TABLE_NAME_LEN); + pTable->name = calloc(1, tsize + VARSTR_HEADER_SIZE + 1); + if (pTable->name == NULL) { + terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + goto _err; + } + STR_WITH_SIZE_TO_VARSTR(pTable->name, pCfg->name, tsize); + if (pCfg->type == TSDB_CHILD_TABLE) { pTable->superUid = pCfg->superUid; pTable->tagVal = tdDataRowDup(pCfg->tagValues); From d1003fedff1983e5165e931e03ebb994b0b9d68d Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Wed, 27 May 2020 10:57:38 +0000 Subject: [PATCH 18/39] [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 82a3dcab888f29736427b78e688a2745df4c0ecd Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Thu, 28 May 2020 01:33:38 +0800 Subject: [PATCH 19/39] [td-430] fix bug while client does not retrieve or paritally retrieve result from vnode. --- src/client/src/tscServer.c | 8 +++++--- src/client/src/tscSql.c | 26 +++++++++++--------------- src/client/src/tscUtil.c | 2 ++ 3 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c index 7d0ac09e66..a1c50b1518 100644 --- a/src/client/src/tscServer.c +++ b/src/client/src/tscServer.c @@ -217,10 +217,12 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) { STscObj *pObj = pSql->pTscObj; // tscTrace("%p msg:%s is received from server", pSql, taosMsg[rpcMsg->msgType]); - if (pSql->freed || pObj->signature != pObj) { + if (pObj->signature != pObj) { tscTrace("%p sql is already released or DB connection is closed, freed:%d pObj:%p signature:%p", pSql, pSql->freed, pObj, pObj->signature); - tscFreeSqlObj(pSql); + if (pSql != pObj->pSql) { + tscFreeSqlObj(pSql); + } rpcFreeCont(rpcMsg->pCont); return; } @@ -1867,8 +1869,8 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) { return TSDB_CODE_CLI_OUT_OF_MEMORY; } - free(pTableMeta); tscTrace("%p recv table meta: %"PRId64 ", tid:%d, name:%s", pSql, pTableMeta->uid, pTableMeta->sid, pTableMetaInfo->name); + free(pTableMeta); return TSDB_CODE_SUCCESS; } diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c index 14605a571d..7a6cce4d7f 100644 --- a/src/client/src/tscSql.c +++ b/src/client/src/tscSql.c @@ -576,26 +576,22 @@ void taos_free_result_imp(TAOS_RES *res, int keepCmd) { * for each subquery. Because the failure of execution tsProcessSql may trigger the callback function * be executed, and the retry efforts may result in double free the resources, e.g.,SRetrieveSupport */ - if ((pCmd->command == TSDB_SQL_SELECT || pCmd->command == TSDB_SQL_SHOW || pCmd->command == TSDB_SQL_RETRIEVE || - pCmd->command == TSDB_SQL_FETCH) && - (pRes->code != TSDB_CODE_QUERY_CANCELLED && ((pRes->numOfRows > 0 && pCmd->command < TSDB_SQL_LOCAL && pRes->completed == false) || - (pRes->code == TSDB_CODE_SUCCESS && pRes->numOfRows == 0 && pCmd->command == TSDB_SQL_SELECT && - pSql->pStream == NULL && pTableMetaInfo->pTableMeta != NULL)))) { + if ((pCmd->command == TSDB_SQL_SELECT || + pCmd->command == TSDB_SQL_SHOW || + pCmd->command == TSDB_SQL_RETRIEVE || + pCmd->command == TSDB_SQL_FETCH) && + (pRes->code != TSDB_CODE_QUERY_CANCELLED && ((pCmd->command < TSDB_SQL_LOCAL && pRes->completed == false) || + (pRes->code == TSDB_CODE_SUCCESS && pCmd->command == TSDB_SQL_SELECT && pSql->pStream == NULL && pTableMetaInfo->pTableMeta != NULL)))) { pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH; - tscTrace("%p code:%d, numOfRows:%d, command:%d", pSql, pRes->code, pRes->numOfRows, pCmd->command); + tscTrace("%p send msg to free qhandle in vnode, code:%d, numOfRows:%d, command:%s", pSql, pRes->code, pRes->numOfRows, + sqlCmd[pCmd->command]); pSql->freed = 1; tscProcessSql(pSql); - - /* - * If release connection msg is sent to vnode, the corresponding SqlObj for async query can not be freed instantly, - * since its free operation is delegated to callback function, which is tscProcessMsgFromServer. - */ - STscObj* pObj = pSql->pTscObj; - if (pObj->pSql == pSql) { - pObj->pSql = NULL; - } + + // waits for response and then goes on + sem_wait(&pSql->rspSem); } else { // if no free resource msg is sent to vnode, we free this object immediately. STscObj* pTscObj = pSql->pTscObj; diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c index ec9908ae96..4c8722ecea 100644 --- a/src/client/src/tscUtil.c +++ b/src/client/src/tscUtil.c @@ -423,6 +423,8 @@ void tscFreeSqlObj(SSqlObj* pSql) { tfree(pCmd->payload); pCmd->allocSize = 0; + + tfree(pSql->sqlstr); free(pSql); } From 5a601c83f137c982f0a265d6558acfa4f6180729 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 01:35:26 +0000 Subject: [PATCH 20/39] [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 1da4fa6aefb765f3219605dea5c799e48eca6306 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Thu, 28 May 2020 01:36:35 +0000 Subject: [PATCH 21/39] fix table encode and decode bug --- src/tsdb/src/tsdbMeta.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c index 8345dc5f8b..15de4df3fd 100644 --- a/src/tsdb/src/tsdbMeta.c +++ b/src/tsdb/src/tsdbMeta.c @@ -48,6 +48,7 @@ void tsdbEncodeTable(STable *pTable, char *buf, int *contLen) { ptr = tdEncodeSchema(ptr, pTable->tagSchema); } else if (pTable->type == TSDB_CHILD_TABLE) { dataRowCpy(ptr, pTable->tagVal); + ptr = POINTER_SHIFT(ptr, dataRowLen(pTable->tagVal)); } else { ptr = tdEncodeSchema(ptr, pTable->schema); } From 5c889fff5481b9433ede1af2b05696d2e412612f Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 02:13:38 +0000 Subject: [PATCH 22/39] [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 85c9508fb7dd606e628f062c429de8aef8412f20 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Thu, 28 May 2020 03:39:31 +0000 Subject: [PATCH 23/39] fix table/column_num.py coredump --- src/tsdb/src/tsdbMeta.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c index 5d2123a1d4..e320de9827 100644 --- a/src/tsdb/src/tsdbMeta.c +++ b/src/tsdb/src/tsdbMeta.c @@ -406,7 +406,7 @@ int tsdbCreateTable(TsdbRepoT *repo, STableCfg *pCfg) { // Write to meta file int bufLen = 0; - char *buf = malloc(4096); + char *buf = malloc(1024*1024); if (newSuper) { tsdbEncodeTable(super, buf, &bufLen); tsdbInsertMetaRecord(pMeta->mfh, super->tableId.uid, buf, bufLen); From a6c3ffd5403e3658af3af802ce685ac2519ddbdb Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 03:40:02 +0000 Subject: [PATCH 24/39] [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 25/39] [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 26/39] [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 27/39] [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 28/39] [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 29/39] [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 73eee9d80bde3dcde35d75f9437fda73b4d1f383 Mon Sep 17 00:00:00 2001 From: Bomin Zhang Date: Thu, 28 May 2020 15:25:56 +0800 Subject: [PATCH 30/39] fix possible dead loop in shellPrintNChar --- src/kit/shell/inc/shell.h | 1 - src/kit/shell/src/shellDarwin.c | 25 -------------------- src/kit/shell/src/shellEngine.c | 39 +++++++++++++++++++++++++++++--- src/kit/shell/src/shellLinux.c | 24 -------------------- src/kit/shell/src/shellWindows.c | 26 --------------------- 5 files changed, 36 insertions(+), 79 deletions(-) diff --git a/src/kit/shell/inc/shell.h b/src/kit/shell/inc/shell.h index 5400d9c5ba..54ac45583c 100644 --- a/src/kit/shell/inc/shell.h +++ b/src/kit/shell/inc/shell.h @@ -68,7 +68,6 @@ void get_history_path(char* history); void cleanup_handler(void* arg); void exitShell(); int shellDumpResult(TAOS* con, char* fname, int* error_no, bool printMode); -void shellPrintNChar(const char* str, int length, int width); void shellGetGrantInfo(void *con); int isCommentLine(char *line); diff --git a/src/kit/shell/src/shellDarwin.c b/src/kit/shell/src/shellDarwin.c index 987087d71f..98ea6510d7 100644 --- a/src/kit/shell/src/shellDarwin.c +++ b/src/kit/shell/src/shellDarwin.c @@ -349,31 +349,6 @@ void *shellLoopQuery(void *arg) { return NULL; } -void shellPrintNChar(const char *str, int length, int width) { - int pos = 0, cols = 0; - while (pos < length) { - wchar_t wc; - pos += mbtowc(&wc, str + pos, MB_CUR_MAX); - if (pos > length) { - break; - } - - int w = wcwidth(wc); - if (w > 0) { - if (width > 0 && cols + w > width) { - break; - } - printf("%lc", wc); - cols += w; - } - } - - for (; cols < width; cols++) { - putchar(' '); - } -} - - int get_old_terminal_mode(struct termios *tio) { /* Make sure stdin is a terminal. */ if (!isatty(STDIN_FILENO)) { diff --git a/src/kit/shell/src/shellEngine.c b/src/kit/shell/src/shellEngine.c index 4ef51eaa5a..5b4da875de 100644 --- a/src/kit/shell/src/shellEngine.c +++ b/src/kit/shell/src/shellEngine.c @@ -435,7 +435,6 @@ static int dumpResultToFile(const char* fname, TAOS_RES* result) { int num_fields = taos_num_fields(result); TAOS_FIELD *fields = taos_fetch_fields(result); - int32_t* length = taos_fetch_lengths(result); int precision = taos_result_precision(result); for (int col = 0; col < num_fields; col++) { @@ -448,6 +447,7 @@ static int dumpResultToFile(const char* fname, TAOS_RES* result) { int numOfRows = 0; do { + int32_t* length = taos_fetch_lengths(result); for (int i = 0; i < num_fields; i++) { if (i > 0) { fputc(',', fp); @@ -465,6 +465,39 @@ static int dumpResultToFile(const char* fname, TAOS_RES* result) { } +static void shellPrintNChar(const char *str, int length, int width) { + int pos = 0, cols = 0; + while (pos < length) { + wchar_t wc; + int bytes = mbtowc(&wc, str + pos, MB_CUR_MAX); + if (bytes == 0) { + break; + } + pos += bytes; + if (pos > length) { + break; + } + +#ifdef WINDOWS + int w = bytes; +#else + int w = wcwidth(wc); +#endif + if (w > 0) { + if (width > 0 && cols + w > width) { + break; + } + printf("%lc", wc); + cols += w; + } + } + + for (; cols < width; cols++) { + putchar(' '); + } +} + + static void printField(const char* val, TAOS_FIELD* field, int width, int32_t length, int precision) { if (val == NULL) { int w = width; @@ -523,7 +556,6 @@ static int verticalPrintResult(TAOS_RES* result) { int num_fields = taos_num_fields(result); TAOS_FIELD *fields = taos_fetch_fields(result); - int32_t* length = taos_fetch_lengths(result); int precision = taos_result_precision(result); int maxColNameLen = 0; @@ -537,6 +569,7 @@ static int verticalPrintResult(TAOS_RES* result) { int numOfRows = 0; do { printf("*************************** %d.row ***************************\n", numOfRows + 1); + int32_t* length = taos_fetch_lengths(result); for (int i = 0; i < num_fields; i++) { TAOS_FIELD* field = fields + i; @@ -631,7 +664,6 @@ static int horizontalPrintResult(TAOS_RES* result) { int num_fields = taos_num_fields(result); TAOS_FIELD *fields = taos_fetch_fields(result); - int32_t* length = taos_fetch_lengths(result); int precision = taos_result_precision(result); int width[TSDB_MAX_COLUMNS]; @@ -643,6 +675,7 @@ static int horizontalPrintResult(TAOS_RES* result) { int numOfRows = 0; do { + int32_t* length = taos_fetch_lengths(result); for (int i = 0; i < num_fields; i++) { putchar(' '); printField(row[i], fields + i, width[i], length[i], precision); diff --git a/src/kit/shell/src/shellLinux.c b/src/kit/shell/src/shellLinux.c index d8b3e9bb4d..b4b74eae3a 100644 --- a/src/kit/shell/src/shellLinux.c +++ b/src/kit/shell/src/shellLinux.c @@ -323,30 +323,6 @@ void *shellLoopQuery(void *arg) { return NULL; } -void shellPrintNChar(const char *str, int length, int width) { - int pos = 0, cols = 0; - while (pos < length) { - wchar_t wc; - pos += mbtowc(&wc, str + pos, MB_CUR_MAX); - if (pos > length) { - break; - } - - int w = wcwidth(wc); - if (w > 0) { - if (width > 0 && cols + w > width) { - break; - } - printf("%lc", wc); - cols += w; - } - } - - for (; cols < width; cols++) { - putchar(' '); - } -} - int get_old_terminal_mode(struct termios *tio) { /* Make sure stdin is a terminal. */ if (!isatty(STDIN_FILENO)) { diff --git a/src/kit/shell/src/shellWindows.c b/src/kit/shell/src/shellWindows.c index 440aa508ab..48545f537e 100644 --- a/src/kit/shell/src/shellWindows.c +++ b/src/kit/shell/src/shellWindows.c @@ -214,32 +214,6 @@ void *shellLoopQuery(void *arg) { return NULL; } -void shellPrintNChar(const char *str, int length, int width) { - int pos = 0, cols = 0; - while (pos < length) { - wchar_t wc; - int bytes = mbtowc(&wc, str + pos, MB_CUR_MAX); - pos += bytes; - if (pos > length) { - break; - } - - int w = bytes; - if (w > 0) { - if (width > 0 && cols + w > width) { - break; - } - printf("%lc", wc); - cols += w; - } - } - - for (; cols < width; cols++) { - putchar(' '); - } -} - - void get_history_path(char *history) { sprintf(history, "%s/%s", ".", HISTORY_FILE); } void exitShell() { exit(EXIT_SUCCESS); } From 8c49afc1f47ddc5cd00e2f42ff13964d7e85dbf8 Mon Sep 17 00:00:00 2001 From: Bomin Zhang Date: Thu, 28 May 2020 16:15:24 +0800 Subject: [PATCH 31/39] fix incorrect length in nchar conversion --- src/client/src/tscSubquery.c | 5 ++++- src/util/inc/tutil.h | 2 +- src/util/src/tutil.c | 16 ++++++++-------- 3 files changed, 13 insertions(+), 10 deletions(-) diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c index 3a205924bf..8c741dfdc8 100644 --- a/src/client/src/tscSubquery.c +++ b/src/client/src/tscSubquery.c @@ -1888,11 +1888,14 @@ static void transferNcharData(SSqlObj *pSql, int32_t columnIndex, TAOS_FIELD *pF /* string terminated char for binary data*/ memset(pRes->buffer[columnIndex], 0, pField->bytes + TSDB_NCHAR_SIZE); - if (taosUcs4ToMbs(pRes->tsrow[columnIndex], pField->bytes - VARSTR_HEADER_SIZE, pRes->buffer[columnIndex])) { + int32_t length = taosUcs4ToMbs(pRes->tsrow[columnIndex], pRes->length[columnIndex], pRes->buffer[columnIndex]); + if ( length >= 0 ) { pRes->tsrow[columnIndex] = pRes->buffer[columnIndex]; + pRes->length[columnIndex] = length; } else { tscError("%p charset:%s to %s. val:%ls convert failed.", pSql, DEFAULT_UNICODE_ENCODEC, tsCharset, pRes->tsrow[columnIndex]); pRes->tsrow[columnIndex] = NULL; + pRes->length[columnIndex] = 0; } } } diff --git a/src/util/inc/tutil.h b/src/util/inc/tutil.h index 3a0a1920af..5dcb6e406f 100644 --- a/src/util/inc/tutil.h +++ b/src/util/inc/tutil.h @@ -145,7 +145,7 @@ bool taosMbsToUcs4(char *mbs, size_t mbs_len, char *ucs4, int32_t ucs4_max_len, int tasoUcs4Compare(void* f1_ucs4, void *f2_ucs4, int bytes); -bool taosUcs4ToMbs(void *ucs4, int32_t ucs4_max_len, char *mbs); +int32_t taosUcs4ToMbs(void *ucs4, int32_t ucs4_max_len, char *mbs); bool taosValidateEncodec(const char *encodec); diff --git a/src/util/src/tutil.c b/src/util/src/tutil.c index 989273e051..2392560370 100644 --- a/src/util/src/tutil.c +++ b/src/util/src/tutil.c @@ -447,10 +447,10 @@ int tasoUcs4Compare(void* f1_ucs4, void *f2_ucs4, int bytes) { int32_t ucs4_max_len = bytes + 4; char *f1_mbs = calloc(bytes, 1); char *f2_mbs = calloc(bytes, 1); - if (!taosUcs4ToMbs(f1_ucs4, ucs4_max_len, f1_mbs)) { + if (taosUcs4ToMbs(f1_ucs4, ucs4_max_len, f1_mbs) < 0) { return -1; } - if (!taosUcs4ToMbs(f2_ucs4, ucs4_max_len, f2_mbs)) { + if (taosUcs4ToMbs(f2_ucs4, ucs4_max_len, f2_mbs) < 0) { return -1; } int32_t ret = strcmp(f1_mbs, f2_mbs); @@ -464,29 +464,29 @@ int tasoUcs4Compare(void* f1_ucs4, void *f2_ucs4, int bytes) { #endif } -bool taosUcs4ToMbs(void *ucs4, int32_t ucs4_max_len, char *mbs) { +int32_t taosUcs4ToMbs(void *ucs4, int32_t ucs4_max_len, char *mbs) { #ifdef USE_LIBICONV iconv_t cd = iconv_open(tsCharset, DEFAULT_UNICODE_ENCODEC); size_t ucs4_input_len = ucs4_max_len; size_t outLen = ucs4_max_len; if (iconv(cd, (char **)&ucs4, &ucs4_input_len, &mbs, &outLen) == -1) { iconv_close(cd); - return false; + return -1; } iconv_close(cd); - return true; + return (int32_t)(ucs4_max_len - outLen); #else mbstate_t state = {0}; int32_t len = (int32_t) wcsnrtombs(NULL, (const wchar_t **) &ucs4, ucs4_max_len / 4, 0, &state); if (len < 0) { - return false; + return -1; } memset(&state, 0, sizeof(state)); len = wcsnrtombs(mbs, (const wchar_t **) &ucs4, ucs4_max_len / 4, (size_t) len, &state); if (len < 0) { - return false; + return -1; } - return true; + return len; #endif } From c773992e06fd22a31b86be5d5411bbca9fa5e83c Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Thu, 28 May 2020 17:32:48 +0800 Subject: [PATCH 32/39] fix resource leak in mgmtTable.c --- src/mnode/src/mgmtTable.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/mnode/src/mgmtTable.c b/src/mnode/src/mgmtTable.c index 53fbd64f87..f4c37a9b46 100644 --- a/src/mnode/src/mgmtTable.c +++ b/src/mnode/src/mgmtTable.c @@ -233,7 +233,10 @@ static int32_t mgmtChildTableActionDecode(SSdbOper *pOper) { if (pTable == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; int32_t len = strlen(pOper->rowData); - if (len > TSDB_TABLE_ID_LEN) return TSDB_CODE_INVALID_TABLE_ID; + if (len > TSDB_TABLE_ID_LEN) { + free(pTable); + return TSDB_CODE_INVALID_TABLE_ID; + } pTable->info.tableId = strdup(pOper->rowData); len++; From e92fec2db5a34082478d70b8cb554ca22034aaec Mon Sep 17 00:00:00 2001 From: Bomin Zhang Date: Wed, 27 May 2020 17:51:15 +0800 Subject: [PATCH 33/39] td-436: update limit in document --- documentation/webdocs/markdowndocs/Super Table-ch.md | 7 ++++--- documentation/webdocs/markdowndocs/Super Table.md | 6 +++--- documentation/webdocs/markdowndocs/TAOS SQL-ch.md | 6 +++--- documentation/webdocs/markdowndocs/TAOS SQL.md | 4 ++-- documentation/webdocs/markdowndocs/connector-ch.md | 2 +- 5 files changed, 13 insertions(+), 12 deletions(-) diff --git a/documentation/webdocs/markdowndocs/Super Table-ch.md b/documentation/webdocs/markdowndocs/Super Table-ch.md index 38e6f8c17f..626f695c27 100644 --- a/documentation/webdocs/markdowndocs/Super Table-ch.md +++ b/documentation/webdocs/markdowndocs/Super Table-ch.md @@ -53,10 +53,11 @@ STable从属于库，一个STable只属于一个库，但一个库可以有一 说明： - 1. TAGS列总长度不能超过512 bytes； + 1. TAGS列总长度不能超过64k bytes； 2. TAGS列的数据类型不能是timestamp； 3. TAGS列名不能与其他列名相同; 4. TAGS列名不能为预留关键字. + 5. TAGS总数的上限是128. - 显示已创建的超级表 @@ -114,7 +115,7 @@ INSERT INTO USING TAGS (, ...) VALUES ( ADD TAG ``` - 为STable增加一个新的标签，并指定新标签的类型。标签总数不能超过6个。 + 为STable增加一个新的标签，并指定新标签的类型。标签总数不能超过128个。 - 删除标签 @@ -202,7 +203,7 @@ INSERT INTO therm4 VALUES ('2018-01-01 00:00:00.000', 23); ###3:按标签聚合查询 -查询位于北京(beijing)和天津(tianjing)两个地区的温度传感器采样值的数量count(*)、平均温度avg(degree)、最高温度max(degree)、最低温度min(degree)，并将结果按所处地域(location)和传感器类型(type)进行聚合。 +查询位于北京(beijing)和天津(tianjin)两个地区的温度传感器采样值的数量count(*)、平均温度avg(degree)、最高温度max(degree)、最低温度min(degree)，并将结果按所处地域(location)和传感器类型(type)进行聚合。 ```mysql SELECT COUNT(*), AVG(degree), MAX(degree), MIN(degree) diff --git a/documentation/webdocs/markdowndocs/Super Table.md b/documentation/webdocs/markdowndocs/Super Table.md index efc95c5f79..6c80c2097c 100644 --- a/documentation/webdocs/markdowndocs/Super Table.md +++ b/documentation/webdocs/markdowndocs/Super Table.md @@ -22,11 +22,11 @@ New keyword "tags" is introduced, where tag_name is the tag name, and tag_type i Note： -1. The bytes of all tags together shall be less than 512 +1. The bytes of all tags together shall be less than 64k 2. Tag's data type can not be time stamp 3. Tag name shall be different from the field name 4. Tag name shall not be the same as system keywords -5. Maximum number of tags is 6 +5. Maximum number of tags is 128 For example: @@ -168,7 +168,7 @@ You can add, delete and change the tags for a STable, and you can change the tag ALTER TABLE ADD TAG ``` -It adds a new tag to the STable with a data type. The maximum number of tags is 6. +It adds a new tag to the STable with a data type. The maximum number of tags is 128. ### Drop a Tag diff --git a/documentation/webdocs/markdowndocs/TAOS SQL-ch.md b/documentation/webdocs/markdowndocs/TAOS SQL-ch.md index cd184cbc71..81fc3ffcc4 100644 --- a/documentation/webdocs/markdowndocs/TAOS SQL-ch.md +++ b/documentation/webdocs/markdowndocs/TAOS SQL-ch.md @@ -63,7 +63,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic | 3 | BIGINT | 8 | 长整型，范围 [-2^63+1, 2^63-1], -2^63用于NULL | | 4 | FLOAT | 4 | 浮点型，有效位数6-7，范围 [-3.4E38, 3.4E38] | | 5 | DOUBLE | 8 | 双精度浮点型，有效位数15-16，范围 [-1.7E308, 1.7E308] | -| 6 | BINARY | 自定义 | 用于记录字符串，最长不能超过504 bytes。binary仅支持字符串输入，字符串两端使用单引号引用，否则英文全部自动转化为小写。使用时须指定大小，如binary(20)定义了最长为20个字符的字符串，每个字符占1byte的存储空间。如果用户字符串超出20字节，将被自动截断。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示， 即 **\’**。 | +| 6 | BINARY | 自定义 | 用于记录字符串，理论上，最长可以有65526字节，但由于每行数据最多64K字节，实际上限一般小于理论值。 binary仅支持字符串输入，字符串两端使用单引号引用，否则英文全部自动转化为小写。使用时须指定大小，如binary(20)定义了最长为20个字符的字符串，每个字符占1byte的存储空间。如果用户字符串超出20字节，将被自动截断。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示， 即 **\’**。 | | 7 | SMALLINT | 2 | 短整型， 范围 [-32767, 32767], -32768用于NULL | | 8 | TINYINT | 1 | 单字节整型，范围 [-127, 127], -128用于NULL | | 9 | BOOL | 1 | 布尔型，{true, false} | @@ -106,7 +106,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic ```mysql CREATE TABLE [IF NOT EXISTS] tb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]) ``` - 说明：1）表的第一个字段必须是TIMESTAMP，并且系统自动将其设为主键；2）表的每行长度不能超过4096字节；3）使用数据类型binary或nchar，需指定其最长的字节数，如binary(20)，表示20字节。 + 说明：1）表的第一个字段必须是TIMESTAMP，并且系统自动将其设为主键；2）表的每行长度不能超过64K字节；3）使用数据类型binary或nchar，需指定其最长的字节数，如binary(20)，表示20字节。 - **删除数据表** @@ -402,7 +402,7 @@ count(tbname) | SELECT * FROM tb1 WHERE ts >= NOW - 1h ``` -- 查询表tb1从2018-06-01 08:00:00.000 到2018-06-02 08:00:00.000时间范围，并且clo3的字符串是'nny'结尾的记录，结果按照时间戳降序 +- 查询表tb1从2018-06-01 08:00:00.000 到2018-06-02 08:00:00.000时间范围，并且col3的字符串是'nny'结尾的记录，结果按照时间戳降序 ```mysql SELECT * FROM tb1 WHERE ts > '2018-06-01 08:00:00.000' AND ts <= '2018-06-02 08:00:00.000' AND col3 LIKE '%nny' ORDER BY ts DESC diff --git a/documentation/webdocs/markdowndocs/TAOS SQL.md b/documentation/webdocs/markdowndocs/TAOS SQL.md index 99aa73b435..2b9960b860 100644 --- a/documentation/webdocs/markdowndocs/TAOS SQL.md +++ b/documentation/webdocs/markdowndocs/TAOS SQL.md @@ -39,7 +39,7 @@ The full list of data types is listed below. For string types of data, we will | 6 | DOUBLE | 8 | A standard nullable double float type with 15-16 significant digits and a range of [-1.7E308, 1.7E308]​ | | 7 | BOOL | 1 | A nullable boolean type, [**`true`**, **`false`**] | | 8 | TIMESTAMP | 8 | A nullable timestamp type with the same usage as the primary column timestamp | -| 9 | BINARY(*M*) | *M* | A nullable string type whose length is *M*, any exceeded chars will be automatically truncated. This type of string only supports ASCii encoded chars. | +| 9 | BINARY(*M*) | *M* | A nullable string type whose length is *M*, any exceeded chars will be automatically truncated, the maximum length of *M* is 65526, but as maximum row size is 64K bytes, the actual upper limit will generally less than 65526. This type of string only supports ASCii encoded chars. | | 10 | NCHAR(*M*) | 4 * *M* | A nullable string type whose length is *M*, any exceeded chars will be truncated. The **`NCHAR`** type supports Unicode encoded chars. | All the keywords in a SQL statement are case-insensitive, but strings values are case-sensitive and must be quoted by a pair of `'` or `"`. To quote a `'` or a `"` , you can use the escape character `\`. @@ -86,7 +86,7 @@ All the keywords in a SQL statement are case-insensitive, but strings values are 1) The first column must be a `timestamp`, and the system will set it as the primary key. - 2) The record size is limited to 4096 bytes + 2) The record size is limited to 64k bytes 3) For `binary` or `nchar` data types, the length must be specified. For example, binary(20) means a binary data type with 20 bytes. diff --git a/documentation/webdocs/markdowndocs/connector-ch.md b/documentation/webdocs/markdowndocs/connector-ch.md index 47c8381f69..3cd8da1bd5 100644 --- a/documentation/webdocs/markdowndocs/connector-ch.md +++ b/documentation/webdocs/markdowndocs/connector-ch.md @@ -2,7 +2,7 @@ TDengine提供了丰富的应用程序开发接口，其中包括C/C++、JAVA、Python、RESTful、Go等，便于用户快速开发应用。 -注意：所以执行 SQL 语句的 API，例如 C/C++ Connector 中的 `tao_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。 +注意：所有执行 SQL 语句的 API，例如 C/C++ Connector 中的 `tao_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。 ## C/C++ Connector From b94905d0560aeb770a61a45e73393674e68b4b7e Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Thu, 28 May 2020 17:45:21 +0800 Subject: [PATCH 34/39] [td-409]fix bug that callback function is not set correctly in sub-insert object. --- src/client/src/tscSubquery.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c index 8c741dfdc8..c4fe0b202b 100644 --- a/src/client/src/tscSubquery.c +++ b/src/client/src/tscSubquery.c @@ -1763,7 +1763,12 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) { tscError("%p failed to malloc buffer for subObj, orderOfSub:%d, reason:%s", pSql, i, strerror(errno)); break; } - + + /* + * assign the callback function to fetchFp to make sure that the error process function can restore + * the callback function (multiVnodeInsertMerge) correctly. + */ + pNew->fetchFp = pNew->fp; pSql->pSubs[i] = pNew; tscTrace("%p sub:%p create subObj success. orderOfSub:%d", pSql, pNew, i); } From 0b4a5b130fc069caae2a625096328046fa689a2d Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 10:17:38 +0000 Subject: [PATCH 35/39] [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 7da305f43d0af84184ae4306a4b193c51ee821f2 Mon Sep 17 00:00:00 2001 From: Hui Li Date: Thu, 28 May 2020 18:57:28 +0800 Subject: [PATCH 36/39] [add cluster sim case] --- .../dn3_mn1_replica2_wal1_AddDelDnode.sim | 266 ++++++++++++++++++ 1 file changed, 266 insertions(+) create mode 100644 tests/script/unique/arbitrator/dn3_mn1_replica2_wal1_AddDelDnode.sim diff --git a/tests/script/unique/arbitrator/dn3_mn1_replica2_wal1_AddDelDnode.sim b/tests/script/unique/arbitrator/dn3_mn1_replica2_wal1_AddDelDnode.sim new file mode 100644 index 0000000000..583134c761 --- /dev/null +++ b/tests/script/unique/arbitrator/dn3_mn1_replica2_wal1_AddDelDnode.sim @@ -0,0 +1,266 @@ +system sh/stop_dnodes.sh +system sh/deploy.sh -n dnode1 -i 1 +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/deploy.sh -n dnode5 -i 5 + +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 dnode5 -c numOfMPeers -v 1 + +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +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 dnode5 -c walLevel -v 1 + +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 dnode3 -c balanceInterval -v 10 +system sh/cfg.sh -n dnode4 -c balanceInterval -v 10 +system sh/cfg.sh -n dnode5 -c balanceInterval -v 10 + +system sh/cfg.sh -n dnode1 -c numOfTotalVnodes -v 200 +system sh/cfg.sh -n dnode2 -c numOfTotalVnodes -v 4 +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 arbitrator -v $arbitrator +system sh/cfg.sh -n dnode2 -c arbitrator -v $arbitrator +system sh/cfg.sh -n dnode3 -c arbitrator -v $arbitrator +system sh/cfg.sh -n dnode4 -c arbitrator -v $arbitrator +system sh/cfg.sh -n dnode5 -c arbitrator -v $arbitrator + +system sh/cfg.sh -n dnode1 -c offlineThreshold -v 20 +system sh/cfg.sh -n dnode2 -c offlineThreshold -v 20 +system sh/cfg.sh -n dnode3 -c offlineThreshold -v 20 +system sh/cfg.sh -n dnode4 -c offlineThreshold -v 20 +system sh/cfg.sh -n dnode5 -c offlineThreshold -v 20 + +system sh/cfg.sh -n dnode1 -c enableCoreFile -v 1 +system sh/cfg.sh -n dnode2 -c enableCoreFile -v 1 +system sh/cfg.sh -n dnode3 -c enableCoreFile -v 1 +system sh/cfg.sh -n dnode4 -c enableCoreFile -v 1 +system sh/cfg.sh -n dnode5 -c enableCoreFile -v 1 + +print ============== step0: start tarbitrator +system sh/exec_tarbitrator.sh -s start + +print ============== step1: start dnode1, only deploy mnode +system sh/exec_up.sh -n dnode1 -s start +sleep 3000 +sql connect + +print ============== step2: start dnode2/dnode3 and add into cluster, then create database, create table , and insert data +system sh/exec_up.sh -n dnode2 -s start +system sh/exec_up.sh -n dnode3 -s start +sleep 1000 +sql create dnode $hostname2 +sql create dnode $hostname3 + +$rowNum = 100 +$tblNum = 16 +$totalRows = 0 +$tsStart = 1420041600000 + +$db = db +sql create database $db replica 2 maxTables 4 +sql use $db + +# create table , insert data +$stb = stb +sql create table $stb (ts timestamp, c1 int) tags(t1 int) + + +$i = 0 +while $i < $tblNum + $tb = tb . $i + sql create table $tb using $stb tags( $i ) + + $x = 0 + while $x < $rowNum + $ts = $tsStart + $x + sql insert into $tb values ( $ts + 0a , $x ) ( $ts + 1a , $x ) ( $ts + 2a , $x ) ( $ts + 3a , $x ) ( $ts + 4a , $x ) ( $ts + 5a , $x ) ( $ts + 6a , $x ) ( $ts + 7a , $x ) ( $ts + 8a , $x ) ( $ts + 9a , $x ) ( $ts + 10a , $x ) ( $ts + 11a , $x ) ( $ts + 12a , $x ) ( $ts + 13a , $x ) ( $ts + 14a , $x ) ( $ts + 15a , $x ) ( $ts + 16a , $x ) ( $ts + 17a , $x ) ( $ts + 18a , $x ) ( $ts + 19a , $x ) ( $ts + 20a , $x ) ( $ts + 21a , $x ) ( $ts + 22a , $x ) ( $ts + 23a , $x ) ( $ts + 24a , $x ) ( $ts + 25a , $x ) ( $ts + 26a , $x ) ( $ts + 27a , $x ) ( $ts + 28a , $x ) ( $ts + 29a , $x ) ( $ts + 30a , $x ) ( $ts + 31a , $x ) ( $ts + 32a , $x ) ( $ts + 33a , $x ) ( $ts + 34a , $x ) ( $ts + 25a , $x ) ( $ts + 26a , $x ) ( $ts + 27a , $x ) ( $ts + 28a , $x ) ( $ts + 29a , $x ) ( $ts + 30a , $x ) ( $ts + 31a , $x ) ( $ts + 32a , $x ) ( $ts + 33a , $x ) ( $ts + 34a , $x ) ( $ts + 35a , $x ) ( $ts + 36a , $x ) ( $ts + 37a , $x ) ( $ts + 38a , $x ) ( $ts + 39a , $x ) ( $ts + 40a , $x ) ( $ts + 41a , $x ) ( $ts + 42a , $x ) ( $ts + 43a , $x ) ( $ts + 44a , $x ) ( $ts + 45a , $x ) ( $ts + 46a , $x ) ( $ts + 47a , $x ) ( $ts + 48a , $x ) ( $ts + 49a , $x ) ( $ts + 50a , $x ) ( $ts + 51a , $x ) ( $ts + 52a , $x ) ( $ts + 53a , $x ) ( $ts + 54a , $x ) ( $ts + 55a , $x ) ( $ts + 56a , $x ) ( $ts + 57a , $x ) ( $ts + 58a , $x ) ( $ts + 59a , $x ) + $x = $x + 60 + endw + $totalRows = $totalRows + $x + print info: inserted $x rows into $tb and totalRows: $totalRows + $i = $i + 1 +endw + +print info: select count(*) from $stb +sleep 1000 +sql reset query cache +sleep 1000 +sql select count(*) from $stb +print data00 $data00 +if $data00 != $totalRows then + return -1 +endi + +print ============== step3: add one new dnode4 expect auto balancing +system sh/exec_up.sh -n dnode4 -s start +sql create dnode $hostname4 +sleep 10000 +sql select count(*) from $stb +print data00 $data00 +if $data00 != $totalRows then + return -1 +endi + + +print ============== step4: stop dnode3, after offlineThreshold, dnode3 will be dropped for cluster +system sh/exec_up.sh -n dnode3 -s stop +sql select count(*) from $stb +print data00 $data00 +if $data00 != $totalRows then + return -1 +endi + +#sleep 3000 +#sql show dnodes +#print $data0_1 $data1_1 $data2_1 $data3_1 $data4_1 +#print $data0_2 $data1_2 $data2_2 $data3_2 $data4_2 +#print $data0_3 $data1_3 $data2_3 $data3_3 $data4_3 +#print $data0_4 $data1_4 $data2_4 $data3_4 $data4_4 +# +#$dnode1Status = $data4_1 +#$dnode2Status = $data4_2 +#$dnode3Status = $data4_3 +#$dnode4Status = $data4_4 +# +#if $dnode1Status != ready then +# return -1 +#endi +#if $dnode2Status != ready then +# return -1 +#endi +#if $dnode3Status != offline then +# return -1 +#endi +#if $dnode4Status != ready then +# return -1 +#endi + +sleep 30000 + +wait_drop: +sql show dnodes +if $rows != 3 then + sleep 3000 + goto wait_drop +endi +print $data0_1 $data1_1 $data2_1 $data3_1 $data4_1 +print $data0_2 $data1_2 $data2_2 $data3_2 $data4_2 +print $data0_3 $data1_3 $data2_3 $data3_3 $data4_3 +print $data0_4 $data1_4 $data2_4 $data3_4 $data4_4 +$dnode1Status = $data4_1 +$dnode2Status = $data4_2 +$dnode3Status = $data4_3 +$dnode4Status = $data4_4 + +if $dnode1Status != ready then + return -1 +endi +if $dnode2Status != ready then + return -1 +endi +if $dnode4Status != ready then + return -1 +endi + + +print ============== step5: start dnode5 and add into cluster , drop database +sql drop database $db +sleep 1000 +system sh/exec_up.sh -n dnode5 -s start +sql create dnode $hostname5 +sleep 3000 +wait_dnode5: +sql show dnodes +if $rows != 4 then + sleep 3000 + goto wait_dnode5 +endi +print $data0_1 $data1_1 $data2_1 $data3_1 $data4_1 +print $data0_2 $data1_2 $data2_2 $data3_2 $data4_2 +print $data0_3 $data1_3 $data2_3 $data3_3 $data4_3 +print $data0_4 $data1_4 $data2_4 $data3_4 $data4_4 +print $data0_5 $data1_5 $data2_5 $data3_5 $data4_5 +$dnode1Status = $data4_1 +$dnode2Status = $data4_2 +$dnode4Status = $data4_4 +$dnode5Status = $data4_5 + +if $dnode1Status != ready then + return -1 +endi +if $dnode2Status != ready then + return -1 +endi +if $dnode4Status != ready then + return -1 +endi +if $dnode5Status != ready then + return -1 +endi + + +print ============== step6: create database and table until not free vnodes +$rowNum = 100 +$tblNum = 24 +$totalRows = 0 +$tsStart = 1420041600000 + +$db = db1 +sql create database $db replica 2 maxTables 4 +sql use $db +$stb = stb +sql create table $stb (ts timestamp, c1 int) tags(t1 int) + + +# create table , insert data +$stb = stb +sql create table $stb (ts timestamp, c1 int) tags(t1 int) + + +$i = 0 +while $i < $tblNum + $tb = tb . $i + sql create table $tb using $stb tags( $i ) + + $x = 0 + while $x < $rowNum + $ts = $tsStart + $x + sql insert into $tb values ( $ts + 0a , $x ) ( $ts + 1a , $x ) ( $ts + 2a , $x ) ( $ts + 3a , $x ) ( $ts + 4a , $x ) ( $ts + 5a , $x ) ( $ts + 6a , $x ) ( $ts + 7a , $x ) ( $ts + 8a , $x ) ( $ts + 9a , $x ) ( $ts + 10a , $x ) ( $ts + 11a , $x ) ( $ts + 12a , $x ) ( $ts + 13a , $x ) ( $ts + 14a , $x ) ( $ts + 15a , $x ) ( $ts + 16a , $x ) ( $ts + 17a , $x ) ( $ts + 18a , $x ) ( $ts + 19a , $x ) ( $ts + 20a , $x ) ( $ts + 21a , $x ) ( $ts + 22a , $x ) ( $ts + 23a , $x ) ( $ts + 24a , $x ) ( $ts + 25a , $x ) ( $ts + 26a , $x ) ( $ts + 27a , $x ) ( $ts + 28a , $x ) ( $ts + 29a , $x ) ( $ts + 30a , $x ) ( $ts + 31a , $x ) ( $ts + 32a , $x ) ( $ts + 33a , $x ) ( $ts + 34a , $x ) ( $ts + 25a , $x ) ( $ts + 26a , $x ) ( $ts + 27a , $x ) ( $ts + 28a , $x ) ( $ts + 29a , $x ) ( $ts + 30a , $x ) ( $ts + 31a , $x ) ( $ts + 32a , $x ) ( $ts + 33a , $x ) ( $ts + 34a , $x ) ( $ts + 35a , $x ) ( $ts + 36a , $x ) ( $ts + 37a , $x ) ( $ts + 38a , $x ) ( $ts + 39a , $x ) ( $ts + 40a , $x ) ( $ts + 41a , $x ) ( $ts + 42a , $x ) ( $ts + 43a , $x ) ( $ts + 44a , $x ) ( $ts + 45a , $x ) ( $ts + 46a , $x ) ( $ts + 47a , $x ) ( $ts + 48a , $x ) ( $ts + 49a , $x ) ( $ts + 50a , $x ) ( $ts + 51a , $x ) ( $ts + 52a , $x ) ( $ts + 53a , $x ) ( $ts + 54a , $x ) ( $ts + 55a , $x ) ( $ts + 56a , $x ) ( $ts + 57a , $x ) ( $ts + 58a , $x ) ( $ts + 59a , $x ) + $x = $x + 60 + endw + $totalRows = $totalRows + $x + print info: inserted $x rows into $tb and totalRows: $totalRows + $i = $i + 1 +endw + +print info: select count(*) from $stb +sleep 2000 +sql reset query cache +sleep 3000 +sql select count(*) from $stb +print data00 $data00 +if $data00 != $totalRows then + return -1 +endi + +print ============== step7: drop dnode3, and system should prompt cannot drop dnodes +sql_error drop dnode $hostname3 +print ============== step8: add one new table, and system should prompt 'need more dnode' +sql_error create table tb_more using $stb tags( 1000 ) + From fe22dcf99bf78ca93b0dd3f2f83a348f6a07527c Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Thu, 28 May 2020 12:24:02 +0000 Subject: [PATCH 37/39] [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 38/39] [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 39/39] [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,