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

feat: (errcode) tconfig.c

This commit is contained in:
Shungang Li 2024-07-23 15:06:14 +08:00
parent cd2f039fd9
commit 4281289eef
6 changed files with 191 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/util/tconfig.h
View File

@ -101,7 +101,7 @@ typedef struct {
typedef struct SConfig SConfig; typedef struct SConfig SConfig;
typedef struct SConfigIter SConfigIter; typedef struct SConfigIter SConfigIter;
SConfig *cfgInit(); int32_t cfgInit(SConfig **ppCfg);
int32_t cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const void *sourceStr); int32_t cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const void *sourceStr);
int32_t cfgLoadFromArray(SConfig *pCfg, SArray *pArgs); // SConfigPair int32_t cfgLoadFromArray(SConfig *pCfg, SArray *pArgs); // SConfigPair
void cfgCleanup(SConfig *pCfg); void cfgCleanup(SConfig *pCfg);
@ -110,7 +110,7 @@ SConfigItem *cfgGetItem(SConfig *pCfg, const char *pName);
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);
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);
SConfigIter *cfgCreateIter(SConfig *pConf); int32_t cfgCreateIter(SConfig *pConf, SConfigIter **ppIter);
SConfigItem *cfgNextIter(SConfigIter *pIter); SConfigItem *cfgNextIter(SConfigIter *pIter);
void cfgDestroyIter(SConfigIter *pIter); void cfgDestroyIter(SConfigIter *pIter);
void cfgLock(SConfig *pCfg); void cfgLock(SConfig *pCfg);
@ -131,8 +131,8 @@ int32_t cfgAddTimezone(SConfig *pCfg, const char *name, const char *defaultVal,
const char *cfgStypeStr(ECfgSrcType type); const char *cfgStypeStr(ECfgSrcType type);
const char *cfgDtypeStr(ECfgDataType type); const char *cfgDtypeStr(ECfgDataType type);
void cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen); int32_t cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen);
void cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen); int32_t cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen);
void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump); void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump);
void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump); void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump);

4
include/util/tutil.h
View File

@ -152,9 +152,9 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
#define TCONTAINER_OF(ptr, type, member) ((type *)((char *)(ptr)-offsetof(type, member))) #define TCONTAINER_OF(ptr, type, member) ((type *)((char *)(ptr)-offsetof(type, member)))
#define TAOS_RETURN(code) \ #define TAOS_RETURN(CODE) \
do { \ do { \
return (terrno = (code)); \ return (terrno = (CODE)); \
} while (0) } while (0)
#define TAOS_CHECK_RETURN(CMD) \ #define TAOS_CHECK_RETURN(CMD) \

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

@ -1263,8 +1263,8 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi
const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc) { const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc) {
if (tsCfg == NULL) osDefaultInit(); if (tsCfg == NULL) osDefaultInit();
SConfig *pCfg = cfgInit(); SConfig *pCfg = NULL;
if (pCfg == NULL) return -1; TAOS_CHECK_RETURN(cfgInit(&pCfg));
if (tsc) { if (tsc) {
tsLogEmbedded = 0; tsLogEmbedded = 0;
@ -1325,8 +1325,8 @@ int32_t taosReadDataFolder(const char *cfgDir, const char **envCmd, const char *
SArray *pArgs) { SArray *pArgs) {
if (tsCfg == NULL) osDefaultInit(); if (tsCfg == NULL) osDefaultInit();
SConfig *pCfg = cfgInit(); SConfig *pCfg = NULL;
if (pCfg == NULL) return -1; TAOS_CHECK_RETURN(cfgInit(&pCfg));
if (cfgAddDir(pCfg, "dataDir", tsDataDir, CFG_SCOPE_SERVER, CFG_DYN_NONE) != 0) return -1; if (cfgAddDir(pCfg, "dataDir", tsDataDir, CFG_SCOPE_SERVER, CFG_DYN_NONE) != 0) return -1;
if (cfgAddInt32(pCfg, "dDebugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER) != 0) return -1; if (cfgAddInt32(pCfg, "dDebugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER) != 0) return -1;
@ -1371,10 +1371,7 @@ static int32_t taosCheckGlobalCfg() {
static int32_t cfgInitWrapper(SConfig **pCfg) { static int32_t cfgInitWrapper(SConfig **pCfg) {
if (*pCfg == NULL) { if (*pCfg == NULL) {
*pCfg = cfgInit(); TAOS_CHECK_RETURN(cfgInit(pCfg));
if (*pCfg == NULL) {
return terrno;
}
} }
return 0; return 0;
} }

10
source/common/src/tmisce.c
View File

@ -270,11 +270,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf)), NULL, _exit); TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf)), NULL, _exit);
pIter = cfgCreateIter(pConf); TAOS_CHECK_GOTO(cfgCreateIter(pConf, &pIter), NULL, _exit);
if (pIter == NULL) {
code = TSDB_CODE_OUT_OF_MEMORY;
TAOS_CHECK_GOTO(code, NULL, _exit);
}
cfgLock(pConf); cfgLock(pConf);
locked = 1; locked = 1;
@ -296,7 +292,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
char value[TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE] = {0}; char value[TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE] = {0};
int32_t valueLen = 0; int32_t valueLen = 0;
cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_VALUE_LEN, &valueLen); TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_VALUE_LEN, &valueLen), NULL, _exit);
varDataSetLen(value, valueLen); varDataSetLen(value, valueLen);
pColInfo = taosArrayGet(pBlock->pDataBlock, col++); pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
@ -308,7 +304,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, value, false), NULL, _exit); TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, value, false), NULL, _exit);
char scope[TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE] = {0}; char scope[TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE] = {0};
cfgDumpItemScope(pItem, &scope[VARSTR_HEADER_SIZE], TSDB_CONFIG_SCOPE_LEN, &valueLen); TAOS_CHECK_GOTO(cfgDumpItemScope(pItem, &scope[VARSTR_HEADER_SIZE], TSDB_CONFIG_SCOPE_LEN, &valueLen), NULL, _exit);
varDataSetLen(scope, valueLen); varDataSetLen(scope, valueLen);
pColInfo = taosArrayGet(pBlock->pDataBlock, col++); pColInfo = taosArrayGet(pBlock->pDataBlock, col++);

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

