xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Merge pull request #26783 from taosdata/feat/TD-30991-3.0 

feat: (errcode) tglobal.c
This commit is contained in:
Hongze Cheng 2024-07-27 16:39:57 +08:00 committed by GitHub
parent 21f6ddf3d0 a2800cf358
commit 4b12153b31
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
12 changed files with 782 additions and 744 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/common/tglobal.h
View File

@ -272,11 +272,11 @@ int32_t taosCfgDynamicOptions(SConfig *pCfg, const char *name, bool forServer);
struct SConfig *taosGetCfg(); struct SConfig *taosGetCfg();
void taosSetGlobalDebugFlag(int32_t flag); int32_t taosSetGlobalDebugFlag(int32_t flag);
void taosSetDebugFlag(int32_t *pFlagPtr, const char *flagName, int32_t flagVal); int32_t taosSetDebugFlag(int32_t *pFlagPtr, const char *flagName, int32_t flagVal);
void taosLocalCfgForbiddenToChange(char *name, bool *forbidden); void taosLocalCfgForbiddenToChange(char *name, bool *forbidden);
int8_t taosGranted(int8_t type); int8_t taosGranted(int8_t type);
int32_t taosSetSlowLogScope(char *pScope); int32_t taosSetSlowLogScope(char *pScopeStr, int32_t *pScope);
#ifdef __cplusplus #ifdef __cplusplus
} }

986
source/common/src/tglobal.c
View File

File diff suppressed because it is too large Load Diff

23
source/common/src/ttime.c
View File

@ -1252,13 +1252,13 @@ static bool isSeperatorChar(char c) {
return (c > 0x20 && c < 0x7F && !(c >= 'A' && c <= 'Z') && !(c >= 'a' && c <= 'z') && !(c >= '0' && c <= '9')); return (c > 0x20 && c < 0x7F && !(c >= 'A' && c <= 'Z') && !(c >= 'a' && c <= 'z') && !(c >= '0' && c <= '9'));
} }
static void parseTsFormat(const char* formatStr, SArray* formats) { static int32_t parseTsFormat(const char* formatStr, SArray* formats) {
TSFormatNode* lastOtherFormat = NULL; TSFormatNode* lastOtherFormat = NULL;
while (*formatStr) { while (*formatStr) {
const TSFormatKeyWord* key = keywordSearch(formatStr); const TSFormatKeyWord* key = keywordSearch(formatStr);
if (key) { if (key) {
TSFormatNode format = {.key = key, .type = TS_FORMAT_NODE_TYPE_KEYWORD}; TSFormatNode format = {.key = key, .type = TS_FORMAT_NODE_TYPE_KEYWORD};
taosArrayPush(formats, &format); if (NULL == taosArrayPush(formats, &format)) TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
formatStr += key->len; formatStr += key->len;
lastOtherFormat = NULL; lastOtherFormat = NULL;
} else { } else {
@ -1286,7 +1286,7 @@ static void parseTsFormat(const char* formatStr, SArray* formats) {
TSFormatNode format = {.type = TS_FORMAT_NODE_TYPE_CHAR, .key = NULL}; TSFormatNode format = {.type = TS_FORMAT_NODE_TYPE_CHAR, .key = NULL};
format.c = formatStr; format.c = formatStr;
format.len = 1; format.len = 1;
taosArrayPush(formats, &format); if (NULL == taosArrayPush(formats, &format)) TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
formatStr++; formatStr++;
last = taosArrayGetLast(formats); last = taosArrayGetLast(formats);
} }
@ -1314,13 +1314,14 @@ static void parseTsFormat(const char* formatStr, SArray* formats) {
.key = NULL}; .key = NULL};
format.c = formatStr; format.c = formatStr;
format.len = 1; format.len = 1;
taosArrayPush(formats, &format); if (NULL == taosArrayPush(formats, &format)) TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
formatStr++; formatStr++;
if (format.type == TS_FORMAT_NODE_TYPE_CHAR) lastOtherFormat = taosArrayGetLast(formats); if (format.type == TS_FORMAT_NODE_TYPE_CHAR) lastOtherFormat = taosArrayGetLast(formats);
} }
} }
} }
} }
TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int32_t outLen) { static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int32_t outLen) {
@ -1488,7 +1489,7 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
s += 6; s += 6;
break; break;
case TSFKW_NS: case TSFKW_NS:
sprintf(s, "%09" PRId64, tm->fsec); (void)sprintf(s, "%09" PRId64, tm->fsec);
s += 9; s += 9;
break; break;
case TSFKW_TZH: case TSFKW_TZH:
@ -1925,7 +1926,7 @@ int32_t taosTs2Char(const char* format, SArray** formats, int64_t ts, int32_t pr
if (!*formats){ if (!*formats){
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
parseTsFormat(format, *formats); TAOS_CHECK_RETURN(parseTsFormat(format, *formats));
} }
struct STm tm; struct STm tm;
TAOS_CHECK_RETURN(taosTs2Tm(ts, precision, &tm)); TAOS_CHECK_RETURN(taosTs2Tm(ts, precision, &tm));
@ -1941,7 +1942,7 @@ int32_t taosChar2Ts(const char* format, SArray** formats, const char* tsStr, int
if (!*formats) { if (!*formats) {
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
parseTsFormat(format, *formats); TAOS_CHECK_RETURN(parseTsFormat(format, *formats));
} }
int32_t code = char2ts(tsStr, *formats, ts, precision, &sErrPos, &fErrIdx); int32_t code = char2ts(tsStr, *formats, ts, precision, &sErrPos, &fErrIdx);
if (code == -1) { if (code == -1) {
@ -1966,7 +1967,7 @@ int32_t TEST_ts2char(const char* format, int64_t ts, int32_t precision, char* ou
if (!formats) { if (!formats) {
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
parseTsFormat(format, formats); TAOS_CHECK_RETURN(parseTsFormat(format, formats));
struct STm tm; struct STm tm;
TAOS_CHECK_GOTO(taosTs2Tm(ts, precision, &tm), NULL, _exit); TAOS_CHECK_GOTO(taosTs2Tm(ts, precision, &tm), NULL, _exit);
TAOS_CHECK_GOTO(tm2char(formats, &tm, out, outLen), NULL, _exit); TAOS_CHECK_GOTO(tm2char(formats, &tm, out, outLen), NULL, _exit);
@ -1980,11 +1981,11 @@ int32_t TEST_char2ts(const char* format, int64_t* ts, int32_t precision, const c
const char* sErrPos; const char* sErrPos;
int32_t fErrIdx; int32_t fErrIdx;
SArray* formats = taosArrayInit(4, sizeof(TSFormatNode)); SArray* formats = taosArrayInit(4, sizeof(TSFormatNode));
parseTsFormat(format, formats); TAOS_CHECK_RETURN(parseTsFormat(format, formats));
int32_t code = char2ts(tsStr, formats, ts, precision, &sErrPos, &fErrIdx); int32_t code = char2ts(tsStr, formats, ts, precision, &sErrPos, &fErrIdx);
if (code == -1) { if (code == -1) {
printf("failed position: %s\n", sErrPos); (void)printf("failed position: %s\n", sErrPos);
printf("failed format: %s\n", ((TSFormatNode*)taosArrayGet(formats, fErrIdx))->key->name); (void)printf("failed format: %s\n", ((TSFormatNode*)taosArrayGet(formats, fErrIdx))->key->name);
} }
taosArrayDestroy(formats); taosArrayDestroy(formats);
return code; return code;

2
source/common/src/ttypes.c
View File

@ -175,7 +175,7 @@ void assignVal(char *val, const char *src, int32_t len, int32_t type) {
break; break;
default: { default: {
if (len > 0) { if (len > 0) {
memcpy(val, src, len); (void)memcpy(val, src, len);
} }
break; break;

8
source/common/src/tvariant.c
View File

@ -426,7 +426,7 @@ void taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uin
size_t lenInwchar = len / TSDB_NCHAR_SIZE; size_t lenInwchar = len / TSDB_NCHAR_SIZE;
pVar->ucs4 = taosMemoryCalloc(1, (lenInwchar + 1) * TSDB_NCHAR_SIZE); pVar->ucs4 = taosMemoryCalloc(1, (lenInwchar + 1) * TSDB_NCHAR_SIZE);
memcpy(pVar->ucs4, pz, lenInwchar * TSDB_NCHAR_SIZE); (void)memcpy(pVar->ucs4, pz, lenInwchar * TSDB_NCHAR_SIZE);
pVar->nLen = (int32_t)len; pVar->nLen = (int32_t)len;
break; break;
@ -435,7 +435,7 @@ void taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uin
case TSDB_DATA_TYPE_VARBINARY: case TSDB_DATA_TYPE_VARBINARY:
case TSDB_DATA_TYPE_GEOMETRY: { // todo refactor, extract a method case TSDB_DATA_TYPE_GEOMETRY: { // todo refactor, extract a method
pVar->pz = taosMemoryCalloc(len + 1, sizeof(char)); pVar->pz = taosMemoryCalloc(len + 1, sizeof(char));
memcpy(pVar->pz, pz, len); (void)memcpy(pVar->pz, pz, len);
pVar->nLen = (int32_t)len; pVar->nLen = (int32_t)len;
break; break;
} }
@ -470,10 +470,10 @@ void taosVariantAssign(SVariant *pDst, const SVariant *pSrc) {
char *p = taosMemoryRealloc(pDst->pz, len); char *p = taosMemoryRealloc(pDst->pz, len);
ASSERT(p); ASSERT(p);
memset(p, 0, len); (void)memset(p, 0, len);
pDst->pz = p; pDst->pz = p;
memcpy(pDst->pz, pSrc->pz, pSrc->nLen); (void)memcpy(pDst->pz, pSrc->pz, pSrc->nLen);
pDst->nLen = pSrc->nLen; pDst->nLen = pSrc->nLen;
return; return;
} }

98
source/common/test/commonTests.cpp
View File

@ -733,16 +733,17 @@ TEST(AlreadyAddGroupIdTest, GroupIdAddedWithDifferentLength) {
#define SLOW_LOG_TYPE_OTHERS 0x4 #define SLOW_LOG_TYPE_OTHERS 0x4
#define SLOW_LOG_TYPE_ALL 0x7 #define SLOW_LOG_TYPE_ALL 0x7
static int32_t taosSetSlowLogScope(char *pScope) { static int32_t taosSetSlowLogScope(char* pScopeStr, int32_t* pScope) {
if (NULL == pScope || 0 == strlen(pScope)) { if (NULL == pScopeStr || 0 == strlen(pScopeStr)) {
return SLOW_LOG_TYPE_QUERY; *pScope = SLOW_LOG_TYPE_QUERY;
TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
int32_t slowScope = 0; int32_t slowScope = 0;
char* scope = NULL; char* scope = NULL;
char *tmp = NULL; char *tmp = NULL;
while((scope = strsep(&pScope, "|")) != NULL){ while((scope = strsep(&pScopeStr, "|")) != NULL){
taosMemoryFreeClear(tmp); taosMemoryFreeClear(tmp);
tmp = taosStrdup(scope); tmp = taosStrdup(scope);
strtrim(tmp); strtrim(tmp);
@ -772,73 +773,94 @@ static int32_t taosSetSlowLogScope(char *pScope) {
} }
taosMemoryFreeClear(tmp); taosMemoryFreeClear(tmp);
uError("Invalid slowLog scope value:%s", pScope); uError("Invalid slowLog scope value:%s", pScopeStr);
terrno = TSDB_CODE_INVALID_CFG_VALUE; TAOS_RETURN(TSDB_CODE_INVALID_CFG_VALUE);
return -1;
} }
*pScope = slowScope;
taosMemoryFreeClear(tmp); taosMemoryFreeClear(tmp);
return slowScope; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
TEST(TaosSetSlowLogScopeTest, NullPointerInput) { TEST(TaosSetSlowLogScopeTest, NullPointerInput) {
char *pScope = NULL; char* pScopeStr = NULL;
int32_t result = taosSetSlowLogScope(pScope); int32_t scope = 0;
EXPECT_EQ(result, SLOW_LOG_TYPE_QUERY); int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
EXPECT_EQ(result, TSDB_CODE_SUCCESS);
EXPECT_EQ(scope, SLOW_LOG_TYPE_QUERY);
} }
TEST(TaosSetSlowLogScopeTest, EmptyStringInput) { TEST(TaosSetSlowLogScopeTest, EmptyStringInput) {
char pScope[1] = ""; char pScopeStr[1] = "";
int32_t result = taosSetSlowLogScope(pScope); int32_t scope = 0;
EXPECT_EQ(result, SLOW_LOG_TYPE_QUERY); int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
EXPECT_EQ(result, TSDB_CODE_SUCCESS);
EXPECT_EQ(scope, SLOW_LOG_TYPE_QUERY);
} }
TEST(TaosSetSlowLogScopeTest, AllScopeInput) { TEST(TaosSetSlowLogScopeTest, AllScopeInput) {
char pScope[] = "all"; char pScopeStr[] = "all";
int32_t result = taosSetSlowLogScope(pScope); int32_t scope = 0;
EXPECT_EQ(result, SLOW_LOG_TYPE_ALL); int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
EXPECT_EQ(result, TSDB_CODE_SUCCESS);
EXPECT_EQ(scope, SLOW_LOG_TYPE_ALL);
} }
TEST(TaosSetSlowLogScopeTest, QueryScopeInput) { TEST(TaosSetSlowLogScopeTest, QueryScopeInput) {
char pScope[] = " query"; char pScopeStr[] = " query";
int32_t result = taosSetSlowLogScope(pScope); int32_t scope = 0;
EXPECT_EQ(result, SLOW_LOG_TYPE_QUERY); int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
EXPECT_EQ(result, TSDB_CODE_SUCCESS);
EXPECT_EQ(scope, SLOW_LOG_TYPE_QUERY);
} }
TEST(TaosSetSlowLogScopeTest, InsertScopeInput) { TEST(TaosSetSlowLogScopeTest, InsertScopeInput) {
char pScope[] = "insert"; char pScopeStr[] = "insert";
int32_t result = taosSetSlowLogScope(pScope); int32_t scope = 0;
EXPECT_EQ(result, SLOW_LOG_TYPE_INSERT); int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
EXPECT_EQ(result, TSDB_CODE_SUCCESS);
EXPECT_EQ(scope, SLOW_LOG_TYPE_INSERT);
} }
TEST(TaosSetSlowLogScopeTest, OthersScopeInput) { TEST(TaosSetSlowLogScopeTest, OthersScopeInput) {
char pScope[] = "others"; char pScopeStr[] = "others";
int32_t result = taosSetSlowLogScope(pScope); int32_t scope = 0;
EXPECT_EQ(result, SLOW_LOG_TYPE_OTHERS); int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
EXPECT_EQ(result, TSDB_CODE_SUCCESS);
EXPECT_EQ(scope, SLOW_LOG_TYPE_OTHERS);
} }
TEST(TaosSetSlowLogScopeTest, NoneScopeInput) { TEST(TaosSetSlowLogScopeTest, NoneScopeInput) {
char pScope[] = "none"; char pScopeStr[] = "none";
int32_t result = taosSetSlowLogScope(pScope); int32_t scope = 0;
EXPECT_EQ(result, SLOW_LOG_TYPE_NULL); int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
EXPECT_EQ(result, TSDB_CODE_SUCCESS);
EXPECT_EQ(scope, SLOW_LOG_TYPE_NULL);
} }
TEST(TaosSetSlowLogScopeTest, InvalidScopeInput) { TEST(TaosSetSlowLogScopeTest, InvalidScopeInput) {
char pScope[] = "invalid"; char pScopeStr[] = "invalid";
int32_t result = taosSetSlowLogScope(pScope); int32_t scope = 0;
EXPECT_EQ(result, -1); int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
EXPECT_EQ(result, TSDB_CODE_SUCCESS);
EXPECT_EQ(scope, -1);
} }
TEST(TaosSetSlowLogScopeTest, MixedScopesInput) { TEST(TaosSetSlowLogScopeTest, MixedScopesInput) {
char pScope[] = "query|insert|others|none"; char pScopeStr[] = "query|insert|others|none";
int32_t result = taosSetSlowLogScope(pScope); int32_t scope = 0;
EXPECT_EQ(result, (SLOW_LOG_TYPE_QUERY | SLOW_LOG_TYPE_INSERT | SLOW_LOG_TYPE_OTHERS)); int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
EXPECT_EQ(result, TSDB_CODE_SUCCESS);
EXPECT_EQ(scope, (SLOW_LOG_TYPE_QUERY | SLOW_LOG_TYPE_INSERT | SLOW_LOG_TYPE_OTHERS));
} }
TEST(TaosSetSlowLogScopeTest, MixedScopesInputWithSpaces) { TEST(TaosSetSlowLogScopeTest, MixedScopesInputWithSpaces) {
char pScope[] = "query | insert | others "; char pScopeStr[] = "query | insert | others ";
int32_t result = taosSetSlowLogScope(pScope); int32_t scope = 0;
EXPECT_EQ(result, (SLOW_LOG_TYPE_QUERY | SLOW_LOG_TYPE_INSERT | SLOW_LOG_TYPE_OTHERS)); int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
EXPECT_EQ(result, TSDB_CODE_SUCCESS);
EXPECT_EQ(scope, (SLOW_LOG_TYPE_QUERY | SLOW_LOG_TYPE_INSERT | SLOW_LOG_TYPE_OTHERS));
} }
#pragma GCC diagnostic pop #pragma GCC diagnostic pop

2
source/dnode/mgmt/exe/dmMain.c
View File

@ -74,7 +74,7 @@ static struct {
char encryptKey[ENCRYPT_KEY_LEN + 1]; char encryptKey[ENCRYPT_KEY_LEN + 1];
} global = {0}; } global = {0};
static void dmSetDebugFlag(int32_t signum, void *sigInfo, void *context) { taosSetGlobalDebugFlag(143); } static void dmSetDebugFlag(int32_t signum, void *sigInfo, void *context) { (void)taosSetGlobalDebugFlag(143); }
static void dmSetAssert(int32_t signum, void *sigInfo, void *context) { tsAssert = 1; } static void dmSetAssert(int32_t signum, void *sigInfo, void *context) { tsAssert = 1; }
static void dmStopDnode(int signum, void *sigInfo, void *context) { static void dmStopDnode(int signum, void *sigInfo, void *context) {

18
source/dnode/vnode/src/inc/metaTtl.h
View File

@ -85,18 +85,18 @@ typedef struct {
TXN* pTxn; TXN* pTxn;
} STtlDelTtlCtx; } STtlDelTtlCtx;
int ttlMgrOpen(STtlManger** ppTtlMgr, TDB* pEnv, int8_t rollback, const char* logPrefix, int32_t flushThreshold); int32_t ttlMgrOpen(STtlManger** ppTtlMgr, TDB* pEnv, int8_t rollback, const char* logPrefix, int32_t flushThreshold);
void ttlMgrClose(STtlManger* pTtlMgr); void ttlMgrClose(STtlManger* pTtlMgr);
bool ttlMgrNeedUpgrade(TDB* pEnv); bool ttlMgrNeedUpgrade(TDB* pEnv);
int ttlMgrUpgrade(STtlManger* pTtlMgr, void* pMeta); int32_t ttlMgrUpgrade(STtlManger* pTtlMgr, void* pMeta);
int ttlMgrInsertTtl(STtlManger* pTtlMgr, const STtlUpdTtlCtx* pUpdCtx); int32_t ttlMgrInsertTtl(STtlManger* pTtlMgr, const STtlUpdTtlCtx* pUpdCtx);
int ttlMgrDeleteTtl(STtlManger* pTtlMgr, const STtlDelTtlCtx* pDelCtx); int32_t ttlMgrDeleteTtl(STtlManger* pTtlMgr, const STtlDelTtlCtx* pDelCtx);
int ttlMgrUpdateChangeTime(STtlManger* pTtlMgr, const STtlUpdCtimeCtx* pUpdCtimeCtx); int32_t ttlMgrUpdateChangeTime(STtlManger* pTtlMgr, const STtlUpdCtimeCtx* pUpdCtimeCtx);
int ttlMgrFlush(STtlManger* pTtlMgr, TXN* pTxn); int32_t ttlMgrFlush(STtlManger* pTtlMgr, TXN* pTxn);
int ttlMgrFindExpired(STtlManger* pTtlMgr, int64_t timePointMs, SArray* pTbUids, int32_t ttlDropMaxCount); int32_t ttlMgrFindExpired(STtlManger* pTtlMgr, int64_t timePointMs, SArray* pTbUids, int32_t ttlDropMaxCount);
#ifdef __cplusplus #ifdef __cplusplus
} }

194
source/dnode/vnode/src/meta/metaTtl.c
View File

@ -46,39 +46,38 @@ static bool ttlMgrNeedFlush(STtlManger *pTtlMgr);
const char *ttlTbname = "ttl.idx"; const char *ttlTbname = "ttl.idx";
const char *ttlV1Tbname = "ttlv1.idx"; const char *ttlV1Tbname = "ttlv1.idx";
int ttlMgrOpen(STtlManger **ppTtlMgr, TDB *pEnv, int8_t rollback, const char *logPrefix, int32_t flushThreshold) { int32_t ttlMgrOpen(STtlManger **ppTtlMgr, TDB *pEnv, int8_t rollback, const char *logPrefix, int32_t flushThreshold) {
int ret = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int64_t startNs = taosGetTimestampNs(); int64_t startNs = taosGetTimestampNs();
*ppTtlMgr = NULL; *ppTtlMgr = NULL;
STtlManger *pTtlMgr = (STtlManger *)tdbOsCalloc(1, sizeof(*pTtlMgr)); STtlManger *pTtlMgr = (STtlManger *)tdbOsCalloc(1, sizeof(*pTtlMgr));
if (pTtlMgr == NULL) return TSDB_CODE_OUT_OF_MEMORY; if (pTtlMgr == NULL) TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
char *logBuffer = (char *)tdbOsCalloc(1, strlen(logPrefix) + 1); char *logBuffer = (char *)tdbOsCalloc(1, strlen(logPrefix) + 1);
if (logBuffer == NULL) { if (logBuffer == NULL) {
tdbOsFree(pTtlMgr); tdbOsFree(pTtlMgr);
return TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
strcpy(logBuffer, logPrefix); (void)strcpy(logBuffer, logPrefix);
pTtlMgr->logPrefix = logBuffer; pTtlMgr->logPrefix = logBuffer;
pTtlMgr->flushThreshold = flushThreshold; pTtlMgr->flushThreshold = flushThreshold;
ret = tdbTbOpen(ttlV1Tbname, TDB_VARIANT_LEN, TDB_VARIANT_LEN, ttlIdxKeyV1Cmpr, pEnv, &pTtlMgr->pTtlIdx, rollback); code = tdbTbOpen(ttlV1Tbname, TDB_VARIANT_LEN, TDB_VARIANT_LEN, ttlIdxKeyV1Cmpr, pEnv, &pTtlMgr->pTtlIdx, rollback);
if (ret < 0) { if (TSDB_CODE_SUCCESS != code) {
metaError("%s, failed to open %s since %s", pTtlMgr->logPrefix, ttlV1Tbname, tstrerror(terrno)); metaError("%s, failed to open %s since %s", pTtlMgr->logPrefix, ttlV1Tbname, tstrerror(code));
tdbOsFree(pTtlMgr); tdbOsFree(pTtlMgr);
return ret; TAOS_RETURN(code);
} }
pTtlMgr->pTtlCache = taosHashInit(8192, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK); pTtlMgr->pTtlCache = taosHashInit(8192, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
pTtlMgr->pDirtyUids = taosHashInit(8192, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK); pTtlMgr->pDirtyUids = taosHashInit(8192, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
ret = ttlMgrFillCache(pTtlMgr); if ((code = ttlMgrFillCache(pTtlMgr)) != TSDB_CODE_SUCCESS) {
if (ret < 0) {
metaError("%s, failed to fill hash since %s", pTtlMgr->logPrefix, tstrerror(terrno)); metaError("%s, failed to fill hash since %s", pTtlMgr->logPrefix, tstrerror(terrno));
ttlMgrCleanup(pTtlMgr); ttlMgrCleanup(pTtlMgr);
return ret; TAOS_RETURN(code);
} }
int64_t endNs = taosGetTimestampNs(); int64_t endNs = taosGetTimestampNs();
@ -86,7 +85,7 @@ int ttlMgrOpen(STtlManger **ppTtlMgr, TDB *pEnv, int8_t rollback, const char *lo
taosHashGetSize(pTtlMgr->pTtlCache), endNs - startNs); taosHashGetSize(pTtlMgr->pTtlCache), endNs - startNs);
*ppTtlMgr = pTtlMgr; *ppTtlMgr = pTtlMgr;
return TSDB_CODE_SUCCESS; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
void ttlMgrClose(STtlManger *pTtlMgr) { ttlMgrCleanup(pTtlMgr); } void ttlMgrClose(STtlManger *pTtlMgr) { ttlMgrCleanup(pTtlMgr); }
@ -99,37 +98,34 @@ bool ttlMgrNeedUpgrade(TDB *pEnv) {
return needUpgrade; return needUpgrade;
} }
int ttlMgrUpgrade(STtlManger *pTtlMgr, void *pMeta) { int32_t ttlMgrUpgrade(STtlManger *pTtlMgr, void *pMeta) {
SMeta *meta = (SMeta *)pMeta; SMeta *meta = (SMeta *)pMeta;
int ret = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
if (!tdbTbExist(ttlTbname, meta->pEnv)) return TSDB_CODE_SUCCESS; if (!tdbTbExist(ttlTbname, meta->pEnv)) TAOS_RETURN(TSDB_CODE_SUCCESS);
metaInfo("%s, ttl mgr start upgrade", pTtlMgr->logPrefix); metaInfo("%s, ttl mgr start upgrade", pTtlMgr->logPrefix);
int64_t startNs = taosGetTimestampNs(); int64_t startNs = taosGetTimestampNs();
ret = tdbTbOpen(ttlTbname, sizeof(STtlIdxKey), 0, ttlIdxKeyCmpr, meta->pEnv, &pTtlMgr->pOldTtlIdx, 0); code = tdbTbOpen(ttlTbname, sizeof(STtlIdxKey), 0, ttlIdxKeyCmpr, meta->pEnv, &pTtlMgr->pOldTtlIdx, 0);
if (ret < 0) { if (TSDB_CODE_SUCCESS != code) {
metaError("%s, failed to open %s index since %s", pTtlMgr->logPrefix, ttlTbname, tstrerror(terrno)); metaError("%s, failed to open %s index since %s", pTtlMgr->logPrefix, ttlTbname, tstrerror(code));
goto _out; goto _out;
} }
ret = ttlMgrConvert(pTtlMgr->pOldTtlIdx, pTtlMgr->pTtlIdx, pMeta); if ((code = ttlMgrConvert(pTtlMgr->pOldTtlIdx, pTtlMgr->pTtlIdx, pMeta)) != TSDB_CODE_SUCCESS) {
if (ret < 0) { metaError("%s, failed to convert ttl index since %s", pTtlMgr->logPrefix, tstrerror(code));
metaError("%s, failed to convert ttl index since %s", pTtlMgr->logPrefix, tstrerror(terrno));
goto _out; goto _out;
} }
ret = tdbTbDropByName(ttlTbname, meta->pEnv, meta->txn); if ((code = tdbTbDropByName(ttlTbname, meta->pEnv, meta->txn)) != TSDB_CODE_SUCCESS) {
if (ret < 0) { metaError("%s, failed to drop old ttl index since %s", pTtlMgr->logPrefix, tstrerror(code));
metaError("%s, failed to drop old ttl index since %s", pTtlMgr->logPrefix, tstrerror(terrno));
goto _out; goto _out;
} }
ret = ttlMgrFillCache(pTtlMgr); if ((code = ttlMgrFillCache(pTtlMgr)) != TSDB_CODE_SUCCESS) {
if (ret < 0) { metaError("%s, failed to fill hash since %s", pTtlMgr->logPrefix, tstrerror(code));
metaError("%s, failed to fill hash since %s", pTtlMgr->logPrefix, tstrerror(terrno));
goto _out; goto _out;
} }
@ -141,14 +137,14 @@ _out:
tdbTbClose(pTtlMgr->pOldTtlIdx); tdbTbClose(pTtlMgr->pOldTtlIdx);
pTtlMgr->pOldTtlIdx = NULL; pTtlMgr->pOldTtlIdx = NULL;
return ret; TAOS_RETURN(code);
} }
static void ttlMgrCleanup(STtlManger *pTtlMgr) { static void ttlMgrCleanup(STtlManger *pTtlMgr) {
taosMemoryFree(pTtlMgr->logPrefix); taosMemoryFree(pTtlMgr->logPrefix);
taosHashCleanup(pTtlMgr->pTtlCache); taosHashCleanup(pTtlMgr->pTtlCache);
taosHashCleanup(pTtlMgr->pDirtyUids); taosHashCleanup(pTtlMgr->pDirtyUids);
tdbTbClose(pTtlMgr->pTtlIdx); (void)tdbTbClose(pTtlMgr->pTtlIdx);
taosMemoryFree(pTtlMgr); taosMemoryFree(pTtlMgr);
} }
@ -215,30 +211,30 @@ static int32_t ttlMgrFillCacheOneEntry(const void *pKey, int keyLen, const void
return taosHashPut(pCache, &uid, sizeof(uid), &data, sizeof(data)); return taosHashPut(pCache, &uid, sizeof(uid), &data, sizeof(data));
} }
static int ttlMgrConvertOneEntry(const void *pKey, int keyLen, const void *pVal, int valLen, void *pConvertData) { static int32_t ttlMgrConvertOneEntry(const void *pKey, int keyLen, const void *pVal, int valLen, void *pConvertData) {
SConvertData *pData = (SConvertData *)pConvertData; SConvertData *pData = (SConvertData *)pConvertData;
STtlIdxKey *ttlKey = (STtlIdxKey *)pKey; STtlIdxKey *ttlKey = (STtlIdxKey *)pKey;
tb_uid_t uid = ttlKey->uid; tb_uid_t uid = ttlKey->uid;
int64_t ttlDays = 0; int64_t ttlDays = 0;
int ret = metaGetTableTtlByUid(pData->pMeta, uid, &ttlDays); int32_t code = TSDB_CODE_SUCCESS;
if (ret < 0) { if ((code = metaGetTableTtlByUid(pData->pMeta, uid, &ttlDays)) != TSDB_CODE_SUCCESS) {
metaError("ttlMgr convert failed to get ttl since %s", tstrerror(terrno)); metaError("ttlMgr convert failed to get ttl since %s", tstrerror(code));
goto _out; goto _out;
} }
STtlIdxKeyV1 ttlKeyV1 = {.deleteTimeMs = ttlKey->deleteTimeSec * 1000, .uid = uid}; STtlIdxKeyV1 ttlKeyV1 = {.deleteTimeMs = ttlKey->deleteTimeSec * 1000, .uid = uid};
ret = tdbTbUpsert(pData->pNewTtlIdx, &ttlKeyV1, sizeof(ttlKeyV1), &ttlDays, sizeof(ttlDays), pData->pMeta->txn); code = tdbTbUpsert(pData->pNewTtlIdx, &ttlKeyV1, sizeof(ttlKeyV1), &ttlDays, sizeof(ttlDays), pData->pMeta->txn);
if (ret < 0) { if (code != TSDB_CODE_SUCCESS) {
metaError("ttlMgr convert failed to upsert since %s", tstrerror(terrno)); metaError("ttlMgr convert failed to upsert since %s", tstrerror(code));
goto _out; goto _out;
} }
ret = 0; code = TSDB_CODE_SUCCESS;
_out: _out:
return ret; TAOS_RETURN(code);
} }
static int32_t ttlMgrFindExpiredOneEntry(const void *pKey, int keyLen, const void *pVal, int valLen, static int32_t ttlMgrFindExpiredOneEntry(const void *pKey, int keyLen, const void *pVal, int valLen,
@ -248,7 +244,10 @@ static int32_t ttlMgrFindExpiredOneEntry(const void *pKey, int keyLen, const voi
int c = ttlIdxKeyV1Cmpr(&pCtx->expiredKey, sizeof(pCtx->expiredKey), pKey, keyLen); int c = ttlIdxKeyV1Cmpr(&pCtx->expiredKey, sizeof(pCtx->expiredKey), pKey, keyLen);
if (c > 0) { if (c > 0) {
taosArrayPush(pCtx->pTbUids, &((STtlIdxKeyV1 *)pKey)->uid); if (NULL == taosArrayPush(pCtx->pTbUids, &((STtlIdxKeyV1 *)pKey)->uid)) {
metaError("ttlMgr find expired failed since %s", tstrerror(TSDB_CODE_OUT_OF_MEMORY));
return -1;
}
pCtx->count++; pCtx->count++;
} }
@ -262,16 +261,16 @@ static int ttlMgrConvert(TTB *pOldTtlIdx, TTB *pNewTtlIdx, void *pMeta) {
SConvertData cvData = {.pNewTtlIdx = pNewTtlIdx, .pMeta = meta}; SConvertData cvData = {.pNewTtlIdx = pNewTtlIdx, .pMeta = meta};
int ret = tdbTbTraversal(pOldTtlIdx, &cvData, ttlMgrConvertOneEntry); int code = TSDB_CODE_SUCCESS;
if (ret < 0) { if ((code = tdbTbTraversal(pOldTtlIdx, &cvData, ttlMgrConvertOneEntry)) != TSDB_CODE_SUCCESS) {
metaError("failed to convert since %s", tstrerror(terrno)); metaError("failed to convert since %s", tstrerror(code));
} }
metaInfo("ttlMgr convert end."); metaInfo("ttlMgr convert end.");
return ret; TAOS_RETURN(code);
} }
int ttlMgrInsertTtl(STtlManger *pTtlMgr, const STtlUpdTtlCtx *updCtx) { int32_t ttlMgrInsertTtl(STtlManger *pTtlMgr, const STtlUpdTtlCtx *updCtx) {
if (updCtx->ttlDays == 0) return 0; if (updCtx->ttlDays == 0) return 0;
STtlCacheEntry cacheEntry = {.ttlDays = updCtx->ttlDays, STtlCacheEntry cacheEntry = {.ttlDays = updCtx->ttlDays,
@ -280,56 +279,55 @@ int ttlMgrInsertTtl(STtlManger *pTtlMgr, const STtlUpdTtlCtx *updCtx) {
.changeTimeMsDirty = updCtx->changeTimeMs}; .changeTimeMsDirty = updCtx->changeTimeMs};
STtlDirtyEntry dirtryEntry = {.type = ENTRY_TYPE_UPSERT}; STtlDirtyEntry dirtryEntry = {.type = ENTRY_TYPE_UPSERT};
int ret = taosHashPut(pTtlMgr->pTtlCache, &updCtx->uid, sizeof(updCtx->uid), &cacheEntry, sizeof(cacheEntry)); int32_t code = taosHashPut(pTtlMgr->pTtlCache, &updCtx->uid, sizeof(updCtx->uid), &cacheEntry, sizeof(cacheEntry));
if (ret < 0) { if (TSDB_CODE_SUCCESS != code) {
metaError("%s, ttlMgr insert failed to update cache since %s", pTtlMgr->logPrefix, tstrerror(terrno)); metaError("%s, ttlMgr insert failed to update cache since %s", pTtlMgr->logPrefix, tstrerror(code));
goto _out; goto _out;
} }
ret = taosHashPut(pTtlMgr->pDirtyUids, &updCtx->uid, sizeof(updCtx->uid), &dirtryEntry, sizeof(dirtryEntry)); code = taosHashPut(pTtlMgr->pDirtyUids, &updCtx->uid, sizeof(updCtx->uid), &dirtryEntry, sizeof(dirtryEntry));
if (ret < 0) { if (TSDB_CODE_SUCCESS != code) {
metaError("%s, ttlMgr insert failed to update dirty uids since %s", pTtlMgr->logPrefix, tstrerror(terrno)); metaError("%s, ttlMgr insert failed to update dirty uids since %s", pTtlMgr->logPrefix, tstrerror(code));
goto _out; goto _out;
} }
if (ttlMgrNeedFlush(pTtlMgr)) { if (ttlMgrNeedFlush(pTtlMgr)) {
ttlMgrFlush(pTtlMgr, updCtx->pTxn); (void)ttlMgrFlush(pTtlMgr, updCtx->pTxn);
} }
ret = 0; code = TSDB_CODE_SUCCESS;
_out: _out:
metaTrace("%s, ttl mgr insert ttl, uid: %" PRId64 ", ctime: %" PRId64 ", ttlDays: %" PRId64, pTtlMgr->logPrefix, metaTrace("%s, ttl mgr insert ttl, uid: %" PRId64 ", ctime: %" PRId64 ", ttlDays: %" PRId64, pTtlMgr->logPrefix,
updCtx->uid, updCtx->changeTimeMs, updCtx->ttlDays); updCtx->uid, updCtx->changeTimeMs, updCtx->ttlDays);
return ret; TAOS_RETURN(code);
} }
int ttlMgrDeleteTtl(STtlManger *pTtlMgr, const STtlDelTtlCtx *delCtx) { int32_t ttlMgrDeleteTtl(STtlManger *pTtlMgr, const STtlDelTtlCtx *delCtx) {
if (delCtx->ttlDays == 0) return 0; if (delCtx->ttlDays == 0) return 0;
STtlDirtyEntry dirtryEntry = {.type = ENTRY_TYPE_DELETE}; STtlDirtyEntry dirtryEntry = {.type = ENTRY_TYPE_DELETE};
int ret = taosHashPut(pTtlMgr->pDirtyUids, &delCtx->uid, sizeof(delCtx->uid), &dirtryEntry, sizeof(dirtryEntry)); int32_t code = taosHashPut(pTtlMgr->pDirtyUids, &delCtx->uid, sizeof(delCtx->uid), &dirtryEntry, sizeof(dirtryEntry));
if (ret < 0) { if (TSDB_CODE_SUCCESS != code) {
metaError("%s, ttlMgr del failed to update dirty uids since %s", pTtlMgr->logPrefix, tstrerror(terrno)); metaError("%s, ttlMgr del failed to update dirty uids since %s", pTtlMgr->logPrefix, tstrerror(code));
goto _out; goto _out;
} }
if (ttlMgrNeedFlush(pTtlMgr)) { if (ttlMgrNeedFlush(pTtlMgr)) {
ttlMgrFlush(pTtlMgr, delCtx->pTxn); (void)ttlMgrFlush(pTtlMgr, delCtx->pTxn);
} }
ret = 0; code = TSDB_CODE_SUCCESS;
_out: _out:
metaTrace("%s, ttl mgr delete ttl, uid: %" PRId64, pTtlMgr->logPrefix, delCtx->uid); metaTrace("%s, ttl mgr delete ttl, uid: %" PRId64, pTtlMgr->logPrefix, delCtx->uid);
TAOS_RETURN(code);
return ret;
} }
int ttlMgrUpdateChangeTime(STtlManger *pTtlMgr, const STtlUpdCtimeCtx *pUpdCtimeCtx) { int32_t ttlMgrUpdateChangeTime(STtlManger *pTtlMgr, const STtlUpdCtimeCtx *pUpdCtimeCtx) {
int ret = 0; int32_t code = TSDB_CODE_SUCCESS;
STtlCacheEntry *oldData = taosHashGet(pTtlMgr->pTtlCache, &pUpdCtimeCtx->uid, sizeof(pUpdCtimeCtx->uid)); STtlCacheEntry *oldData = taosHashGet(pTtlMgr->pTtlCache, &pUpdCtimeCtx->uid, sizeof(pUpdCtimeCtx->uid));
if (oldData == NULL) { if (oldData == NULL) {
@ -342,43 +340,39 @@ int ttlMgrUpdateChangeTime(STtlManger *pTtlMgr, const STtlUpdCtimeCtx *pUpdCtime
.changeTimeMsDirty = pUpdCtimeCtx->changeTimeMs}; .changeTimeMsDirty = pUpdCtimeCtx->changeTimeMs};
STtlDirtyEntry dirtryEntry = {.type = ENTRY_TYPE_UPSERT}; STtlDirtyEntry dirtryEntry = {.type = ENTRY_TYPE_UPSERT};
ret = taosHashPut(pTtlMgr->pTtlCache, &pUpdCtimeCtx->uid, sizeof(pUpdCtimeCtx->uid), &cacheEntry, sizeof(cacheEntry)); code = taosHashPut(pTtlMgr->pTtlCache, &pUpdCtimeCtx->uid, sizeof(pUpdCtimeCtx->uid), &cacheEntry, sizeof(cacheEntry));
if (ret < 0) { if (TSDB_CODE_SUCCESS != code) {
metaError("%s, ttlMgr update ctime failed to update cache since %s", pTtlMgr->logPrefix, tstrerror(terrno)); metaError("%s, ttlMgr update ctime failed to update cache since %s", pTtlMgr->logPrefix, tstrerror(code));
goto _out; goto _out;
} }
ret = taosHashPut(pTtlMgr->pDirtyUids, &pUpdCtimeCtx->uid, sizeof(pUpdCtimeCtx->uid), &dirtryEntry, code = taosHashPut(pTtlMgr->pDirtyUids, &pUpdCtimeCtx->uid, sizeof(pUpdCtimeCtx->uid), &dirtryEntry,
sizeof(dirtryEntry)); sizeof(dirtryEntry));
if (ret < 0) { if (TSDB_CODE_SUCCESS != code) {
metaError("%s, ttlMgr update ctime failed to update dirty uids since %s", pTtlMgr->logPrefix, metaError("%s, ttlMgr update ctime failed to update dirty uids since %s", pTtlMgr->logPrefix,
tstrerror(terrno)); tstrerror(code));
goto _out; goto _out;
} }
if (ttlMgrNeedFlush(pTtlMgr)) { if (ttlMgrNeedFlush(pTtlMgr)) {
ttlMgrFlush(pTtlMgr, pUpdCtimeCtx->pTxn); (void)ttlMgrFlush(pTtlMgr, pUpdCtimeCtx->pTxn);
} }
ret = 0; code = TSDB_CODE_SUCCESS;
_out: _out:
metaTrace("%s, ttl mgr update ctime, uid: %" PRId64 ", ctime: %" PRId64, pTtlMgr->logPrefix, pUpdCtimeCtx->uid, metaTrace("%s, ttl mgr update ctime, uid: %" PRId64 ", ctime: %" PRId64, pTtlMgr->logPrefix, pUpdCtimeCtx->uid,
pUpdCtimeCtx->changeTimeMs); pUpdCtimeCtx->changeTimeMs);
TAOS_RETURN(code);
return ret;
} }
int ttlMgrFindExpired(STtlManger *pTtlMgr, int64_t timePointMs, SArray *pTbUids, int32_t ttlDropMaxCount) { int32_t ttlMgrFindExpired(STtlManger *pTtlMgr, int64_t timePointMs, SArray *pTbUids, int32_t ttlDropMaxCount) {
int ret = -1; int32_t code = TSDB_CODE_SUCCESS;
STtlIdxKeyV1 ttlKey = {.deleteTimeMs = timePointMs, .uid = INT64_MAX}; STtlIdxKeyV1 ttlKey = {.deleteTimeMs = timePointMs, .uid = INT64_MAX};
STtlExpiredCtx expiredCtx = { STtlExpiredCtx expiredCtx = {
.ttlDropMaxCount = ttlDropMaxCount, .count = 0, .expiredKey = ttlKey, .pTbUids = pTbUids}; .ttlDropMaxCount = ttlDropMaxCount, .count = 0, .expiredKey = ttlKey, .pTbUids = pTbUids};
ret = tdbTbTraversal(pTtlMgr->pTtlIdx, &expiredCtx, ttlMgrFindExpiredOneEntry); TAOS_CHECK_GOTO(tdbTbTraversal(pTtlMgr->pTtlIdx, &expiredCtx, ttlMgrFindExpiredOneEntry), NULL, _out);
if (ret) {
goto _out;
}
size_t vIdx = 0; size_t vIdx = 0;
for (size_t i = 0; i < pTbUids->size; i++) { for (size_t i = 0; i < pTbUids->size; i++) {
@ -393,20 +387,20 @@ int ttlMgrFindExpired(STtlManger *pTtlMgr, int64_t timePointMs, SArray *pTbUids,
taosArrayPopTailBatch(pTbUids, pTbUids->size - vIdx); taosArrayPopTailBatch(pTbUids, pTbUids->size - vIdx);
_out: _out:
return ret; TAOS_RETURN(code);
} }
static bool ttlMgrNeedFlush(STtlManger *pTtlMgr) { static bool ttlMgrNeedFlush(STtlManger *pTtlMgr) {
return pTtlMgr->flushThreshold > 0 && taosHashGetSize(pTtlMgr->pDirtyUids) > pTtlMgr->flushThreshold; return pTtlMgr->flushThreshold > 0 && taosHashGetSize(pTtlMgr->pDirtyUids) > pTtlMgr->flushThreshold;
} }
int ttlMgrFlush(STtlManger *pTtlMgr, TXN *pTxn) { int32_t ttlMgrFlush(STtlManger *pTtlMgr, TXN *pTxn) {
int64_t startNs = taosGetTimestampNs(); int64_t startNs = taosGetTimestampNs();
int64_t endNs = startNs; int64_t endNs = startNs;
metaTrace("%s, ttl mgr flush start. dirty uids:%d", pTtlMgr->logPrefix, taosHashGetSize(pTtlMgr->pDirtyUids)); metaTrace("%s, ttl mgr flush start. dirty uids:%d", pTtlMgr->logPrefix, taosHashGetSize(pTtlMgr->pDirtyUids));
int ret = -1; int32_t code = TSDB_CODE_SUCCESS;
void *pIter = taosHashIterate(pTtlMgr->pDirtyUids, NULL); void *pIter = taosHashIterate(pTtlMgr->pDirtyUids, NULL);
while (pIter != NULL) { while (pIter != NULL) {
@ -415,8 +409,8 @@ int ttlMgrFlush(STtlManger *pTtlMgr, TXN *pTxn) {
STtlCacheEntry *cacheEntry = taosHashGet(pTtlMgr->pTtlCache, pUid, sizeof(*pUid)); STtlCacheEntry *cacheEntry = taosHashGet(pTtlMgr->pTtlCache, pUid, sizeof(*pUid));
if (cacheEntry == NULL) { if (cacheEntry == NULL) {
metaError("%s, ttlMgr flush failed to get ttl cache since %s, uid: %" PRId64 ", type: %d", pTtlMgr->logPrefix, metaError("%s, ttlMgr flush failed to get ttl cache, uid: %" PRId64 ", type: %d", pTtlMgr->logPrefix, *pUid,
tstrerror(terrno), *pUid, pEntry->type); pEntry->type);
continue; continue;
} }
@ -428,26 +422,26 @@ int ttlMgrFlush(STtlManger *pTtlMgr, TXN *pTxn) {
if (pEntry->type == ENTRY_TYPE_UPSERT) { if (pEntry->type == ENTRY_TYPE_UPSERT) {
// delete old key & upsert new key // delete old key & upsert new key
tdbTbDelete(pTtlMgr->pTtlIdx, &ttlKey, sizeof(ttlKey), pTxn); // maybe first insert, ignore error (void)tdbTbDelete(pTtlMgr->pTtlIdx, &ttlKey, sizeof(ttlKey), pTxn); // maybe first insert, ignore error
ret = tdbTbUpsert(pTtlMgr->pTtlIdx, &ttlKeyDirty, sizeof(ttlKeyDirty), &cacheEntry->ttlDaysDirty, code = tdbTbUpsert(pTtlMgr->pTtlIdx, &ttlKeyDirty, sizeof(ttlKeyDirty), &cacheEntry->ttlDaysDirty,
sizeof(cacheEntry->ttlDaysDirty), pTxn); sizeof(cacheEntry->ttlDaysDirty), pTxn);
if (ret < 0) { if (TSDB_CODE_SUCCESS != code) {
metaError("%s, ttlMgr flush failed to upsert since %s", pTtlMgr->logPrefix, tstrerror(terrno)); metaError("%s, ttlMgr flush failed to upsert since %s", pTtlMgr->logPrefix, tstrerror(code));
goto _out; goto _out;
} }
cacheEntry->ttlDays = cacheEntry->ttlDaysDirty; cacheEntry->ttlDays = cacheEntry->ttlDaysDirty;
cacheEntry->changeTimeMs = cacheEntry->changeTimeMsDirty; cacheEntry->changeTimeMs = cacheEntry->changeTimeMsDirty;
} else if (pEntry->type == ENTRY_TYPE_DELETE) { } else if (pEntry->type == ENTRY_TYPE_DELETE) {
ret = tdbTbDelete(pTtlMgr->pTtlIdx, &ttlKey, sizeof(ttlKey), pTxn); code = tdbTbDelete(pTtlMgr->pTtlIdx, &ttlKey, sizeof(ttlKey), pTxn);
if (ret < 0) { if (TSDB_CODE_SUCCESS != code) {
metaError("%s, ttlMgr flush failed to delete since %s", pTtlMgr->logPrefix, tstrerror(terrno)); metaError("%s, ttlMgr flush failed to delete since %s", pTtlMgr->logPrefix, tstrerror(code));
goto _out; goto _out;
} }
ret = taosHashRemove(pTtlMgr->pTtlCache, pUid, sizeof(*pUid)); code = taosHashRemove(pTtlMgr->pTtlCache, pUid, sizeof(*pUid));
if (ret < 0) { if (TSDB_CODE_SUCCESS != code) {
metaError("%s, ttlMgr flush failed to remove cache since %s", pTtlMgr->logPrefix, tstrerror(terrno)); metaError("%s, ttlMgr flush failed to remove cache since %s", pTtlMgr->logPrefix, tstrerror(code));
goto _out; goto _out;
} }
} else { } else {
@ -457,16 +451,16 @@ int ttlMgrFlush(STtlManger *pTtlMgr, TXN *pTxn) {
void *pIterTmp = pIter; void *pIterTmp = pIter;
pIter = taosHashIterate(pTtlMgr->pDirtyUids, pIterTmp); pIter = taosHashIterate(pTtlMgr->pDirtyUids, pIterTmp);
taosHashRemove(pTtlMgr->pDirtyUids, pUid, sizeof(tb_uid_t)); (void)taosHashRemove(pTtlMgr->pDirtyUids, pUid, sizeof(tb_uid_t));
} }
taosHashClear(pTtlMgr->pDirtyUids); taosHashClear(pTtlMgr->pDirtyUids);
ret = 0; code = TSDB_CODE_SUCCESS;
_out: _out:
endNs = taosGetTimestampNs(); endNs = taosGetTimestampNs();
metaTrace("%s, ttl mgr flush end, time consumed: %" PRId64 " ns", pTtlMgr->logPrefix, endNs - startNs); metaTrace("%s, ttl mgr flush end, time consumed: %" PRId64 " ns", pTtlMgr->logPrefix, endNs - startNs);
return ret; TAOS_RETURN(code);
} }

4
source/libs/command/src/command.c
View File

@ -827,9 +827,7 @@ static int32_t execAlterLocal(SAlterLocalStmt* pStmt) {
return terrno; return terrno;
} }
if (taosCfgDynamicOptions(tsCfg, pStmt->config, false)) { TAOS_CHECK_RETURN(taosCfgDynamicOptions(tsCfg, pStmt->config, false));
return terrno;
}
_return: _return:

6
source/libs/geometry/src/geosWrapper.c
View File

@ -29,7 +29,7 @@ void geosFreeBuffer(void *buffer) {
void geosErrMsgeHandler(const char *errMsg, void *userData) { void geosErrMsgeHandler(const char *errMsg, void *userData) {
char *targetErrMsg = userData; char *targetErrMsg = userData;
snprintf(targetErrMsg, 512, "%s", errMsg); (void)snprintf(targetErrMsg, 512, "%s", errMsg);
} }
int32_t initCtxMakePoint() { int32_t initCtxMakePoint() {
@ -94,7 +94,7 @@ static int32_t initWktRegex(pcre2_code **ppRegex, pcre2_match_data **ppMatchData
return TSDB_CODE_OUT_OF_MEMORY; return TSDB_CODE_OUT_OF_MEMORY;
} }
sprintf( (void)sprintf(
wktPatternWithSpace, wktPatternWithSpace,
"^( *)point( *)z?m?( *)((empty)|(\\(( *)(([-+]?[0-9]+\\.?[0-9]*)|([-+]?[0-9]*\\.?[0-9]+))(e[-+]?[0-9]+)?(( " "^( *)point( *)z?m?( *)((empty)|(\\(( *)(([-+]?[0-9]+\\.?[0-9]*)|([-+]?[0-9]*\\.?[0-9]+))(e[-+]?[0-9]+)?(( "
"*)(([-+]?[0-9]+\\.?[0-9]*)|([-+]?[0-9]*\\.?[0-9]+))(e[-+]?[0-9]+)?){1,3}( *)\\)))|linestring( *)z?m?( " "*)(([-+]?[0-9]+\\.?[0-9]*)|([-+]?[0-9]*\\.?[0-9]+))(e[-+]?[0-9]+)?){1,3}( *)\\)))|linestring( *)z?m?( "
@ -264,7 +264,7 @@ int32_t doAsText(const unsigned char *inputGeom, size_t size, char **outputWKT)
SGeosContext *geosCtx = getThreadLocalGeosCtx(); SGeosContext *geosCtx = getThreadLocalGeosCtx();
GEOSGeometry *geom = NULL; GEOSGeometry *geom = NULL;
unsigned char *wkt = NULL; char *wkt = NULL;
geom = GEOSWKBReader_read_r(geosCtx->handle, geosCtx->WKBReader, inputGeom, size); geom = GEOSWKBReader_read_r(geosCtx->handle, geosCtx->WKBReader, inputGeom, size);
if (geom == NULL) { if (geom == NULL) {

175
source/util/src/tconfig.c
View File

@ -42,7 +42,7 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url);
extern char **environ; extern char **environ;
int32_t cfgInit(SConfig ** ppCfg) { int32_t cfgInit(SConfig **ppCfg) {
SConfig *pCfg = taosMemoryCalloc(1, sizeof(SConfig)); SConfig *pCfg = taosMemoryCalloc(1, sizeof(SConfig));
if (pCfg == NULL) { if (pCfg == NULL) {
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
@ -54,7 +54,7 @@ int32_t cfgInit(SConfig ** ppCfg) {
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
taosThreadMutexInit(&pCfg->lock, NULL); TAOS_CHECK_RETURN(taosThreadMutexInit(&pCfg->lock, NULL));
*ppCfg = pCfg; *ppCfg = pCfg;
TAOS_RETURN(TSDB_CODE_SUCCESS); TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
@ -113,7 +113,7 @@ void cfgCleanup(SConfig *pCfg) {
} }
taosArrayDestroy(pCfg->array); taosArrayDestroy(pCfg->array);
taosThreadMutexDestroy(&pCfg->lock); (void)taosThreadMutexDestroy(&pCfg->lock);
taosMemoryFree(pCfg); taosMemoryFree(pCfg);
} }
@ -244,17 +244,17 @@ static int32_t doSetConf(SConfigItem *pItem, const char *value, ECfgSrcType styp
static int32_t cfgSetTimezone(SConfigItem *pItem, const char *value, ECfgSrcType stype) { static int32_t cfgSetTimezone(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
TAOS_CHECK_RETURN(doSetConf(pItem, value, stype)); TAOS_CHECK_RETURN(doSetConf(pItem, value, stype));
osSetTimezone(value); TAOS_CHECK_RETURN(osSetTimezone(value));
TAOS_RETURN(TSDB_CODE_SUCCESS); TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value, const char *level, const char *primary, static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value, const char *level, const char *primary,
const char *disable, ECfgSrcType stype) { const char *disable, ECfgSrcType stype) {
taosThreadMutexLock(&pCfg->lock); (void)taosThreadMutexLock(&pCfg->lock);
SConfigItem *pItem = cfgGetItem(pCfg, name); SConfigItem *pItem = cfgGetItem(pCfg, name);
if (pItem == NULL) { if (pItem == NULL) {
taosThreadMutexUnlock(&pCfg->lock); (void)taosThreadMutexUnlock(&pCfg->lock);
TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND); TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
} }
@ -262,7 +262,7 @@ static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value,
if (pItem->array == NULL) { if (pItem->array == NULL) {
pItem->array = taosArrayInit(16, sizeof(SDiskCfg)); pItem->array = taosArrayInit(16, sizeof(SDiskCfg));
if (pItem->array == NULL) { if (pItem->array == NULL) {
taosThreadMutexUnlock(&pCfg->lock); (void)taosThreadMutexUnlock(&pCfg->lock);
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
@ -275,13 +275,13 @@ static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value,
cfg.disable = disable ? atoi(disable) : 0; cfg.disable = disable ? atoi(disable) : 0;
void *ret = taosArrayPush(pItem->array, &cfg); void *ret = taosArrayPush(pItem->array, &cfg);
if (ret == NULL) { if (ret == NULL) {
taosThreadMutexUnlock(&pCfg->lock); (void)taosThreadMutexUnlock(&pCfg->lock);
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
pItem->stype = stype; pItem->stype = stype;
taosThreadMutexUnlock(&pCfg->lock); (void)taosThreadMutexUnlock(&pCfg->lock);
TAOS_RETURN(TSDB_CODE_SUCCESS); TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
@ -307,7 +307,7 @@ static int32_t cfgUpdateDebugFlagItem(SConfig *pCfg, const char *name, bool rese
if (pDebugFlagItem == NULL) return -1; if (pDebugFlagItem == NULL) return -1;
if (pDebugFlagItem->array != NULL) { if (pDebugFlagItem->array != NULL) {
SLogVar logVar = {0}; SLogVar logVar = {0};
strncpy(logVar.name, name, TSDB_LOG_VAR_LEN - 1); (void)strncpy(logVar.name, name, TSDB_LOG_VAR_LEN - 1);
if (NULL == taosArrayPush(pDebugFlagItem->array, &logVar)) { if (NULL == taosArrayPush(pDebugFlagItem->array, &logVar)) {
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
@ -317,15 +317,15 @@ static int32_t cfgUpdateDebugFlagItem(SConfig *pCfg, const char *name, bool rese
int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcType stype, bool lock) { int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcType stype, bool lock) {
// GRANT_CFG_SET; // GRANT_CFG_SET;
int32_t code = 0; int32_t code = TSDB_CODE_SUCCESS;
if (lock) { if (lock) {
taosThreadMutexLock(&pCfg->lock); (void)taosThreadMutexLock(&pCfg->lock);
} }
SConfigItem *pItem = cfgGetItem(pCfg, name); SConfigItem *pItem = cfgGetItem(pCfg, name);
if (pItem == NULL) { if (pItem == NULL) {
taosThreadMutexUnlock(&pCfg->lock); (void)taosThreadMutexUnlock(&pCfg->lock);
TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND); TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
} }
@ -374,7 +374,7 @@ int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcTy
} }
if (lock) { if (lock) {
taosThreadMutexUnlock(&pCfg->lock); (void)taosThreadMutexUnlock(&pCfg->lock);
} }
TAOS_RETURN(code); TAOS_RETURN(code);
@ -398,12 +398,10 @@ void cfgLock(SConfig *pCfg) {
return; return;
} }
taosThreadMutexLock(&pCfg->lock); (void)taosThreadMutexLock(&pCfg->lock);
} }
void cfgUnLock(SConfig *pCfg) { void cfgUnLock(SConfig *pCfg) { (void)taosThreadMutexUnlock(&pCfg->lock); }
taosThreadMutexUnlock(&pCfg->lock);
}
int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *pVal, bool isServer) { int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *pVal, bool isServer) {
ECfgDynType dynType = isServer ? CFG_DYN_SERVER : CFG_DYN_CLIENT; ECfgDynType dynType = isServer ? CFG_DYN_SERVER : CFG_DYN_CLIENT;
@ -420,11 +418,13 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p
switch (pItem->dtype) { switch (pItem->dtype) {
case CFG_DTYPE_STRING: { case CFG_DTYPE_STRING: {
if (strcasecmp(name, "slowLogScope") == 0) { if (strcasecmp(name, "slowLogScope") == 0) {
char *tmp = taosStrdup(pVal); char *tmp = taosStrdup(pVal);
if (taosSetSlowLogScope(tmp) < 0) { int32_t scope = 0;
int32_t code = taosSetSlowLogScope(tmp, &scope);
if (TSDB_CODE_SUCCESS != code) {
cfgUnLock(pCfg); cfgUnLock(pCfg);
taosMemoryFree(tmp); taosMemoryFree(tmp);
TAOS_RETURN(TSDB_CODE_INVALID_CFG); TAOS_RETURN(code);
} }
taosMemoryFree(tmp); taosMemoryFree(tmp);
} }
@ -506,7 +506,7 @@ static int32_t cfgAddItem(SConfig *pCfg, SConfigItem *pItem, const char *name) {
int32_t len = strlen(name); int32_t len = strlen(name);
char lowcaseName[CFG_NAME_MAX_LEN + 1] = {0}; char lowcaseName[CFG_NAME_MAX_LEN + 1] = {0};
strntolower(lowcaseName, name, TMIN(CFG_NAME_MAX_LEN, len)); (void)strntolower(lowcaseName, name, TMIN(CFG_NAME_MAX_LEN, len));
if (taosArrayPush(pCfg->array, pItem) == NULL) { if (taosArrayPush(pCfg->array, pItem) == NULL) {
if (pItem->dtype == CFG_DTYPE_STRING) { if (pItem->dtype == CFG_DTYPE_STRING) {
@ -721,10 +721,10 @@ int32_t cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t
void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump) { void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump) {
if (dump) { if (dump) {
printf(" s3 config"); (void)printf(" s3 config");
printf("\n"); (void)printf("\n");
printf("================================================================="); (void)printf("=================================================================");
printf("\n"); (void)printf("\n");
} else { } else {
uInfo(" s3 config"); uInfo(" s3 config");
uInfo("================================================================="); uInfo("=================================================================");
@ -752,7 +752,7 @@ void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump) {
switch (pItem->dtype) { switch (pItem->dtype) {
case CFG_DTYPE_BOOL: case CFG_DTYPE_BOOL:
if (dump) { if (dump) {
printf("%s %s %u\n", src, name, pItem->bval); (void)printf("%s %s %u\n", src, name, pItem->bval);
} else { } else {
uInfo("%s %s %u", src, name, pItem->bval); uInfo("%s %s %u", src, name, pItem->bval);
} }
@ -760,14 +760,14 @@ void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump) {
break; break;
case CFG_DTYPE_INT32: case CFG_DTYPE_INT32:
if (dump) { if (dump) {
printf("%s %s %d\n", src, name, pItem->i32); (void)printf("%s %s %d\n", src, name, pItem->i32);
} else { } else {
uInfo("%s %s %d", src, name, pItem->i32); uInfo("%s %s %d", src, name, pItem->i32);
} }
break; break;
case CFG_DTYPE_INT64: case CFG_DTYPE_INT64:
if (dump) { if (dump) {
printf("%s %s %" PRId64 "\n", src, name, pItem->i64); (void)printf("%s %s %" PRId64 "\n", src, name, pItem->i64);
} else { } else {
uInfo("%s %s %" PRId64, src, name, pItem->i64); uInfo("%s %s %" PRId64, src, name, pItem->i64);
} }
@ -775,7 +775,7 @@ void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump) {
case CFG_DTYPE_DOUBLE: case CFG_DTYPE_DOUBLE:
case CFG_DTYPE_FLOAT: case CFG_DTYPE_FLOAT:
if (dump) { if (dump) {
printf("%s %s %.2f\n", src, name, pItem->fval); (void)printf("%s %s %.2f\n", src, name, pItem->fval);
} else { } else {
uInfo("%s %s %.2f", src, name, pItem->fval); uInfo("%s %s %.2f", src, name, pItem->fval);
} }
@ -787,7 +787,7 @@ void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump) {
case CFG_DTYPE_TIMEZONE: case CFG_DTYPE_TIMEZONE:
case CFG_DTYPE_NONE: case CFG_DTYPE_NONE:
if (dump) { if (dump) {
printf("%s %s %s\n", src, name, pItem->str); (void)printf("%s %s %s\n", src, name, pItem->str);
} else { } else {
uInfo("%s %s %s", src, name, pItem->str); uInfo("%s %s %s", src, name, pItem->str);
} }
@ -796,7 +796,7 @@ void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump) {
} }
if (dump) { if (dump) {
printf("=================================================================\n"); (void)printf("=================================================================\n");
} else { } else {
uInfo("================================================================="); uInfo("=================================================================");
} }
@ -804,10 +804,10 @@ void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump) {
void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump) { void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump) {
if (dump) { if (dump) {
printf(" global config"); (void)printf(" global config");
printf("\n"); (void)printf("\n");
printf("================================================================="); (void)printf("=================================================================");
printf("\n"); (void)printf("\n");
} else { } else {
uInfo(" global config"); uInfo(" global config");
uInfo("================================================================="); uInfo("=================================================================");
@ -834,7 +834,7 @@ void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump) {
switch (pItem->dtype) { switch (pItem->dtype) {
case CFG_DTYPE_BOOL: case CFG_DTYPE_BOOL:
if (dump) { if (dump) {
printf("%s %s %u\n", src, name, pItem->bval); (void)printf("%s %s %u\n", src, name, pItem->bval);
} else { } else {
uInfo("%s %s %u", src, name, pItem->bval); uInfo("%s %s %u", src, name, pItem->bval);
} }
@ -842,14 +842,14 @@ void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump) {
break; break;
case CFG_DTYPE_INT32: case CFG_DTYPE_INT32:
if (dump) { if (dump) {
printf("%s %s %d\n", src, name, pItem->i32); (void)printf("%s %s %d\n", src, name, pItem->i32);
} else { } else {
uInfo("%s %s %d", src, name, pItem->i32); uInfo("%s %s %d", src, name, pItem->i32);
} }
break; break;
case CFG_DTYPE_INT64: case CFG_DTYPE_INT64:
if (dump) { if (dump) {
printf("%s %s %" PRId64 "\n", src, name, pItem->i64); (void)printf("%s %s %" PRId64 "\n", src, name, pItem->i64);
} else { } else {
uInfo("%s %s %" PRId64, src, name, pItem->i64); uInfo("%s %s %" PRId64, src, name, pItem->i64);
} }
@ -857,7 +857,7 @@ void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump) {
case CFG_DTYPE_DOUBLE: case CFG_DTYPE_DOUBLE:
case CFG_DTYPE_FLOAT: case CFG_DTYPE_FLOAT:
if (dump) { if (dump) {
printf("%s %s %.2f\n", src, name, pItem->fval); (void)printf("%s %s %.2f\n", src, name, pItem->fval);
} else { } else {
uInfo("%s %s %.2f", src, name, pItem->fval); uInfo("%s %s %.2f", src, name, pItem->fval);
} }
@ -869,7 +869,7 @@ void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump) {
case CFG_DTYPE_TIMEZONE: case CFG_DTYPE_TIMEZONE:
case CFG_DTYPE_NONE: case CFG_DTYPE_NONE:
if (dump) { if (dump) {
printf("%s %s %s\n", src, name, pItem->str); (void)printf("%s %s %s\n", src, name, pItem->str);
} else { } else {
uInfo("%s %s %s", src, name, pItem->str); uInfo("%s %s %s", src, name, pItem->str);
} }
@ -878,7 +878,7 @@ void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump) {
} }
if (dump) { if (dump) {
printf("=================================================================\n"); (void)printf("=================================================================\n");
} else { } else {
uInfo("================================================================="); uInfo("=================================================================");
} }
@ -900,21 +900,21 @@ int32_t cfgLoadFromEnvVar(SConfig *pConfig) {
pEnv++; pEnv++;
(void)taosEnvToCfg(line, line); (void)taosEnvToCfg(line, line);
paGetToken(line, &name, &olen); (void)paGetToken(line, &name, &olen);
if (olen == 0) continue; if (olen == 0) continue;
name[olen] = 0; name[olen] = 0;
paGetToken(name + olen + 1, &value, &vlen); (void)paGetToken(name + olen + 1, &value, &vlen);
if (vlen == 0) continue; if (vlen == 0) continue;
value[vlen] = 0; value[vlen] = 0;
paGetToken(value + vlen + 1, &value2, &vlen2); (void)paGetToken(value + vlen + 1, &value2, &vlen2);
if (vlen2 != 0) { if (vlen2 != 0) {
value2[vlen2] = 0; value2[vlen2] = 0;
paGetToken(value2 + vlen2 + 1, &value3, &vlen3); (void)paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
if (vlen3 != 0) { if (vlen3 != 0) {
value3[vlen3] = 0; value3[vlen3] = 0;
paGetToken(value3 + vlen3 + 1, &value4, &vlen4); (void)paGetToken(value3 + vlen3 + 1, &value4, &vlen4);
if (vlen4 != 0) value4[vlen4] = 0; if (vlen4 != 0) value4[vlen4] = 0;
} }
} }
@ -947,21 +947,21 @@ int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd) {
name = value = value2 = value3 = value4 = NULL; name = value = value2 = value3 = value4 = NULL;
olen = vlen = vlen2 = vlen3 = vlen4 = 0; olen = vlen = vlen2 = vlen3 = vlen4 = 0;
paGetToken(buf, &name, &olen); (void)paGetToken(buf, &name, &olen);
if (olen == 0) continue; if (olen == 0) continue;
name[olen] = 0; name[olen] = 0;
paGetToken(name + olen + 1, &value, &vlen); (void)paGetToken(name + olen + 1, &value, &vlen);
if (vlen == 0) continue; if (vlen == 0) continue;
value[vlen] = 0; value[vlen] = 0;
paGetToken(value + vlen + 1, &value2, &vlen2); (void)paGetToken(value + vlen + 1, &value2, &vlen2);
if (vlen2 != 0) { if (vlen2 != 0) {
value2[vlen2] = 0; value2[vlen2] = 0;
paGetToken(value2 + vlen2 + 1, &value3, &vlen3); (void)paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
if (vlen3 != 0) { if (vlen3 != 0) {
value3[vlen3] = 0; value3[vlen3] = 0;
paGetToken(value3 + vlen3 + 1, &value4, &vlen4); (void)paGetToken(value3 + vlen3 + 1, &value4, &vlen4);
if (vlen4 != 0) value4[vlen4] = 0; if (vlen4 != 0) value4[vlen4] = 0;
} }
} }
@ -1015,21 +1015,21 @@ int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) {
if (line[_bytes - 1] == '\n') line[_bytes - 1] = 0; if (line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
(void)taosEnvToCfg(line, line); (void)taosEnvToCfg(line, line);
paGetToken(line, &name, &olen); (void)paGetToken(line, &name, &olen);
if (olen == 0) continue; if (olen == 0) continue;
name[olen] = 0; name[olen] = 0;
paGetToken(name + olen + 1, &value, &vlen); (void)paGetToken(name + olen + 1, &value, &vlen);
if (vlen == 0) continue; if (vlen == 0) continue;
value[vlen] = 0; value[vlen] = 0;
paGetToken(value + vlen + 1, &value2, &vlen2); (void)paGetToken(value + vlen + 1, &value2, &vlen2);
if (vlen2 != 0) { if (vlen2 != 0) {
value2[vlen2] = 0; value2[vlen2] = 0;
paGetToken(value2 + vlen2 + 1, &value3, &vlen3); (void)paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
if (vlen3 != 0) { if (vlen3 != 0) {
value3[vlen3] = 0; value3[vlen3] = 0;
paGetToken(value3 + vlen3 + 1, &value4, &vlen4); (void)paGetToken(value3 + vlen3 + 1, &value4, &vlen4);
if (vlen4 != 0) value4[vlen4] = 0; if (vlen4 != 0) value4[vlen4] = 0;
} }
} }
@ -1043,7 +1043,7 @@ int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) {
} }
} }
taosCloseFile(&pFile); (void)taosCloseFile(&pFile);
uInfo("load from env cfg file %s success", filepath); uInfo("load from env cfg file %s success", filepath);
TAOS_RETURN(TSDB_CODE_SUCCESS); TAOS_RETURN(TSDB_CODE_SUCCESS);
@ -1079,11 +1079,11 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
if (line[_bytes - 1] == '\n') line[_bytes - 1] = 0; if (line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
paGetToken(line, &name, &olen); (void)paGetToken(line, &name, &olen);
if (olen == 0) continue; if (olen == 0) continue;
name[olen] = 0; name[olen] = 0;
paGetToken(name + olen + 1, &value, &vlen); (void)paGetToken(name + olen + 1, &value, &vlen);
if (vlen == 0) continue; if (vlen == 0) continue;
value[vlen] = 0; value[vlen] = 0;
@ -1096,7 +1096,7 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
int32_t count = 1; int32_t count = 1;
while (vlen < 1024) { while (vlen < 1024) {
paGetToken(value + vlen + 1 * count, &tmp, &len); (void)paGetToken(value + vlen + 1 * count, &tmp, &len);
if (len == 0) break; if (len == 0) break;
tmp[len] = 0; tmp[len] = 0;
strcpy(newValue + vlen, tmp); strcpy(newValue + vlen, tmp);
@ -1107,13 +1107,13 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
code = cfgSetItem(pConfig, name, newValue, CFG_STYPE_CFG_FILE, true); code = cfgSetItem(pConfig, name, newValue, CFG_STYPE_CFG_FILE, true);
if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
} else { } else {
paGetToken(value + vlen + 1, &value2, &vlen2); (void)paGetToken(value + vlen + 1, &value2, &vlen2);
if (vlen2 != 0) { if (vlen2 != 0) {
value2[vlen2] = 0; value2[vlen2] = 0;
paGetToken(value2 + vlen2 + 1, &value3, &vlen3); (void)paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
if (vlen3 != 0) { if (vlen3 != 0) {
value3[vlen3] = 0; value3[vlen3] = 0;
paGetToken(value3 + vlen3 + 1, &value4, &vlen4); (void)paGetToken(value3 + vlen3 + 1, &value4, &vlen4);
if (vlen4 != 0) value4[vlen4] = 0; if (vlen4 != 0) value4[vlen4] = 0;
} }
} }
@ -1136,7 +1136,7 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
} }
} }
taosCloseFile(&pFile); (void)taosCloseFile(&pFile);
if (TSDB_CODE_SUCCESS == code || TSDB_CODE_CFG_NOT_FOUND == code) { if (TSDB_CODE_SUCCESS == code || TSDB_CODE_CFG_NOT_FOUND == code) {
uInfo("load from cfg file %s success", filepath); uInfo("load from cfg file %s success", filepath);
@ -1177,18 +1177,18 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
// if(line[_bytes - 1] == '\n') line[_bytes - 1] = 0; // if(line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
// paGetToken(line, &name, &olen); // (void)paGetToken(line, &name, &olen);
// if (olen == 0) continue; // if (olen == 0) continue;
// name[olen] = 0; // name[olen] = 0;
// paGetToken(name + olen + 1, &value, &vlen); // (void)paGetToken(name + olen + 1, &value, &vlen);
// if (vlen == 0) continue; // if (vlen == 0) continue;
// value[vlen] = 0; // value[vlen] = 0;
// paGetToken(value + vlen + 1, &value2, &vlen2); // (void)paGetToken(value + vlen + 1, &value2, &vlen2);
// if (vlen2 != 0) { // if (vlen2 != 0) {
// value2[vlen2] = 0; // value2[vlen2] = 0;
// paGetToken(value2 + vlen2 + 1, &value3, &vlen3); // (void)paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
// if (vlen3 != 0) value3[vlen3] = 0; // if (vlen3 != 0) value3[vlen3] = 0;
// } // }
@ -1200,7 +1200,7 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
// } // }
// } // }
// taosCloseFile(&pFile); // (void)taosCloseFile(&pFile);
// if (line != NULL) taosMemoryFreeClear(line); // if (line != NULL) taosMemoryFreeClear(line);
// if (code == 0 || (code != 0 && terrno == TSDB_CODE_CFG_NOT_FOUND)) { // if (code == 0 || (code != 0 && terrno == TSDB_CODE_CFG_NOT_FOUND)) {
@ -1243,20 +1243,20 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
size_t fileSize = taosLSeekFile(pFile, 0, SEEK_END); size_t fileSize = taosLSeekFile(pFile, 0, SEEK_END);
char *buf = taosMemoryMalloc(fileSize + 1); char *buf = taosMemoryMalloc(fileSize + 1);
if (!buf) { if (!buf) {
taosCloseFile(&pFile); (void)taosCloseFile(&pFile);
uError("load json file error: %s, failed to alloc memory", filepath); uError("load json file error: %s, failed to alloc memory", filepath);
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
buf[fileSize] = 0; buf[fileSize] = 0;
taosLSeekFile(pFile, 0, SEEK_SET); (void)taosLSeekFile(pFile, 0, SEEK_SET);
if (taosReadFile(pFile, buf, fileSize) <= 0) { if (taosReadFile(pFile, buf, fileSize) <= 0) {
taosCloseFile(&pFile); (void)taosCloseFile(&pFile);
uError("load json file error: %s", filepath); uError("load json file error: %s", filepath);
taosMemoryFreeClear(buf); taosMemoryFreeClear(buf);
TAOS_RETURN(TSDB_CODE_INVALID_DATA_FMT); TAOS_RETURN(TSDB_CODE_INVALID_DATA_FMT);
} }
taosCloseFile(&pFile); (void)taosCloseFile(&pFile);
pJson = tjsonParse(buf); pJson = tjsonParse(buf);
if (NULL == pJson) { if (NULL == pJson) {
const char *jsonParseError = tjsonGetError(); const char *jsonParseError = tjsonGetError();
@ -1284,25 +1284,24 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
goto _err_json; goto _err_json;
} }
memcpy(cfgLineBuf, itemName, itemNameLen); (void)memcpy(cfgLineBuf, itemName, itemNameLen);
cfgLineBuf[itemNameLen] = ' '; cfgLineBuf[itemNameLen] = ' ';
memcpy(&cfgLineBuf[itemNameLen + 1], itemValueString, itemValueStringLen); (void)memcpy(&cfgLineBuf[itemNameLen + 1], itemValueString, itemValueStringLen);
(void)paGetToken(cfgLineBuf, &name, &olen);
paGetToken(cfgLineBuf, &name, &olen);
if (olen == 0) continue; if (olen == 0) continue;
name[olen] = 0; name[olen] = 0;
paGetToken(name + olen + 1, &value, &vlen); (void)paGetToken(name + olen + 1, &value, &vlen);
if (vlen == 0) continue; if (vlen == 0) continue;
value[vlen] = 0; value[vlen] = 0;
paGetToken(value + vlen + 1, &value2, &vlen2); (void)paGetToken(value + vlen + 1, &value2, &vlen2);
if (vlen2 != 0) { if (vlen2 != 0) {
value2[vlen2] = 0; value2[vlen2] = 0;
paGetToken(value2 + vlen2 + 1, &value3, &vlen3); (void)paGetToken(value2 + vlen2 + 1, &value3, &vlen3);
if (vlen3 != 0) { if (vlen3 != 0) {
value3[vlen3] = 0; value3[vlen3] = 0;
paGetToken(value3 + vlen3 + 1, &value4, &vlen4); (void)paGetToken(value3 + vlen3 + 1, &value4, &vlen4);
if (vlen4 != 0) value4[vlen4] = 0; if (vlen4 != 0) value4[vlen4] = 0;
} }
} }
@ -1346,7 +1345,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
p++; p++;
p[strlen(p) - 1] = '\0'; p[strlen(p) - 1] = '\0';
} }
memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX)); (void)memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX));
uInfo("get apollo url from env cmd success"); uInfo("get apollo url from env cmd success");
TAOS_RETURN(TSDB_CODE_SUCCESS); TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
@ -1368,7 +1367,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
p++; p++;
p[strlen(p) - 1] = '\0'; p[strlen(p) - 1] = '\0';
} }
memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX)); (void)memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX));
uInfo("get apollo url from env variables success, apolloUrl=%s", apolloUrl); uInfo("get apollo url from env variables success, apolloUrl=%s", apolloUrl);
TAOS_RETURN(TSDB_CODE_SUCCESS); TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
@ -1405,14 +1404,14 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
p++; p++;
p[strlen(p) - 1] = '\0'; p[strlen(p) - 1] = '\0';
} }
memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX)); (void)memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX));
taosCloseFile(&pFile); (void)taosCloseFile(&pFile);
uInfo("get apollo url from env file success"); uInfo("get apollo url from env file success");
TAOS_RETURN(TSDB_CODE_SUCCESS); TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
} }
} }
taosCloseFile(&pFile); (void)taosCloseFile(&pFile);
} }
uInfo("fail get apollo url from cmd env file"); uInfo("fail get apollo url from cmd env file");
@ -1436,7 +1435,7 @@ int32_t cfgCreateIter(SConfig *pConf, SConfigIter **ppIter) {
TAOS_RETURN(TSDB_CODE_SUCCESS); TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
SConfigItem *cfgNextIter(SConfigIter* pIter) { SConfigItem *cfgNextIter(SConfigIter *pIter) {
if (pIter->index < cfgGetSize(pIter->pConf)) { if (pIter->index < cfgGetSize(pIter->pConf)) {
return taosArrayGet(pIter->pConf->array, pIter->index++); return taosArrayGet(pIter->pConf->array, pIter->index++);
} }