From 3c3e8fdbff2aa24659f5ba8c4704764c6fa7c058 Mon Sep 17 00:00:00 2001 From: xiao-77 Date: Tue, 24 Dec 2024 17:34:57 +0800 Subject: [PATCH 1/5] Add wal & config UT. --- source/libs/wal/inc/walInt.h | 2 +- source/libs/wal/src/walMeta.c | 2 +- source/libs/wal/test/walMetaTest.cpp | 305 +++++++++++++++++++++++---- source/util/src/tconfig.c | 3 +- source/util/test/cfgTest.cpp | 240 ++++++++++++++++++++- 5 files changed, 502 insertions(+), 50 deletions(-) diff --git a/source/libs/wal/inc/walInt.h b/source/libs/wal/inc/walInt.h index 1886541d62..14f6503941 100644 --- a/source/libs/wal/inc/walInt.h +++ b/source/libs/wal/inc/walInt.h @@ -157,7 +157,7 @@ int32_t walLoadMeta(SWal* pWal); int32_t walSaveMeta(SWal* pWal); int32_t walRemoveMeta(SWal* pWal); int32_t walRollFileInfo(SWal* pWal); - +int32_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx, int64_t* lastVer); int32_t walCheckAndRepairMeta(SWal* pWal); int32_t walCheckAndRepairIdx(SWal* pWal); diff --git a/source/libs/wal/src/walMeta.c b/source/libs/wal/src/walMeta.c index 3faeb53499..470a6b3f40 100644 --- a/source/libs/wal/src/walMeta.c +++ b/source/libs/wal/src/walMeta.c @@ -46,7 +46,7 @@ static FORCE_INLINE int walBuildTmpMetaName(SWal* pWal, char* buf) { return snprintf(buf, WAL_FILE_LEN, "%s/meta-ver.tmp", pWal->path); } -static FORCE_INLINE int32_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx, int64_t* lastVer) { +FORCE_INLINE int32_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx, int64_t* lastVer) { int32_t code = 0, lino = 0; int32_t sz = taosArrayGetSize(pWal->fileInfoSet); int64_t retVer = -1; diff --git a/source/libs/wal/test/walMetaTest.cpp b/source/libs/wal/test/walMetaTest.cpp index a958ad74e0..b2875bdca1 100644 --- a/source/libs/wal/test/walMetaTest.cpp +++ b/source/libs/wal/test/walMetaTest.cpp @@ -127,7 +127,7 @@ class WalRetentionEnv : public ::testing::Test { SWalCfg cfg; cfg.rollPeriod = -1; cfg.segSize = -1; - cfg.committed =-1; + cfg.committed = -1; cfg.retentionPeriod = -1; cfg.retentionSize = 0; cfg.rollPeriod = 0; @@ -146,6 +146,83 @@ class WalRetentionEnv : public ::testing::Test { const char* pathName = TD_TMP_DIR_PATH "wal_test"; }; +class WalSkipLevel : public ::testing::Test { + protected: + static void SetUpTestCase() { + int code = walInit(NULL); + ASSERT(code == 0); + } + + static void TearDownTestCase() { walCleanUp(); } + + void walResetEnv() { + TearDown(); + taosRemoveDir(pathName); + SetUp(); + } + + void SetUp() override { + SWalCfg cfg; + cfg.rollPeriod = -1; + cfg.segSize = -1; + cfg.committed = -1; + cfg.retentionPeriod = -1; + cfg.retentionSize = 0; + cfg.rollPeriod = 0; + cfg.vgId = 1; + cfg.level = TAOS_WAL_SKIP; + pWal = walOpen(pathName, &cfg); + ASSERT(pWal != NULL); + } + + void TearDown() override { + walClose(pWal); + pWal = NULL; + } + + SWal* pWal = NULL; + const char* pathName = TD_TMP_DIR_PATH "wal_test"; +}; + +class WalEncrypted : public ::testing::Test { + protected: + static void SetUpTestCase() { + int code = walInit(NULL); + ASSERT(code == 0); + } + + static void TearDownTestCase() { walCleanUp(); } + + void walResetEnv() { + TearDown(); + taosRemoveDir(pathName); + SetUp(); + } + + void SetUp() override { + SWalCfg cfg; + cfg.rollPeriod = -1; + cfg.segSize = -1; + cfg.committed = -1; + cfg.retentionPeriod = -1; + cfg.retentionSize = 0; + cfg.rollPeriod = 0; + cfg.vgId = 0; + cfg.level = TAOS_WAL_FSYNC; + cfg.encryptAlgorithm = 1; + pWal = walOpen(pathName, &cfg); + ASSERT(pWal != NULL); + } + + void TearDown() override { + walClose(pWal); + pWal = NULL; + } + + SWal* pWal = NULL; + const char* pathName = TD_TMP_DIR_PATH "wal_test"; +}; + TEST_F(WalCleanEnv, createNew) { walRollFileInfo(pWal); ASSERT(pWal->fileInfoSet != NULL); @@ -373,6 +450,183 @@ TEST_F(WalKeepEnv, readHandleRead) { walCloseReader(pRead); } +TEST_F(WalKeepEnv, walLogExist) { + walResetEnv(); + int code; + SWalReader* pRead = walOpenReader(pWal, NULL, 0); + ASSERT(pRead != NULL); + + int i; + for (i = 0; i < 100; i++) { + char newStr[100]; + sprintf(newStr, "%s-%d", ranStr, i); + int len = strlen(newStr); + code = walAppendLog(pWal, i, 0, syncMeta, newStr, len); + ASSERT_EQ(code, 0); + } + walLogExist(pWal, 0); + ASSERT_EQ(code, 0); + walCloseReader(pRead); +} + +TEST_F(WalKeepEnv, walScanLogGetLastVerHeadMissMatch) { + walResetEnv(); + int code; + do { + char newStr[100]; + sprintf(newStr, "%s-%d", ranStr, 0); + sprintf(newStr, "%s-%d", ranStr, 0); + int len = strlen(newStr); + code = walAppendLog(pWal, 0, 0, syncMeta, newStr, len); + } while (0); + + int i = 0; + char newStr[100]; + sprintf(newStr, "%s-%d", ranStr, i); + int len = strlen(newStr); + int64_t offset = walGetCurFileOffset(pWal); + SWalFileInfo* pFileInfo = walGetCurFileInfo(pWal); + + pWal->writeHead.head.version = i; + pWal->writeHead.head.bodyLen = len; + pWal->writeHead.head.msgType = 0; + pWal->writeHead.head.ingestTs = taosGetTimestampUs(); + + pWal->writeHead.head.syncMeta = syncMeta; + + pWal->writeHead.cksumHead = 1; + pWal->writeHead.cksumBody = walCalcBodyCksum(newStr, len); + taosWriteFile(pWal->pLogFile, &pWal->writeHead, sizeof(SWalCkHead)); + taosWriteFile(pWal->pLogFile, newStr, len); + + int64_t lastVer = 0; + code = walScanLogGetLastVer(pWal, 0, &lastVer); + ASSERT_EQ(code, TSDB_CODE_WAL_CHKSUM_MISMATCH); +} + +TEST_F(WalKeepEnv, walScanLogGetLastVerBodyMissMatch) { + walResetEnv(); + int code; + do { + char newStr[100]; + sprintf(newStr, "%s-%d", ranStr, 0); + sprintf(newStr, "%s-%d", ranStr, 0); + int len = strlen(newStr); + code = walAppendLog(pWal, 0, 0, syncMeta, newStr, len); + } while (0); + + int i = 0; + char newStr[100]; + sprintf(newStr, "%s-%d", ranStr, i); + int len = strlen(newStr); + int64_t offset = walGetCurFileOffset(pWal); + SWalFileInfo* pFileInfo = walGetCurFileInfo(pWal); + + pWal->writeHead.head.version = i; + pWal->writeHead.head.bodyLen = len; + pWal->writeHead.head.msgType = 0; + pWal->writeHead.head.ingestTs = taosGetTimestampUs(); + + pWal->writeHead.head.syncMeta = syncMeta; + + pWal->writeHead.cksumHead = walCalcHeadCksum(&pWal->writeHead); + pWal->writeHead.cksumBody = 1; + taosWriteFile(pWal->pLogFile, &pWal->writeHead, sizeof(SWalCkHead)); + taosWriteFile(pWal->pLogFile, newStr, len); + + int64_t lastVer = 0; + code = walScanLogGetLastVer(pWal, 0, &lastVer); + ASSERT_EQ(code, TSDB_CODE_WAL_CHKSUM_MISMATCH); +} + +TEST_F(WalKeepEnv, walCheckAndRepairIdxFile) { + walResetEnv(); + int code; + do { + char newStr[100]; + sprintf(newStr, "%s-%d", ranStr, 0); + sprintf(newStr, "%s-%d", ranStr, 0); + int len = strlen(newStr); + code = walAppendLog(pWal, 0, 0, syncMeta, newStr, len); + } while (0); + SWalFileInfo* pFileInfo = walGetCurFileInfo(pWal); + for (int i = 1; i < 100; i++) { + char newStr[100]; + sprintf(newStr, "%s-%d", ranStr, i); + int len = strlen(newStr); + pWal->writeHead.head.version = i; + pWal->writeHead.head.bodyLen = len; + pWal->writeHead.head.msgType = 0; + pWal->writeHead.head.ingestTs = taosGetTimestampUs(); + pWal->writeHead.head.syncMeta = syncMeta; + pWal->writeHead.cksumHead = walCalcHeadCksum(&pWal->writeHead); + pWal->writeHead.cksumBody = walCalcBodyCksum(newStr, len); + taosWriteFile(pWal->pLogFile, &pWal->writeHead, sizeof(SWalCkHead)); + taosWriteFile(pWal->pLogFile, newStr, len); + } + pWal->vers.lastVer = 99; + pFileInfo->lastVer = 99; + code = walCheckAndRepairIdx(pWal); + ASSERT_EQ(code, 0); +} + +TEST_F(WalKeepEnv, walRestoreFromSnapshot1) { + walResetEnv(); + int code; + + int i; + for (i = 0; i < 100; i++) { + char newStr[100]; + sprintf(newStr, "%s-%d", ranStr, i); + int len = strlen(newStr); + code = walAppendLog(pWal, i, 0, syncMeta, newStr, len); + ASSERT_EQ(code, 0); + } + code = walRestoreFromSnapshot(pWal, 50); + ASSERT_EQ(code, 0); +} + +TEST_F(WalKeepEnv, walRestoreFromSnapshot2) { + walResetEnv(); + int code; + + int i; + for (i = 0; i < 100; i++) { + char newStr[100]; + sprintf(newStr, "%s-%d", ranStr, i); + int len = strlen(newStr); + code = walAppendLog(pWal, i, 0, syncMeta, newStr, len); + ASSERT_EQ(code, 0); + } + SWalRef* ref = walOpenRef(pWal); + ref->refVer = 10; + code = walRestoreFromSnapshot(pWal, 99); + ASSERT_EQ(code, -1); +} + +TEST_F(WalKeepEnv, walRollback) { + walResetEnv(); + int code; + + int i; + for (i = 0; i < 100; i++) { + char newStr[100]; + sprintf(newStr, "%s-%d", ranStr, i); + int len = strlen(newStr); + code = walAppendLog(pWal, i, 0, syncMeta, newStr, len); + ASSERT_EQ(code, 0); + } + code = walRollback(pWal, -1); + ASSERT_EQ(code, TSDB_CODE_WAL_INVALID_VER); + pWal->vers.lastVer = 50; + pWal->vers.commitVer = 40; + pWal->vers.snapshotVer = 40; + SWalFileInfo* fileInfo = walGetCurFileInfo(pWal); + + code = walRollback(pWal, 48); + ASSERT_EQ(code, 0); +} + TEST_F(WalRetentionEnv, repairMeta1) { walResetEnv(); int code; @@ -456,44 +710,6 @@ TEST_F(WalRetentionEnv, repairMeta1) { walCloseReader(pRead); } -class WalSkipLevel : public ::testing::Test { - protected: - static void SetUpTestCase() { - int code = walInit(NULL); - ASSERT(code == 0); - } - - static void TearDownTestCase() { walCleanUp(); } - - void walResetEnv() { - TearDown(); - taosRemoveDir(pathName); - SetUp(); - } - - void SetUp() override { - SWalCfg cfg; - cfg.rollPeriod = -1; - cfg.segSize = -1; - cfg.committed =-1; - cfg.retentionPeriod = -1; - cfg.retentionSize = 0; - cfg.rollPeriod = 0; - cfg.vgId = 1; - cfg.level = TAOS_WAL_SKIP; - pWal = walOpen(pathName, &cfg); - ASSERT(pWal != NULL); - } - - void TearDown() override { - walClose(pWal); - pWal = NULL; - } - - SWal* pWal = NULL; - const char* pathName = TD_TMP_DIR_PATH "wal_test"; -}; - TEST_F(WalSkipLevel, restart) { walResetEnv(); int code; @@ -533,4 +749,15 @@ TEST_F(WalSkipLevel, roll) { ASSERT_EQ(code, 0); code = walEndSnapshot(pWal); ASSERT_EQ(code, 0); +} + +TEST_F(WalEncrypted, write) { + int code; + for (int i = 0; i < 100; i++) { + code = walAppendLog(pWal, i, i + 1, syncMeta, (void*)ranStr, ranStrLen); + ASSERT_EQ(code, 0); + ASSERT_EQ(pWal->vers.lastVer, i); + } + code = walSaveMeta(pWal); + ASSERT_EQ(code, 0); } \ No newline at end of file diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c index ee88996c29..77203c4c14 100644 --- a/source/util/src/tconfig.c +++ b/source/util/src/tconfig.c @@ -517,7 +517,7 @@ int32_t cfgSetItemVal(SConfigItem *pItem, const char *name, const char *value, E int32_t code = TSDB_CODE_SUCCESS; if (pItem == NULL) { - TAOS_RETURN(TSDB_CODE_INVALID_CFG); + TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND); } switch (pItem->dtype) { case CFG_DTYPE_BOOL: { @@ -627,6 +627,7 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p cfgUnLock(pCfg); TAOS_RETURN(code); } + if ((pItem->category == CFG_CATEGORY_GLOBAL) && alterType == CFG_ALTER_DNODE) { uError("failed to config:%s, not support update global config on only one dnode", name); cfgUnLock(pCfg); diff --git a/source/util/test/cfgTest.cpp b/source/util/test/cfgTest.cpp index a5812d375b..d2967131f8 100644 --- a/source/util/test/cfgTest.cpp +++ b/source/util/test/cfgTest.cpp @@ -10,6 +10,8 @@ */ #include +#include +#include "osFile.h" #include "tconfig.h" class CfgTest : public ::testing::Test { @@ -35,6 +37,9 @@ TEST_F(CfgTest, 01_Str) { EXPECT_STREQ(cfgStypeStr(CFG_STYPE_ENV_CMD), "env_cmd"); EXPECT_STREQ(cfgStypeStr(CFG_STYPE_APOLLO_URL), "apollo_url"); EXPECT_STREQ(cfgStypeStr(CFG_STYPE_ARG_LIST), "arg_list"); + EXPECT_STREQ(cfgStypeStr(CFG_STYPE_TAOS_OPTIONS), "taos_options"); + EXPECT_STREQ(cfgStypeStr(CFG_STYPE_ALTER_CLIENT_CMD), "alter_client_cmd"); + EXPECT_STREQ(cfgStypeStr(CFG_STYPE_ALTER_SERVER_CMD), "alter_server_cmd"); EXPECT_STREQ(cfgStypeStr(ECfgSrcType(1024)), "invalid"); EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_NONE), "none"); @@ -47,6 +52,10 @@ TEST_F(CfgTest, 01_Str) { EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_DIR), "dir"); EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_DIR), "dir"); EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_DIR), "dir"); + EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_DOUBLE), "double"); + EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_LOCALE), "locale"); + EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_CHARSET), "charset"); + EXPECT_STREQ(cfgDtypeStr(CFG_DTYPE_TIMEZONE), "timezone"); EXPECT_STREQ(cfgDtypeStr(ECfgDataType(1024)), "invalid"); } @@ -57,24 +66,30 @@ TEST_F(CfgTest, 02_Basic) { ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_NE(pConfig, nullptr); - EXPECT_EQ(cfgAddBool(pConfig, "test_bool", 0, 0, 0, 0), 0); - EXPECT_EQ(cfgAddInt32(pConfig, "test_int32", 1, 0, 16, 0, 0, 0), 0); - EXPECT_EQ(cfgAddInt64(pConfig, "test_int64", 2, 0, 16, 0, 0, 0), 0); - EXPECT_EQ(cfgAddFloat(pConfig, "test_float", 3, 0, 16, 0, 0, 0), 0); - EXPECT_EQ(cfgAddString(pConfig, "test_string", "4", 0, 0, 0), 0); - EXPECT_EQ(cfgAddDir(pConfig, "test_dir", TD_TMP_DIR_PATH, 0, 0, 0), 0); + EXPECT_EQ(cfgAddBool(pConfig, "test_bool", 0, 0, 6, 0), 0); + + EXPECT_EQ(cfgAddInt32(pConfig, "test_int32", 21, 0, 16, 0, 1, 0), TSDB_CODE_OUT_OF_RANGE); + EXPECT_EQ(cfgAddInt32(pConfig, "test_int32", 1, 0, 16, 0, 1, 0), 0); + + EXPECT_EQ(cfgAddInt64(pConfig, "test_int64", 21, 0, 16, 0, 2, 0), TSDB_CODE_OUT_OF_RANGE); + EXPECT_EQ(cfgAddInt64(pConfig, "test_int64", 2, 0, 16, 0, 2, 0), 0); + + EXPECT_EQ(cfgAddFloat(pConfig, "test_float", 21, 0, 16, 0, 6, 0), TSDB_CODE_OUT_OF_RANGE); + EXPECT_EQ(cfgAddFloat(pConfig, "test_float", 3, 0, 16, 0, 6, 0), 0); + EXPECT_EQ(cfgAddString(pConfig, "test_string", "4", 0, 6, 0), 0); + EXPECT_EQ(cfgAddDir(pConfig, "test_dir", TD_TMP_DIR_PATH, 0, 6, 0), 0); EXPECT_EQ(cfgGetSize(pConfig), 6); int32_t size = cfgGetSize(pConfig); - SConfigItem* pItem = NULL; + SConfigItem *pItem = NULL; SConfigIter *pIter = NULL; code = cfgCreateIter(pConfig, &pIter); ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_NE(pIter, nullptr); - while((pItem = cfgNextIter(pIter)) != NULL) { + while ((pItem = cfgNextIter(pIter)) != NULL) { switch (pItem->dtype) { case CFG_DTYPE_BOOL: printf("index:%d, cfg:%s value:%d\n", size, pItem->name, pItem->bval); @@ -115,12 +130,16 @@ TEST_F(CfgTest, 02_Basic) { EXPECT_EQ(pItem->dtype, CFG_DTYPE_INT32); EXPECT_STREQ(pItem->name, "test_int32"); EXPECT_EQ(pItem->i32, 1); + code = cfgSetItem(pConfig, "test_int32", "21", CFG_STYPE_DEFAULT, true); + ASSERT_EQ(code, TSDB_CODE_OUT_OF_RANGE); pItem = cfgGetItem(pConfig, "test_int64"); EXPECT_EQ(pItem->stype, CFG_STYPE_DEFAULT); EXPECT_EQ(pItem->dtype, CFG_DTYPE_INT64); EXPECT_STREQ(pItem->name, "test_int64"); EXPECT_EQ(pItem->i64, 2); + code = cfgSetItem(pConfig, "test_int64", "21", CFG_STYPE_DEFAULT, true); + ASSERT_EQ(code, TSDB_CODE_OUT_OF_RANGE); pItem = cfgGetItem(pConfig, "test_float"); EXPECT_EQ(pItem->stype, CFG_STYPE_DEFAULT); @@ -140,5 +159,210 @@ TEST_F(CfgTest, 02_Basic) { EXPECT_STREQ(pItem->name, "test_dir"); EXPECT_STREQ(pItem->str, TD_TMP_DIR_PATH); + code = cfgGetAndSetItem(pConfig, &pItem, "err_cfg", "err_val", CFG_STYPE_DEFAULT, true); + ASSERT_EQ(code, TSDB_CODE_CFG_NOT_FOUND); + + code = cfgCheckRangeForDynUpdate(pConfig, "test_int32", "4", false, CFG_ALTER_LOCAL); + ASSERT_EQ(code, TSDB_CODE_INVALID_CFG); + + code = cfgCheckRangeForDynUpdate(pConfig, "test_int64", "4", true, CFG_ALTER_LOCAL); + ASSERT_EQ(code, TSDB_CODE_INVALID_CFG); + + code = cfgCheckRangeForDynUpdate(pConfig, "test_bool", "3", false, CFG_ALTER_LOCAL); + ASSERT_EQ(code, TSDB_CODE_OUT_OF_RANGE); + + code = cfgCheckRangeForDynUpdate(pConfig, "test_int32", "74", true, CFG_ALTER_LOCAL); + ASSERT_EQ(code, TSDB_CODE_OUT_OF_RANGE); + + code = cfgCheckRangeForDynUpdate(pConfig, "test_int64", "74", false, CFG_ALTER_LOCAL); + ASSERT_EQ(code, TSDB_CODE_OUT_OF_RANGE); + + code = cfgCheckRangeForDynUpdate(pConfig, "test_float", "74", false, CFG_ALTER_LOCAL); + ASSERT_EQ(code, TSDB_CODE_OUT_OF_RANGE); + cfgCleanup(pConfig); } + +TEST_F(CfgTest, initWithArray) { + SConfig *pConfig = NULL; + int32_t code = cfgInit(&pConfig); + + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + ASSERT_NE(pConfig, nullptr); + + EXPECT_EQ(cfgAddBool(pConfig, "test_bool", 0, 0, 0, 0), 0); + EXPECT_EQ(cfgAddInt32(pConfig, "test_int32", 1, 0, 16, 0, 0, 0), 0); + EXPECT_EQ(cfgAddInt64(pConfig, "test_int64", 2, 0, 16, 0, 0, 0), 0); + EXPECT_EQ(cfgAddFloat(pConfig, "test_float", 3, 0, 16, 0, 0, 0), 0); + EXPECT_EQ(cfgAddString(pConfig, "test_string", "4", 0, 0, 0), 0); + EXPECT_EQ(cfgAddDir(pConfig, "test_dir", TD_TMP_DIR_PATH, 0, 0, 0), 0); + + SArray *pArgs = taosArrayInit(6, sizeof(SConfigPair)); + SConfigPair *pPair = (SConfigPair *)taosMemoryMalloc(sizeof(SConfigPair)); + pPair->name = "test_bool"; + pPair->value = "1"; + taosArrayPush(pArgs, pPair); + SConfigPair *pPair1 = (SConfigPair *)taosMemoryMalloc(sizeof(SConfigPair)); + pPair1->name = "test_int32"; + pPair1->value = "2"; + taosArrayPush(pArgs, pPair1); + SConfigPair *pPair2 = (SConfigPair *)taosMemoryMalloc(sizeof(SConfigPair)); + pPair2->name = "test_int64"; + pPair2->value = "3"; + taosArrayPush(pArgs, pPair2); + SConfigPair *pPair3 = (SConfigPair *)taosMemoryMalloc(sizeof(SConfigPair)); + pPair3->name = "test_float"; + pPair3->value = "4"; + taosArrayPush(pArgs, pPair3); + SConfigPair *pPair4 = (SConfigPair *)taosMemoryMalloc(sizeof(SConfigPair)); + pPair4->name = "test_string"; + pPair4->value = "5"; + taosArrayPush(pArgs, pPair4); + SConfigPair *pPair5 = (SConfigPair *)taosMemoryMalloc(sizeof(SConfigPair)); + pPair5->name = "test_dir"; + pPair5->value = TD_TMP_DIR_PATH; + taosArrayPush(pArgs, pPair5); + code = cfgLoadFromArray(pConfig, pArgs); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); +} + +TEST_F(CfgTest, cfgDumpItemCategory) { + SConfig *pConfig = NULL; + int32_t code = cfgInit(&pConfig); + + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + ASSERT_NE(pConfig, nullptr); + + EXPECT_EQ(cfgAddBool(pConfig, "test_bool", 0, 0, 6, 100), 0); + + SConfigItem *pItem = NULL; + pItem = cfgGetItem(pConfig, "test_bool"); + EXPECT_EQ(pItem->stype, CFG_STYPE_DEFAULT); + EXPECT_EQ(pItem->dtype, CFG_DTYPE_BOOL); + EXPECT_STREQ(pItem->name, "test_bool"); + EXPECT_EQ(pItem->bval, 0); + + EXPECT_EQ(cfgDumpItemCategory(pItem, NULL, 0, 0), TSDB_CODE_INVALID_CFG); +} + +TEST_F(CfgTest, cfgDumpCfgS3) { + SConfig *pConfig = NULL; + int32_t code = cfgInit(&pConfig); + + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + ASSERT_NE(pConfig, nullptr); + + cfgAddInt32(pConfig, "s3MigrateIntervalSec", 60 * 60, 600, 100000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER, + CFG_CATEGORY_GLOBAL); + cfgAddBool(pConfig, "s3MigrateEnabled", 60 * 60, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER, CFG_CATEGORY_GLOBAL); + cfgAddString(pConfig, "s3Accesskey", "", CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER_LAZY, CFG_CATEGORY_GLOBAL); + cfgAddString(pConfig, "s3Endpoint", "", CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER_LAZY, CFG_CATEGORY_GLOBAL); + cfgAddString(pConfig, "s3BucketName", "", CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER_LAZY, CFG_CATEGORY_GLOBAL); + cfgAddInt32(pConfig, "s3PageCacheSize", 10, 4, 1024 * 1024 * 1024, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER_LAZY, + CFG_CATEGORY_GLOBAL); + cfgAddInt32(pConfig, "s3UploadDelaySec", 10, 1, 60 * 60 * 24 * 30, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER, + CFG_CATEGORY_GLOBAL); + cfgAddDir(pConfig, "scriptDir", configDir, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL); + + cfgDumpCfgS3(pConfig, false, false); + + cfgDumpCfgS3(pConfig, true, true); + + cfgDumpCfgS3(pConfig, false, true); + + cfgDumpCfgS3(pConfig, true, false); +} + +TEST_F(CfgTest, cfgLoadFromEnvVar) { + SConfig *pConfig = NULL; + int32_t code = cfgInit(&pConfig); + + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + ASSERT_NE(pConfig, nullptr); + + EXPECT_EQ(cfgAddBool(pConfig, "test_bool", 0, 0, 6, 0), 0); + + EXPECT_EQ(cfgAddInt32(pConfig, "test_int32", 21, 0, 16, 0, 1, 0), TSDB_CODE_OUT_OF_RANGE); + EXPECT_EQ(cfgAddInt32(pConfig, "test_int32", 1, 0, 16, 0, 1, 0), 0); + + EXPECT_EQ(cfgAddInt64(pConfig, "test_int64", 21, 0, 16, 0, 2, 0), TSDB_CODE_OUT_OF_RANGE); + EXPECT_EQ(cfgAddInt64(pConfig, "test_int64", 2, 0, 16, 0, 2, 0), 0); + + EXPECT_EQ(cfgAddFloat(pConfig, "test_float", 21, 0, 16, 0, 6, 0), TSDB_CODE_OUT_OF_RANGE); + EXPECT_EQ(cfgAddFloat(pConfig, "test_float", 3, 0, 16, 0, 6, 0), 0); + EXPECT_EQ(cfgAddString(pConfig, "test_string", "4", 0, 6, 0), 0); + EXPECT_EQ(cfgAddDir(pConfig, "test_dir", TD_TMP_DIR_PATH, 0, 6, 0), 0); + + setenv("test_bool", "1", 1); + setenv("test_int32", "2", 1); + setenv("test_int64", "3", 1); + setenv("test_float", "4", 1); + setenv("test_string", "5", 1); + setenv("test_dir", TD_TMP_DIR_PATH, 1); + + ASSERT_EQ(cfgLoad(pConfig, CFG_STYPE_ENV_VAR, "test_bool"), TSDB_CODE_SUCCESS); +} + +TEST_F(CfgTest, cfgLoadFromEnvCmd) { + SConfig *pConfig = NULL; + int32_t code = cfgInit(&pConfig); + + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + ASSERT_NE(pConfig, nullptr); + + EXPECT_EQ(cfgAddBool(pConfig, "test_bool", 0, 0, 6, 0), 0); + + EXPECT_EQ(cfgAddInt32(pConfig, "test_int32", 21, 0, 16, 0, 1, 0), TSDB_CODE_OUT_OF_RANGE); + EXPECT_EQ(cfgAddInt32(pConfig, "test_int32", 1, 0, 16, 0, 1, 0), 0); + + EXPECT_EQ(cfgAddInt64(pConfig, "test_int64", 21, 0, 16, 0, 2, 0), TSDB_CODE_OUT_OF_RANGE); + EXPECT_EQ(cfgAddInt64(pConfig, "test_int64", 2, 0, 16, 0, 2, 0), 0); + + EXPECT_EQ(cfgAddFloat(pConfig, "test_float", 21, 0, 16, 0, 6, 0), TSDB_CODE_OUT_OF_RANGE); + EXPECT_EQ(cfgAddFloat(pConfig, "test_float", 3, 0, 16, 0, 6, 0), 0); + EXPECT_EQ(cfgAddString(pConfig, "test_string", "4", 0, 6, 0), 0); + + const char *envCmd[] = {"test_bool=1", "test_int32=2", "test_int64=3", "test_float=4", "test_string=5", NULL}; + + ASSERT_EQ(cfgLoad(pConfig, CFG_STYPE_ENV_CMD, envCmd), TSDB_CODE_SUCCESS); +} + +TEST_F(CfgTest, cfgLoadFromEnvFile) { + SConfig *pConfig = NULL; + int32_t code = cfgInit(&pConfig); + + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + ASSERT_NE(pConfig, nullptr); + + TdFilePtr envFile = NULL; + const char *envFilePath = TD_TMP_DIR_PATH "envFile"; + envFile = taosOpenFile(envFilePath, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND); + const char *buf = "test_bool=1\ntest_int32=2\ntest_int64=3\ntest_float=4\ntest_string=5\n"; + taosWriteFile(envFile, buf, strlen(buf)); + taosCloseFile(&envFile); + ASSERT_EQ(cfgLoad(pConfig, CFG_STYPE_ENV_FILE, envFilePath), TSDB_CODE_SUCCESS); + + taosRemoveFile(envFilePath); +} + +TEST_F(CfgTest, cfgLoadFromApollUrl) { + SConfig *pConfig = NULL; + int32_t code = cfgInit(&pConfig); + + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + ASSERT_NE(pConfig, nullptr); + + TdFilePtr jsonFile = NULL; + const char *jsonFilePath = TD_TMP_DIR_PATH "envJson.json"; + jsonFile = taosOpenFile(jsonFilePath, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND); + const char *buf = + "{\"test_bool\":\"1\",\"test_int32\":\"2\",\"test_int64\":\"3\",\"test_float\":\"4\",\"test_string\":\"5\"}"; + taosWriteFile(jsonFile, buf, strlen(buf)); + taosCloseFile(&jsonFile); + + char str[256]; + snprintf(str, sizeof(str), "jsonFile:%s", jsonFilePath); + ASSERT_EQ(cfgLoad(pConfig, CFG_STYPE_APOLLO_URL, str), TSDB_CODE_INVALID_DATA_FMT); + + taosRemoveFile(jsonFilePath); +} \ No newline at end of file From 1f434d7d4e064996b1576ca63663cc5db9157c7d Mon Sep 17 00:00:00 2001 From: xiao-77 Date: Tue, 24 Dec 2024 19:05:02 +0800 Subject: [PATCH 2/5] Add case for sdbFile.c . --- tests/parallel_test/cases.task | 1 + tests/system-test/6-cluster/mnodeEncrypt.py | 69 +++++++++++++++++++++ 2 files changed, 70 insertions(+) create mode 100644 tests/system-test/6-cluster/mnodeEncrypt.py diff --git a/tests/parallel_test/cases.task b/tests/parallel_test/cases.task index 1aef2195db..82bbeaaeb5 100644 --- a/tests/parallel_test/cases.task +++ b/tests/parallel_test/cases.task @@ -777,6 +777,7 @@ ,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_querys.py -N 4 -M 1 ,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/vnode/4dnode1mnode_basic_replica3_vgroups.py -N 4 -M 1 ,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/compactDBConflict.py -N 3 +,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/mnodeEncrypt.py 3 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/between.py -Q 2 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/distinct.py -Q 2 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/varchar.py -Q 2 diff --git a/tests/system-test/6-cluster/mnodeEncrypt.py b/tests/system-test/6-cluster/mnodeEncrypt.py new file mode 100644 index 0000000000..e878611d32 --- /dev/null +++ b/tests/system-test/6-cluster/mnodeEncrypt.py @@ -0,0 +1,69 @@ +from ssl import ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE +from numpy import row_stack +import taos +import sys +import time +import os + +from util.log import * +from util.sql import * +from util.cases import * +from util.dnodes import TDDnodes +from util.dnodes import TDDnode +from util.cluster import * +sys.path.append("./6-cluster") +from clusterCommonCreate import * +from clusterCommonCheck import clusterComCheck + +import time +import socket +import subprocess +from multiprocessing import Process +import threading +import time +import inspect +import ctypes + +class TDTestCase: + + def init(self, conn, logSql, replicaVar=1): + tdLog.debug(f"start to excute {__file__}") + self.TDDnodes = None + tdSql.init(conn.cursor()) + self.host = socket.gethostname() + + + def run(self): + tdSql.execute('create database if not exists db'); + tdSql.execute('use db') + tdSql.execute('create table st (ts timestamp, i int, j float, k double) tags(a int)') + + for i in range(0, 2): + tdSql.execute("create table if not exists db.t%d using db.st tags(%d)" % (i, i)) + + + for i in range(2, 4): + tdSql.execute("create table if not exists db.t%d using db.st tags(%d)" % (i, i)) + + sql = "show db.tables" + tdSql.query(sql) + tdSql.checkRows(4) + + timestamp = 1530374400000 + for i in range (4) : + val = i + sql = "insert into db.t%d values(%d, %d, %d, %d)" % (i, timestamp, val, val, val) + tdSql.execute(sql) + + for i in range ( 4) : + val = i + sql = "select * from db.t%d" % (i) + tdSql.query(sql) + tdSql.checkRows(1) + + def stop(self): + tdSql.close() + tdLog.success(f"{__file__} successfully executed") + +tdCases.addLinux(__file__, TDTestCase()) +tdCases.addWindows(__file__, TDTestCase()) From eaa416f7f0846720154e9ebf848d60e8c3837431 Mon Sep 17 00:00:00 2001 From: xiao-77 Date: Tue, 24 Dec 2024 20:03:02 +0800 Subject: [PATCH 3/5] Fix res check. --- source/util/test/cfgTest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/util/test/cfgTest.cpp b/source/util/test/cfgTest.cpp index d2967131f8..52f6c0844c 100644 --- a/source/util/test/cfgTest.cpp +++ b/source/util/test/cfgTest.cpp @@ -362,7 +362,7 @@ TEST_F(CfgTest, cfgLoadFromApollUrl) { char str[256]; snprintf(str, sizeof(str), "jsonFile:%s", jsonFilePath); - ASSERT_EQ(cfgLoad(pConfig, CFG_STYPE_APOLLO_URL, str), TSDB_CODE_INVALID_DATA_FMT); + ASSERT_EQ(cfgLoad(pConfig, CFG_STYPE_APOLLO_URL, str), 0); taosRemoveFile(jsonFilePath); } \ No newline at end of file From 3a29a7e2c3a78e1e415ce5a9dbcb66f65824e7e1 Mon Sep 17 00:00:00 2001 From: xiao-77 Date: Tue, 24 Dec 2024 22:15:36 +0800 Subject: [PATCH 4/5] fix windows build. --- source/util/test/cfgTest.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/source/util/test/cfgTest.cpp b/source/util/test/cfgTest.cpp index 52f6c0844c..3894ca1061 100644 --- a/source/util/test/cfgTest.cpp +++ b/source/util/test/cfgTest.cpp @@ -273,6 +273,7 @@ TEST_F(CfgTest, cfgDumpCfgS3) { cfgDumpCfgS3(pConfig, true, false); } +#ifndef WINDOWS TEST_F(CfgTest, cfgLoadFromEnvVar) { SConfig *pConfig = NULL; int32_t code = cfgInit(&pConfig); @@ -302,6 +303,7 @@ TEST_F(CfgTest, cfgLoadFromEnvVar) { ASSERT_EQ(cfgLoad(pConfig, CFG_STYPE_ENV_VAR, "test_bool"), TSDB_CODE_SUCCESS); } +#endif TEST_F(CfgTest, cfgLoadFromEnvCmd) { SConfig *pConfig = NULL; From c822e57aef3dd2dc182513e7380de81d0d4f72e2 Mon Sep 17 00:00:00 2001 From: xiao-77 Date: Tue, 24 Dec 2024 22:57:51 +0800 Subject: [PATCH 5/5] fix windows build. --- source/util/test/cfgTest.cpp | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/source/util/test/cfgTest.cpp b/source/util/test/cfgTest.cpp index 3894ca1061..74c34f5c91 100644 --- a/source/util/test/cfgTest.cpp +++ b/source/util/test/cfgTest.cpp @@ -10,10 +10,12 @@ */ #include -#include -#include "osFile.h" #include "tconfig.h" +#ifndef WINDOWS +#include "osFile.h" +#endif + class CfgTest : public ::testing::Test { protected: static void SetUpTestSuite() {} @@ -303,7 +305,6 @@ TEST_F(CfgTest, cfgLoadFromEnvVar) { ASSERT_EQ(cfgLoad(pConfig, CFG_STYPE_ENV_VAR, "test_bool"), TSDB_CODE_SUCCESS); } -#endif TEST_F(CfgTest, cfgLoadFromEnvCmd) { SConfig *pConfig = NULL; @@ -367,4 +368,6 @@ TEST_F(CfgTest, cfgLoadFromApollUrl) { ASSERT_EQ(cfgLoad(pConfig, CFG_STYPE_APOLLO_URL, str), 0); taosRemoveFile(jsonFilePath); -} \ No newline at end of file +} + +#endif \ No newline at end of file