@ -42,22 +42,21 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url);
extern char **environ; extern char **environ;
SConfig *cfgInit() { int32_t cfgInit(SConfig ** ppCfg) {
SConfig *pCfg = taosMemoryCalloc(1, sizeof(SConfig)); SConfig *pCfg = taosMemoryCalloc(1, sizeof(SConfig));
if (pCfg == NULL) { if (pCfg == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return NULL;
} }
pCfg->array = taosArrayInit(32, sizeof(SConfigItem)); pCfg->array = taosArrayInit(32, sizeof(SConfigItem));
if (pCfg->array == NULL) { if (pCfg->array == NULL) {
taosMemoryFree(pCfg); taosMemoryFree(pCfg);
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return NULL;
} }
taosThreadMutexInit(&pCfg->lock, NULL); taosThreadMutexInit(&pCfg->lock, NULL);
return pCfg; *ppCfg = pCfg;
TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
int32_t cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const void *sourceStr) { int32_t cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const void *sourceStr) {
@ -73,7 +72,7 @@ int32_t cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const void *sourceStr) {
case CFG_STYPE_ENV_CMD: case CFG_STYPE_ENV_CMD:
return cfgLoadFromEnvCmd(pCfg, (const char **)sourceStr); return cfgLoadFromEnvCmd(pCfg, (const char **)sourceStr);
default: default:
return -1; return TSDB_CODE_INVALID_PARA;
} }
} }
@ -82,11 +81,11 @@ int32_t cfgLoadFromArray(SConfig *pCfg, SArray *pArgs) {
for (int32_t i = 0; i < size; ++i) { for (int32_t i = 0; i < size; ++i) {
SConfigPair *pPair = taosArrayGet(pArgs, i); SConfigPair *pPair = taosArrayGet(pArgs, i);
if (cfgSetItem(pCfg, pPair->name, pPair->value, CFG_STYPE_ARG_LIST, true) != 0) { if (cfgSetItem(pCfg, pPair->name, pPair->value, CFG_STYPE_ARG_LIST, true) != 0) {
return -1; return TSDB_CODE_INVALID_PARA;
} }
} }
return 0; return TSDB_CODE_SUCCESS;
} }
void cfgItemFreeVal(SConfigItem *pItem) { void cfgItemFreeVal(SConfigItem *pItem) {
@ -126,28 +125,27 @@ static int32_t cfgCheckAndSetConf(SConfigItem *pItem, const char *conf) {
pItem->str = taosStrdup(conf); pItem->str = taosStrdup(conf);
if (pItem->str == NULL) { if (pItem->str == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return -1;
} }
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t cfgCheckAndSetDir(SConfigItem *pItem, const char *inputDir) { static int32_t cfgCheckAndSetDir(SConfigItem *pItem, const char *inputDir) {
char fullDir[PATH_MAX] = {0}; char fullDir[PATH_MAX] = {0};
if (taosExpandDir(inputDir, fullDir, PATH_MAX) != 0) { if (taosExpandDir(inputDir, fullDir, PATH_MAX) != 0) {
uError("failed to expand dir:%s", inputDir); int32_t code = TAOS_SYSTEM_ERROR(errno);
return -1; uError("failed to expand dir:%s since %s", inputDir, tstrerror(code));
TAOS_RETURN(code);
} }
taosMemoryFreeClear(pItem->str); taosMemoryFreeClear(pItem->str);
pItem->str = taosStrdup(fullDir); pItem->str = taosStrdup(fullDir);
if (pItem->str == NULL) { if (pItem->str == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return -1;
} }
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t cfgSetBool(SConfigItem *pItem, const char *value, ECfgSrcType stype) { static int32_t cfgSetBool(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
@ -166,97 +164,88 @@ static int32_t cfgSetBool(SConfigItem *pItem, const char *value, ECfgSrcType sty
static int32_t cfgSetInt32(SConfigItem *pItem, const char *value, ECfgSrcType stype) { static int32_t cfgSetInt32(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
int32_t ival; int32_t ival;
int32_t code = taosStrHumanToInt32(value, &ival); TAOS_CHECK_RETURN(taosStrHumanToInt32(value, &ival));
if (code != TSDB_CODE_SUCCESS) return code;
if (ival < pItem->imin || ival > pItem->imax) { if (ival < pItem->imin || ival > pItem->imax) {
uError("cfg:%s, type:%s src:%s value:%d out of range[%" PRId64 ", %" PRId64 "]", pItem->name, uError("cfg:%s, type:%s src:%s value:%d out of range[%" PRId64 ", %" PRId64 "]", pItem->name,
cfgDtypeStr(pItem->dtype), cfgStypeStr(stype), ival, pItem->imin, pItem->imax); cfgDtypeStr(pItem->dtype), cfgStypeStr(stype), ival, pItem->imin, pItem->imax);
terrno = TSDB_CODE_OUT_OF_RANGE; TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
return -1;
} }
pItem->i32 = ival; pItem->i32 = ival;
pItem->stype = stype; pItem->stype = stype;
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t cfgSetInt64(SConfigItem *pItem, const char *value, ECfgSrcType stype) { static int32_t cfgSetInt64(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
int64_t ival; int64_t ival;
int32_t code = taosStrHumanToInt64(value, &ival); TAOS_CHECK_RETURN(taosStrHumanToInt64(value, &ival));
if (code != TSDB_CODE_SUCCESS) return code;
if (ival < pItem->imin || ival > pItem->imax) { if (ival < pItem->imin || ival > pItem->imax) {
uError("cfg:%s, type:%s src:%s value:%" PRId64 " out of range[%" PRId64 ", %" PRId64 "]", pItem->name, uError("cfg:%s, type:%s src:%s value:%" PRId64 " out of range[%" PRId64 ", %" PRId64 "]", pItem->name,
cfgDtypeStr(pItem->dtype), cfgStypeStr(stype), ival, pItem->imin, pItem->imax); cfgDtypeStr(pItem->dtype), cfgStypeStr(stype), ival, pItem->imin, pItem->imax);
terrno = TSDB_CODE_OUT_OF_RANGE; TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
return -1;
} }
pItem->i64 = ival; pItem->i64 = ival;
pItem->stype = stype; pItem->stype = stype;
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t cfgSetFloat(SConfigItem *pItem, const char *value, ECfgSrcType stype) { static int32_t cfgSetFloat(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
double dval; double dval;
int32_t code = parseCfgReal(value, &dval); TAOS_CHECK_RETURN(parseCfgReal(value, &dval));
if (dval < pItem->fmin || dval > pItem->fmax) { if (dval < pItem->fmin || dval > pItem->fmax) {
uError("cfg:%s, type:%s src:%s value:%f out of range[%f, %f]", pItem->name, cfgDtypeStr(pItem->dtype), uError("cfg:%s, type:%s src:%s value:%f out of range[%f, %f]", pItem->name, cfgDtypeStr(pItem->dtype),
cfgStypeStr(stype), dval, pItem->fmin, pItem->fmax); cfgStypeStr(stype), dval, pItem->fmin, pItem->fmax);
terrno = TSDB_CODE_OUT_OF_RANGE; TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
return -1;
} }
pItem->fval = (float)dval; pItem->fval = (float)dval;
pItem->stype = stype; pItem->stype = stype;
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t cfgSetString(SConfigItem *pItem, const char *value, ECfgSrcType stype) { static int32_t cfgSetString(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
char *tmp = taosStrdup(value); char *tmp = taosStrdup(value);
if (tmp == NULL) { if (tmp == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
uError("cfg:%s, type:%s src:%s value:%s failed to dup since %s", pItem->name, cfgDtypeStr(pItem->dtype), uError("cfg:%s, type:%s src:%s value:%s failed to dup since %s", pItem->name, cfgDtypeStr(pItem->dtype),
cfgStypeStr(stype), value, terrstr()); cfgStypeStr(stype), value, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
return -1; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
taosMemoryFreeClear(pItem->str); taosMemoryFreeClear(pItem->str);
pItem->str = tmp; pItem->str = tmp;
pItem->stype = stype; pItem->stype = stype;
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t cfgSetDir(SConfigItem *pItem, const char *value, ECfgSrcType stype) { static int32_t cfgSetDir(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
if (cfgCheckAndSetDir(pItem, value) != 0) { int32_t code = cfgCheckAndSetDir(pItem, value);
if (TSDB_CODE_SUCCESS != code) {
uError("cfg:%s, type:%s src:%s value:%s failed to dup since %s", pItem->name, cfgDtypeStr(pItem->dtype), uError("cfg:%s, type:%s src:%s value:%s failed to dup since %s", pItem->name, cfgDtypeStr(pItem->dtype),
cfgStypeStr(stype), value, terrstr()); cfgStypeStr(stype), value, tstrerror(code));
return -1; TAOS_RETURN(code);
} }
pItem->stype = stype; pItem->stype = stype;
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t doSetConf(SConfigItem *pItem, const char *value, ECfgSrcType stype) { static int32_t doSetConf(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
if (cfgCheckAndSetConf(pItem, value) != 0) { int32_t code = cfgCheckAndSetConf(pItem, value);
terrno = TSDB_CODE_OUT_OF_MEMORY; if (TSDB_CODE_SUCCESS != code) {
uError("cfg:%s, type:%s src:%s value:%s failed to dup since %s", pItem->name, cfgDtypeStr(pItem->dtype), uError("cfg:%s, type:%s src:%s value:%s failed to dup since %s", pItem->name, cfgDtypeStr(pItem->dtype),
cfgStypeStr(stype), value, terrstr()); cfgStypeStr(stype), value, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
return -1; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
pItem->stype = stype; pItem->stype = stype;
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t cfgSetTimezone(SConfigItem *pItem, const char *value, ECfgSrcType stype) { static int32_t cfgSetTimezone(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
int32_t code = doSetConf(pItem, value, stype); TAOS_CHECK_RETURN(doSetConf(pItem, value, stype));
if (code != TSDB_CODE_SUCCESS) {
return code;
}
osSetTimezone(value); osSetTimezone(value);
return code; 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,
@ -267,16 +256,15 @@ static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value,
if (pItem == NULL) { if (pItem == NULL) {
taosThreadMutexUnlock(&pCfg->lock); taosThreadMutexUnlock(&pCfg->lock);
return -1; TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
} }
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) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
taosThreadMutexUnlock(&pCfg->lock); taosThreadMutexUnlock(&pCfg->lock);
return -1; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
} }
@ -287,34 +275,32 @@ 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) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
taosThreadMutexUnlock(&pCfg->lock); taosThreadMutexUnlock(&pCfg->lock);
return -1; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
} }
pItem->stype = stype; pItem->stype = stype;
taosThreadMutexUnlock(&pCfg->lock); taosThreadMutexUnlock(&pCfg->lock);
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t cfgUpdateDebugFlagItem(SConfig *pCfg, const char *name, bool resetArray) { static int32_t cfgUpdateDebugFlagItem(SConfig *pCfg, const char *name, bool resetArray) {
SConfigItem *pDebugFlagItem = cfgGetItem(pCfg, "debugFlag"); SConfigItem *pDebugFlagItem = cfgGetItem(pCfg, "debugFlag");
if (resetArray) { if (resetArray) {
// reset // reset
if (pDebugFlagItem == NULL) return -1; if (pDebugFlagItem == NULL) TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
// logflag names that should 'not' be set by 'debugFlag' // logflag names that should 'not' be set by 'debugFlag'
if (pDebugFlagItem->array == NULL) { if (pDebugFlagItem->array == NULL) {
pDebugFlagItem->array = taosArrayInit(16, sizeof(SLogVar)); pDebugFlagItem->array = taosArrayInit(16, sizeof(SLogVar));
if (pDebugFlagItem->array == NULL) { if (pDebugFlagItem->array == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return -1;
} }
} }
taosArrayClear(pDebugFlagItem->array); taosArrayClear(pDebugFlagItem->array);
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
// update // update
@ -322,9 +308,11 @@ static int32_t cfgUpdateDebugFlagItem(SConfig *pCfg, const char *name, bool rese
if (pDebugFlagItem->array != NULL) { if (pDebugFlagItem->array != NULL) {
SLogVar logVar = {0}; SLogVar logVar = {0};
strncpy(logVar.name, name, TSDB_LOG_VAR_LEN - 1); strncpy(logVar.name, name, TSDB_LOG_VAR_LEN - 1);
taosArrayPush(pDebugFlagItem->array, &logVar); if (NULL == taosArrayPush(pDebugFlagItem->array, &logVar)) {
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
} }
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
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) {
@ -337,9 +325,8 @@ int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcTy
SConfigItem *pItem = cfgGetItem(pCfg, name); SConfigItem *pItem = cfgGetItem(pCfg, name);
if (pItem == NULL) { if (pItem == NULL) {
terrno = TSDB_CODE_CFG_NOT_FOUND;
taosThreadMutexUnlock(&pCfg->lock); taosThreadMutexUnlock(&pCfg->lock);
return -1; TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
} }
switch (pItem->dtype) { switch (pItem->dtype) {
@ -382,7 +369,7 @@ int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcTy
} }
case CFG_DTYPE_NONE: case CFG_DTYPE_NONE:
default: default:
terrno = TSDB_CODE_INVALID_CFG; code = TSDB_CODE_INVALID_CFG;
break; break;
} }
@ -390,7 +377,7 @@ int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcTy
taosThreadMutexUnlock(&pCfg->lock); taosThreadMutexUnlock(&pCfg->lock);
} }
return code; TAOS_RETURN(code);
} }
SConfigItem *cfgGetItem(SConfig *pCfg, const char *pName) { SConfigItem *cfgGetItem(SConfig *pCfg, const char *pName) {
@ -403,7 +390,6 @@ SConfigItem *cfgGetItem(SConfig *pCfg, const char *pName) {
} }
} }
terrno = TSDB_CODE_CFG_NOT_FOUND;
return NULL; return NULL;
} }
@ -420,27 +406,25 @@ void cfgUnLock(SConfig *pCfg) {
} }
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;
cfgLock(pCfg); cfgLock(pCfg);
SConfigItem *pItem = cfgGetItem(pCfg, name); SConfigItem *pItem = cfgGetItem(pCfg, name);
if (!pItem || (pItem->dynScope & dynType) == 0) { if (!pItem || (pItem->dynScope & dynType) == 0) {
uError("failed to config:%s, not support update this config", name); uError("failed to config:%s, not support update this config", name);
terrno = TSDB_CODE_INVALID_CFG;
cfgUnLock(pCfg); cfgUnLock(pCfg);
return -1; TAOS_RETURN(TSDB_CODE_INVALID_CFG);
} }
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){ if (taosSetSlowLogScope(tmp) < 0) {
terrno = TSDB_CODE_INVALID_CFG;
cfgUnLock(pCfg); cfgUnLock(pCfg);
taosMemoryFree(tmp); taosMemoryFree(tmp);
return -1; TAOS_RETURN(TSDB_CODE_INVALID_CFG);
} }
taosMemoryFree(tmp); taosMemoryFree(tmp);
} }
@ -449,9 +433,8 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p
int32_t ival = (int32_t)atoi(pVal); int32_t ival = (int32_t)atoi(pVal);
if (ival != 0 && ival != 1) { if (ival != 0 && ival != 1) {
uError("cfg:%s, type:%s value:%d out of range[0, 1]", pItem->name, cfgDtypeStr(pItem->dtype), ival); uError("cfg:%s, type:%s value:%d out of range[0, 1]", pItem->name, cfgDtypeStr(pItem->dtype), ival);
terrno = TSDB_CODE_OUT_OF_RANGE;
cfgUnLock(pCfg); cfgUnLock(pCfg);
return -1; TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
} }
} break; } break;
case CFG_DTYPE_INT32: { case CFG_DTYPE_INT32: {
@ -464,9 +447,8 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p
if (ival < pItem->imin || ival > pItem->imax) { if (ival < pItem->imin || ival > pItem->imax) {
uError("cfg:%s, type:%s value:%d out of range[%" PRId64 ", %" PRId64 "]", pItem->name, uError("cfg:%s, type:%s value:%d out of range[%" PRId64 ", %" PRId64 "]", pItem->name,
cfgDtypeStr(pItem->dtype), ival, pItem->imin, pItem->imax); cfgDtypeStr(pItem->dtype), ival, pItem->imin, pItem->imax);
terrno = TSDB_CODE_OUT_OF_RANGE;
cfgUnLock(pCfg); cfgUnLock(pCfg);
return -1; TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
} }
} break; } break;
case CFG_DTYPE_INT64: { case CFG_DTYPE_INT64: {
@ -474,30 +456,28 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p
int32_t code = taosStrHumanToInt64(pVal, &ival); int32_t code = taosStrHumanToInt64(pVal, &ival);
if (code != TSDB_CODE_SUCCESS) { if (code != TSDB_CODE_SUCCESS) {
cfgUnLock(pCfg); cfgUnLock(pCfg);
return code; TAOS_RETURN(code);
} }
if (ival < pItem->imin || ival > pItem->imax) { if (ival < pItem->imin || ival > pItem->imax) {
uError("cfg:%s, type:%s value:%" PRId64 " out of range[%" PRId64 ", %" PRId64 "]", pItem->name, uError("cfg:%s, type:%s value:%" PRId64 " out of range[%" PRId64 ", %" PRId64 "]", pItem->name,
cfgDtypeStr(pItem->dtype), ival, pItem->imin, pItem->imax); cfgDtypeStr(pItem->dtype), ival, pItem->imin, pItem->imax);
terrno = TSDB_CODE_OUT_OF_RANGE;
cfgUnLock(pCfg); cfgUnLock(pCfg);
return -1; TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
} }
} break; } break;
case CFG_DTYPE_FLOAT: case CFG_DTYPE_FLOAT:
case CFG_DTYPE_DOUBLE: { case CFG_DTYPE_DOUBLE: {
double dval; double dval;
int32_t code = parseCfgReal(pVal, &dval); int32_t code = parseCfgReal(pVal, &dval);
if (code != TSDB_CODE_SUCCESS) { if (code != TSDB_CODE_SUCCESS) {
cfgUnLock(pCfg); cfgUnLock(pCfg);
return code; TAOS_RETURN(code);
} }
if (dval < pItem->fmin || dval > pItem->fmax) { if (dval < pItem->fmin || dval > pItem->fmax) {
uError("cfg:%s, type:%s value:%f out of range[%f, %f]", pItem->name, cfgDtypeStr(pItem->dtype), dval, uError("cfg:%s, type:%s value:%f out of range[%f, %f]", pItem->name, cfgDtypeStr(pItem->dtype), dval,
pItem->fmin, pItem->fmax); pItem->fmin, pItem->fmax);
terrno = TSDB_CODE_OUT_OF_RANGE;
cfgUnLock(pCfg); cfgUnLock(pCfg);
return -1; TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
} }
} break; } break;
default: default:
@ -505,15 +485,14 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p
} }
cfgUnLock(pCfg); cfgUnLock(pCfg);
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
static int32_t cfgAddItem(SConfig *pCfg, SConfigItem *pItem, const char *name) { static int32_t cfgAddItem(SConfig *pCfg, SConfigItem *pItem, const char *name) {
pItem->stype = CFG_STYPE_DEFAULT; pItem->stype = CFG_STYPE_DEFAULT;
pItem->name = taosStrdup(name); pItem->name = taosStrdup(name);
if (pItem->name == NULL) { if (pItem->name == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return -1;
} }
int32_t size = taosArrayGetSize(pCfg->array); int32_t size = taosArrayGetSize(pCfg->array);
@ -521,7 +500,7 @@ static int32_t cfgAddItem(SConfig *pCfg, SConfigItem *pItem, const char *name) {
SConfigItem *existItem = taosArrayGet(pCfg->array, i); SConfigItem *existItem = taosArrayGet(pCfg->array, i);
if (existItem != NULL && strcmp(existItem->name, pItem->name) == 0) { if (existItem != NULL && strcmp(existItem->name, pItem->name) == 0) {
taosMemoryFree(pItem->name); taosMemoryFree(pItem->name);
return TSDB_CODE_INVALID_CFG; TAOS_RETURN(TSDB_CODE_INVALID_CFG);
} }
} }
@ -535,11 +514,10 @@ static int32_t cfgAddItem(SConfig *pCfg, SConfigItem *pItem, const char *name) {
} }
taosMemoryFree(pItem->name); taosMemoryFree(pItem->name);
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return -1;
} }
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
int32_t cfgAddBool(SConfig *pCfg, const char *name, bool defaultVal, int8_t scope, int8_t dynScope) { int32_t cfgAddBool(SConfig *pCfg, const char *name, bool defaultVal, int8_t scope, int8_t dynScope) {
@ -550,8 +528,7 @@ int32_t cfgAddBool(SConfig *pCfg, const char *name, bool defaultVal, int8_t scop
int32_t cfgAddInt32(SConfig *pCfg, const char *name, int32_t defaultVal, int64_t minval, int64_t maxval, int8_t scope, int32_t cfgAddInt32(SConfig *pCfg, const char *name, int32_t defaultVal, int64_t minval, int64_t maxval, int8_t scope,
int8_t dynScope) { int8_t dynScope) {
if (defaultVal < minval || defaultVal > maxval) { if (defaultVal < minval || defaultVal > maxval) {
terrno = TSDB_CODE_OUT_OF_RANGE; TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
return -1;
} }
SConfigItem item = {.dtype = CFG_DTYPE_INT32, SConfigItem item = {.dtype = CFG_DTYPE_INT32,
@ -566,8 +543,7 @@ int32_t cfgAddInt32(SConfig *pCfg, const char *name, int32_t defaultVal, int64_t
int32_t cfgAddInt64(SConfig *pCfg, const char *name, int64_t defaultVal, int64_t minval, int64_t maxval, int8_t scope, int32_t cfgAddInt64(SConfig *pCfg, const char *name, int64_t defaultVal, int64_t minval, int64_t maxval, int8_t scope,
int8_t dynScope) { int8_t dynScope) {
if (defaultVal < minval || defaultVal > maxval) { if (defaultVal < minval || defaultVal > maxval) {
terrno = TSDB_CODE_OUT_OF_RANGE; TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
return -1;
} }
SConfigItem item = {.dtype = CFG_DTYPE_INT64, SConfigItem item = {.dtype = CFG_DTYPE_INT64,
@ -582,8 +558,7 @@ int32_t cfgAddInt64(SConfig *pCfg, const char *name, int64_t defaultVal, int64_t
int32_t cfgAddFloat(SConfig *pCfg, const char *name, float defaultVal, float minval, float maxval, int8_t scope, int32_t cfgAddFloat(SConfig *pCfg, const char *name, float defaultVal, float minval, float maxval, int8_t scope,
int8_t dynScope) { int8_t dynScope) {
if (defaultVal < minval || defaultVal > maxval) { if (defaultVal < minval || defaultVal > maxval) {
terrno = TSDB_CODE_OUT_OF_RANGE; TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
return -1;
} }
SConfigItem item = {.dtype = CFG_DTYPE_FLOAT, SConfigItem item = {.dtype = CFG_DTYPE_FLOAT,
@ -599,45 +574,32 @@ int32_t cfgAddString(SConfig *pCfg, const char *name, const char *defaultVal, in
SConfigItem item = {.dtype = CFG_DTYPE_STRING, .scope = scope, .dynScope = dynScope}; SConfigItem item = {.dtype = CFG_DTYPE_STRING, .scope = scope, .dynScope = dynScope};
item.str = taosStrdup(defaultVal); item.str = taosStrdup(defaultVal);
if (item.str == NULL) { if (item.str == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return -1;
} }
return cfgAddItem(pCfg, &item, name); return cfgAddItem(pCfg, &item, name);
} }
int32_t cfgAddDir(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) { int32_t cfgAddDir(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) {
SConfigItem item = {.dtype = CFG_DTYPE_DIR, .scope = scope, .dynScope = dynScope}; SConfigItem item = {.dtype = CFG_DTYPE_DIR, .scope = scope, .dynScope = dynScope};
if (cfgCheckAndSetDir(&item, defaultVal) != 0) { TAOS_CHECK_RETURN(cfgCheckAndSetDir(&item, defaultVal));
return -1;
}
return cfgAddItem(pCfg, &item, name); return cfgAddItem(pCfg, &item, name);
} }
int32_t cfgAddLocale(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) { int32_t cfgAddLocale(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) {
SConfigItem item = {.dtype = CFG_DTYPE_LOCALE, .scope = scope, .dynScope = dynScope}; SConfigItem item = {.dtype = CFG_DTYPE_LOCALE, .scope = scope, .dynScope = dynScope};
if (cfgCheckAndSetConf(&item, defaultVal) != 0) { TAOS_CHECK_RETURN(cfgCheckAndSetConf(&item, defaultVal));
return -1;
}
return cfgAddItem(pCfg, &item, name); return cfgAddItem(pCfg, &item, name);
} }
int32_t cfgAddCharset(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) { int32_t cfgAddCharset(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) {
SConfigItem item = {.dtype = CFG_DTYPE_CHARSET, .scope = scope, .dynScope = dynScope}; SConfigItem item = {.dtype = CFG_DTYPE_CHARSET, .scope = scope, .dynScope = dynScope};
if (cfgCheckAndSetConf(&item, defaultVal) != 0) { TAOS_CHECK_RETURN(cfgCheckAndSetConf(&item, defaultVal));
return -1;
}
return cfgAddItem(pCfg, &item, name); return cfgAddItem(pCfg, &item, name);
} }
int32_t cfgAddTimezone(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) { int32_t cfgAddTimezone(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) {
SConfigItem item = {.dtype = CFG_DTYPE_TIMEZONE, .scope = scope, .dynScope = dynScope}; SConfigItem item = {.dtype = CFG_DTYPE_TIMEZONE, .scope = scope, .dynScope = dynScope};
if (cfgCheckAndSetConf(&item, defaultVal) != 0) { TAOS_CHECK_RETURN(cfgCheckAndSetConf(&item, defaultVal));
return -1;
}
return cfgAddItem(pCfg, &item, name); return cfgAddItem(pCfg, &item, name);
} }
@ -693,7 +655,7 @@ const char *cfgDtypeStr(ECfgDataType type) {
} }
} }
void cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen) { int32_t cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen) {
int32_t len = 0; int32_t len = 0;
switch (pItem->dtype) { switch (pItem->dtype) {
case CFG_DTYPE_BOOL: case CFG_DTYPE_BOOL:
@ -719,14 +681,19 @@ void cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *p
break; break;
} }
if (len < 0) {
TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
if (len > bufSize) { if (len > bufSize) {
len = bufSize; len = bufSize;
} }
*pLen = len; *pLen = len;
TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
void cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen) { int32_t cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen) {
int32_t len = 0; int32_t len = 0;
switch (pItem->scope) { switch (pItem->scope) {
case CFG_SCOPE_SERVER: case CFG_SCOPE_SERVER:
@ -740,11 +707,16 @@ void cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *p
break; break;
} }
if (len < 0) {
TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
if (len > bufSize) { if (len > bufSize) {
len = bufSize; len = bufSize;
} }
*pLen = len; *pLen = len;
TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump) { void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump) {
@ -919,14 +891,14 @@ int32_t cfgLoadFromEnvVar(SConfig *pConfig) {
char **pEnv = environ; char **pEnv = environ;
line[1023] = 0; line[1023] = 0;
if (pEnv == NULL) return 0; if (pEnv == NULL) TAOS_RETURN(TSDB_CODE_SUCCESS);
while (*pEnv != NULL) { while (*pEnv != NULL) {
name = value = value2 = value3 = value4 = NULL; name = value = value2 = value3 = value4 = NULL;
olen = vlen = vlen2 = vlen3 = vlen4 = 0; olen = vlen = vlen2 = vlen3 = vlen4 = 0;
strncpy(line, *pEnv, sizeof(line) - 1); strncpy(line, *pEnv, sizeof(line) - 1);
pEnv++; pEnv++;
taosEnvToCfg(line, line); (void)taosEnvToCfg(line, line);
paGetToken(line, &name, &olen); paGetToken(line, &name, &olen);
if (olen == 0) continue; if (olen == 0) continue;
@ -943,21 +915,21 @@ int32_t cfgLoadFromEnvVar(SConfig *pConfig) {
if (vlen3 != 0) { if (vlen3 != 0) {
value3[vlen3] = 0; value3[vlen3] = 0;
paGetToken(value3 + vlen3 + 1, &value4, &vlen4); paGetToken(value3 + vlen3 + 1, &value4, &vlen4);
if(vlen4 != 0) value4[vlen4] = 0; if (vlen4 != 0) value4[vlen4] = 0;
} }
} }
code = cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_VAR, true); code = cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_VAR, true);
if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
if (strcasecmp(name, "dataDir") == 0) { if (strcasecmp(name, "dataDir") == 0) {
code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_ENV_VAR); code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_ENV_VAR);
if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
} }
} }
uInfo("load from env variables cfg success"); uInfo("load from env variables cfg success");
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd) { int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd) {
@ -965,11 +937,11 @@ int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd) {
int32_t olen, vlen, vlen2, vlen3, vlen4; int32_t olen, vlen, vlen2, vlen3, vlen4;
int32_t code = 0; int32_t code = 0;
int32_t index = 0; int32_t index = 0;
if (envCmd == NULL) return 0; if (envCmd == NULL) TAOS_RETURN(TSDB_CODE_SUCCESS);
while (envCmd[index] != NULL) { while (envCmd[index] != NULL) {
strncpy(buf, envCmd[index], sizeof(buf) - 1); strncpy(buf, envCmd[index], sizeof(buf) - 1);
buf[sizeof(buf) - 1] = 0; buf[sizeof(buf) - 1] = 0;
taosEnvToCfg(buf, buf); (void)taosEnvToCfg(buf, buf);
index++; index++;
name = value = value2 = value3 = value4 = NULL; name = value = value2 = value3 = value4 = NULL;
@ -990,21 +962,21 @@ int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd) {
if (vlen3 != 0) { if (vlen3 != 0) {
value3[vlen3] = 0; value3[vlen3] = 0;
paGetToken(value3 + vlen3 + 1, &value4, &vlen4); paGetToken(value3 + vlen3 + 1, &value4, &vlen4);
if(vlen4 != 0) value4[vlen4] = 0; if (vlen4 != 0) value4[vlen4] = 0;
} }
} }
code = cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_CMD, true); code = cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_CMD, true);
if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
if (strcasecmp(name, "dataDir") == 0) { if (strcasecmp(name, "dataDir") == 0) {
code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_ENV_CMD); code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_ENV_CMD);
if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
} }
} }
uInfo("load from env cmd cfg success"); uInfo("load from env cmd cfg success");
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) { int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) {
@ -1017,20 +989,19 @@ int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) {
if (envFile != NULL && strlen(envFile) > 0) { if (envFile != NULL && strlen(envFile) > 0) {
if (!taosCheckExistFile(envFile)) { if (!taosCheckExistFile(envFile)) {
uError("failed to load env file:%s", envFile); uError("failed to load env file:%s", envFile);
return -1; TAOS_RETURN(TSDB_CODE_NOT_FOUND);
} }
filepath = envFile; filepath = envFile;
} else { } else {
if (!taosCheckExistFile(filepath)) { if (!taosCheckExistFile(filepath)) {
uInfo("env file:%s not load", filepath); uInfo("env file:%s not load", filepath);
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
} }
TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ | TD_FILE_STREAM); TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ | TD_FILE_STREAM);
if (pFile == NULL) { if (pFile == NULL) {
terrno = TAOS_SYSTEM_ERROR(errno); TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
return -1;
} }
while (!taosEOFFile(pFile)) { while (!taosEOFFile(pFile)) {
@ -1042,7 +1013,7 @@ int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) {
break; break;
} }
if (line[_bytes - 1] == '\n') line[_bytes - 1] = 0; if (line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
taosEnvToCfg(line, line); (void)taosEnvToCfg(line, line);
paGetToken(line, &name, &olen); paGetToken(line, &name, &olen);
if (olen == 0) continue; if (olen == 0) continue;
@ -1059,23 +1030,23 @@ int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) {
if (vlen3 != 0) { if (vlen3 != 0) {
value3[vlen3] = 0; value3[vlen3] = 0;
paGetToken(value3 + vlen3 + 1, &value4, &vlen4); paGetToken(value3 + vlen3 + 1, &value4, &vlen4);
if(vlen4 != 0) value4[vlen4] = 0; if (vlen4 != 0) value4[vlen4] = 0;
} }
} }
code = cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_FILE, true); code = cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_FILE, true);
if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
if (strcasecmp(name, "dataDir") == 0) { if (strcasecmp(name, "dataDir") == 0) {
code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_ENV_FILE); code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_ENV_FILE);
if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
} }
} }
taosCloseFile(&pFile); taosCloseFile(&pFile);
uInfo("load from env cfg file %s success", filepath); uInfo("load from env cfg file %s success", filepath);
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) { int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
@ -1087,13 +1058,13 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ | TD_FILE_STREAM); TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ | TD_FILE_STREAM);
if (pFile == NULL) { if (pFile == NULL) {
// success when the file does not exist // success when the file does not exist
code = TAOS_SYSTEM_ERROR(errno);
if (errno == ENOENT) { if (errno == ENOENT) {
terrno = TAOS_SYSTEM_ERROR(errno); uInfo("failed to load from cfg file %s since %s, use default parameters", filepath, tstrerror(code));
uInfo("failed to load from cfg file %s since %s, use default parameters", filepath, terrstr()); TAOS_RETURN(TSDB_CODE_SUCCESS);
return 0;
} else { } else {
uError("failed to load from cfg file %s since %s", filepath, terrstr()); uError("failed to load from cfg file %s since %s", filepath, tstrerror(code));
return -1; TAOS_RETURN(code);
} }
} }
@ -1134,7 +1105,7 @@ 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 (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
} else { } else {
paGetToken(value + vlen + 1, &value2, &vlen2); paGetToken(value + vlen + 1, &value2, &vlen2);
if (vlen2 != 0) { if (vlen2 != 0) {
@ -1148,12 +1119,12 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
} }
code = cfgSetItem(pConfig, name, value, CFG_STYPE_CFG_FILE, true); code = cfgSetItem(pConfig, name, value, CFG_STYPE_CFG_FILE, true);
if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
} }
if (strcasecmp(name, "dataDir") == 0) { if (strcasecmp(name, "dataDir") == 0) {
code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_CFG_FILE); code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_CFG_FILE);
if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
} }
size_t len = strlen(name); size_t len = strlen(name);
@ -1161,18 +1132,18 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
const size_t debugFlagLen = strlen(debugFlagStr); const size_t debugFlagLen = strlen(debugFlagStr);
if (len >= debugFlagLen && strcasecmp(name + len - debugFlagLen, debugFlagStr) == 0) { if (len >= debugFlagLen && strcasecmp(name + len - debugFlagLen, debugFlagStr) == 0) {
code = cfgUpdateDebugFlagItem(pConfig, name, len == debugFlagLen); code = cfgUpdateDebugFlagItem(pConfig, name, len == debugFlagLen);
if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
} }
} }
taosCloseFile(&pFile); taosCloseFile(&pFile);
if (code == 0 || (code != 0 && terrno == TSDB_CODE_CFG_NOT_FOUND)) { 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);
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} else { } else {
uError("failed to load from cfg file %s since %s", filepath, terrstr()); uError("failed to load from cfg file %s since %s", filepath, tstrerror(code));
return -1; TAOS_RETURN(code);
} }
} }
@ -1247,46 +1218,52 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
int32_t code = 0; int32_t code = 0;
if (url == NULL || strlen(url) == 0) { if (url == NULL || strlen(url) == 0) {
uInfo("apoll url not load"); uInfo("apoll url not load");
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
char *p = strchr(url, ':'); char *p = strchr(url, ':');
if (p == NULL) { if (p == NULL) {
uError("fail to load apoll url: %s, unknown format", url); uError("fail to load apoll url: %s, unknown format", url);
return -1; TAOS_RETURN(TSDB_CODE_INVALID_PARA);
} }
p++; p++;
SJson *pJson = NULL;
if (strncmp(url, "jsonFile", 8) == 0) { if (strncmp(url, "jsonFile", 8) == 0) {
char *filepath = p; char *filepath = p;
if (!taosCheckExistFile(filepath)) { if (!taosCheckExistFile(filepath)) {
uError("failed to load json file:%s", filepath); uError("failed to load json file:%s", filepath);
return -1; TAOS_RETURN(TSDB_CODE_NOT_FOUND);
} }
TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ); TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ);
if (pFile == NULL) { if (pFile == NULL) {
terrno = TAOS_SYSTEM_ERROR(errno); TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
return -1;
} }
size_t fileSize = taosLSeekFile(pFile, 0, SEEK_END); size_t fileSize = taosLSeekFile(pFile, 0, SEEK_END);
char *buf = taosMemoryMalloc(fileSize); char *buf = taosMemoryMalloc(fileSize);
if (!buf) {
taosCloseFile(&pFile);
uError("load json file error: %s, failed to alloc memory", filepath);
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
taosLSeekFile(pFile, 0, SEEK_SET); taosLSeekFile(pFile, 0, SEEK_SET);
if (taosReadFile(pFile, buf, fileSize) <= 0) { if (taosReadFile(pFile, buf, fileSize) <= 0) {
taosCloseFile(&pFile); taosCloseFile(&pFile);
uError("load json file error: %s", filepath); uError("load json file error: %s", filepath);
taosMemoryFreeClear(buf); taosMemoryFreeClear(buf);
return -1; TAOS_RETURN(TSDB_CODE_INVALID_DATA_FMT);
} }
taosCloseFile(&pFile); taosCloseFile(&pFile);
SJson *pJson = tjsonParse(buf); pJson = tjsonParse(buf);
if (NULL == pJson) { if (NULL == pJson) {
const char *jsonParseError = tjsonGetError(); const char *jsonParseError = tjsonGetError();
if (jsonParseError != NULL) { if (jsonParseError != NULL) {
uError("load json file parse error: %s", jsonParseError); uError("load json file parse error: %s", jsonParseError);
} }
taosMemoryFreeClear(buf); taosMemoryFreeClear(buf);
return -1; TAOS_RETURN(TSDB_CODE_INVALID_DATA_FMT);
} }
taosMemoryFreeClear(buf); taosMemoryFreeClear(buf);
@ -1295,13 +1272,17 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
cJSON *item = tjsonGetArrayItem(pJson, i); cJSON *item = tjsonGetArrayItem(pJson, i);
if (item == NULL) break; if (item == NULL) break;
char *itemName = NULL, *itemValueString = NULL; char *itemName = NULL, *itemValueString = NULL;
tjsonGetObjectName(item, &itemName); TAOS_CHECK_GOTO(tjsonGetObjectName(item, &itemName), NULL, _err_json);
tjsonGetObjectName(item, &itemName); TAOS_CHECK_GOTO(tjsonGetObjectValueString(item, &itemValueString), NULL, _err_json);
tjsonGetObjectValueString(item, &itemValueString);
if (itemValueString != NULL && itemName != NULL) { if (itemValueString != NULL && itemName != NULL) {
size_t itemNameLen = strlen(itemName); size_t itemNameLen = strlen(itemName);
size_t itemValueStringLen = strlen(itemValueString); size_t itemValueStringLen = strlen(itemValueString);
cfgLineBuf = taosMemoryMalloc(itemNameLen + itemValueStringLen + 2); cfgLineBuf = taosMemoryMalloc(itemNameLen + itemValueStringLen + 2);
if (NULL == cfgLineBuf) {
code = TSDB_CODE_OUT_OF_MEMORY;
goto _err_json;
}
memcpy(cfgLineBuf, itemName, itemNameLen); memcpy(cfgLineBuf, itemName, itemNameLen);
cfgLineBuf[itemNameLen] = ' '; cfgLineBuf[itemNameLen] = ' ';
memcpy(&cfgLineBuf[itemNameLen + 1], itemValueString, itemValueStringLen); memcpy(&cfgLineBuf[itemNameLen + 1], itemValueString, itemValueStringLen);
@ -1327,11 +1308,11 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
} }
code = cfgSetItem(pConfig, name, value, CFG_STYPE_APOLLO_URL, true); code = cfgSetItem(pConfig, name, value, CFG_STYPE_APOLLO_URL, true);
if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
if (strcasecmp(name, "dataDir") == 0) { if (strcasecmp(name, "dataDir") == 0) {
code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_APOLLO_URL); code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_APOLLO_URL);
if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break; if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
} }
} }
} }
@ -1341,16 +1322,20 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
// } else if (strncmp(url, "etcdUrl", 7) == 0) { // } else if (strncmp(url, "etcdUrl", 7) == 0) {
} else { } else {
uError("Unsupported url: %s", url); uError("Unsupported url: %s", url);
return -1; TAOS_RETURN(TSDB_CODE_INVALID_PARA);
} }
uInfo("load from apoll url not implemented yet"); uInfo("load from apoll url not implemented yet");
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
_err_json:
tjsonDelete(pJson);
TAOS_RETURN(code);
} }
int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl) { int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl) {
int32_t index = 0; int32_t index = 0;
if (envCmd == NULL) return 0; if (envCmd == NULL) TAOS_RETURN(TSDB_CODE_SUCCESS);
while (envCmd[index] != NULL) { while (envCmd[index] != NULL) {
if (strncmp(envCmd[index], "TAOS_APOLLO_URL", 14) == 0) { if (strncmp(envCmd[index], "TAOS_APOLLO_URL", 14) == 0) {
char *p = strchr(envCmd[index], '='); char *p = strchr(envCmd[index], '=');
@ -1362,7 +1347,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
} }
memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX)); 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");
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
} }
index++; index++;
@ -1384,7 +1369,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
} }
memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX)); 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);
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
} }
} }
@ -1393,13 +1378,13 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
if (envFile != NULL && strlen(envFile) > 0) { if (envFile != NULL && strlen(envFile) > 0) {
if (!taosCheckExistFile(envFile)) { if (!taosCheckExistFile(envFile)) {
uError("failed to load env file:%s", envFile); uError("failed to load env file:%s", envFile);
return -1; TAOS_RETURN(TSDB_CODE_NOT_FOUND);
} }
filepath = envFile; filepath = envFile;
} else { } else {
if (!taosCheckExistFile(filepath)) { if (!taosCheckExistFile(filepath)) {
uInfo("env file:%s not load", filepath); uInfo("env file:%s not load", filepath);
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
} }
int64_t _bytes; int64_t _bytes;
@ -1422,7 +1407,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX)); memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX));
taosCloseFile(&pFile); taosCloseFile(&pFile);
uInfo("get apollo url from env file success"); uInfo("get apollo url from env file success");
return 0; TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
} }
} }
@ -1430,7 +1415,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
} }
uInfo("fail get apollo url from cmd env file"); uInfo("fail get apollo url from cmd env file");
return -1; TAOS_RETURN(TSDB_CODE_INVALID_PARA);
} }
struct SConfigIter { struct SConfigIter {
@ -1438,15 +1423,16 @@ struct SConfigIter {
SConfig *pConf; SConfig *pConf;
}; };
SConfigIter *cfgCreateIter(SConfig *pConf) { int32_t cfgCreateIter(SConfig *pConf, SConfigIter **ppIter) {
SConfigIter* pIter = taosMemoryCalloc(1, sizeof(SConfigIter)); SConfigIter *pIter = taosMemoryCalloc(1, sizeof(SConfigIter));
if (pIter == NULL) { if (pIter == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY; TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
return NULL;
} }
pIter->pConf = pConf; pIter->pConf = pConf;
return pIter;
*ppIter = pIter;
TAOS_RETURN(TSDB_CODE_SUCCESS);
} }
SConfigItem *cfgNextIter(SConfigIter* pIter) { SConfigItem *cfgNextIter(SConfigIter* pIter) {
@ -1463,4 +1449,4 @@ void cfgDestroyIter(SConfigIter *pIter) {
} }
taosMemoryFree(pIter); taosMemoryFree(pIter);
} }

11
source/util/test/cfgTest.cpp
View File

@ -51,7 +51,10 @@ TEST_F(CfgTest, 01_Str) {
} }
TEST_F(CfgTest, 02_Basic) { TEST_F(CfgTest, 02_Basic) {
SConfig *pConfig = cfgInit(); SConfig *pConfig = NULL;
int32_t code = cfgInit(&pConfig);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
ASSERT_NE(pConfig, nullptr); ASSERT_NE(pConfig, nullptr);
EXPECT_EQ(cfgAddBool(pConfig, "test_bool", 0, 0, 0), 0); EXPECT_EQ(cfgAddBool(pConfig, "test_bool", 0, 0, 0), 0);
@ -66,7 +69,11 @@ TEST_F(CfgTest, 02_Basic) {
int32_t size = cfgGetSize(pConfig); int32_t size = cfgGetSize(pConfig);
SConfigItem* pItem = NULL; SConfigItem* pItem = NULL;
SConfigIter* pIter = cfgCreateIter(pConfig); 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) { switch (pItem->dtype) {
case CFG_DTYPE_BOOL: case CFG_DTYPE_BOOL: