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

Add more dyn configs and fix vesion in mnd bug.

This commit is contained in:
xiao-77 2024-11-22 15:57:18 +08:00
parent 1089f323e4
commit db67245af0
6 changed files with 129 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/util/tconfig.h
View File

@ -118,9 +118,9 @@ void cfgCleanup(SConfig *pCfg);
int32_t cfgGetSize(SConfig *pCfg);
SConfigItem *cfgGetItem(SConfig *pCfg, const char *pName);
int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcType stype, bool lock);
int32_t cfgGetAndSetItem(SConfig *pCfg, SConfigItem *pItem, const char *name, const char *value, ECfgSrcType stype,
int32_t cfgGetAndSetItem(SConfig *pCfg, SConfigItem **ppItem, 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, bool isUpdateAll);
int32_t cfgCreateIter(SConfig *pConf, SConfigIter **ppIter);
SConfigItem *cfgNextIter(SConfigIter *pIter);

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

@ -45,7 +45,7 @@ uint16_t tsServerPort = 6030;
int32_t tsVersion = 30000000;
int32_t tsForceReadConfig = 0;
int32_t tsdmConfigVersion = -1;
int32_t tsmmConfigVersion = 0;
int32_t tsmmConfigVersion = -1;
int32_t tsConfigInited = 0;
int32_t tsStatusInterval = 1; // second
int32_t tsNumOfSupportVnodes = 256;
@ -2225,12 +2225,33 @@ static int32_t taosCfgDynamicOptionsForServer(SConfig *pCfg, const char *name) {
{"asynclog", &tsAsyncLog},
{"disableStream", &tsDisableStream},
{"enableWhiteList", &tsEnableWhiteList},
{"statusInterval", &tsStatusInterval},
{"telemetryReporting", &tsEnableTelem},
{"monitor", &tsEnableMonitor},
{"monitorInterval", &tsMonitorInterval},
{"monitorComp", &tsMonitorComp},
{"monitorForceV2", &tsMonitorForceV2},
{"monitorLogProtocol", &tsMonitorLogProtocol},
{"monitorMaxLogs", &tsMonitorMaxLogs},
{"audit", &tsEnableAudit},
{"auditCreateTable", &tsEnableAuditCreateTable},
{"auditInterval", &tsAuditInterval},
{"slowLogThreshold", &tsSlowLogThreshold},
{"compressMsgSize", &tsCompressMsgSize},
{"compressor", &tsCompressor},
{"curRange", &tsCurRange},
{"dPrecision", &tsDPrecision},
{"fPrecision", &tsFPrecision},
{"ifAdtFse", &tsIfAdtFse},
{"maxRange", &tsMaxRange},
{"maxTsmaNum", &tsMaxTsmaNum},
{"queryRsmaTolerance", &tsQueryRsmaTolerance},
{"countAlwaysReturnValue", &tsCountAlwaysReturnValue},
{"uptimeInterval", &tsUptimeInterval},
{"slowLogThresholdTest", &tsSlowLogThresholdTest},
{"slowLogMaxLen", &tsSlowLogMaxLen},
{"slowLogScope", &tsSlowLogScope},
{"slowLogExceptDb", &tsSlowLogExceptDb},
{"mndSdbWriteDelta", &tsMndSdbWriteDelta},
{"minDiskFreeSize", &tsMinDiskFreeSize},
@ -2238,9 +2259,28 @@ static int32_t taosCfgDynamicOptionsForServer(SConfig *pCfg, const char *name) {
{"randErrorDivisor", &tsRandErrDivisor},
{"randErrorScope", &tsRandErrScope},
{"syncLogBufferMemoryAllowed", &tsLogBufferMemoryAllowed},
{"resolveFQDNRetryTime", &tsResolveFQDNRetryTime},
{"syncElectInterval", &tsElectInterval},
{"syncHeartbeatInterval", &tsHeartbeatInterval},
{"syncHeartbeatTimeout", &tsHeartbeatTimeout},
{"syncSnapReplMaxWaitN", &tsSnapReplMaxWaitN},
{"walFsyncDataSizeLimit", &tsWalFsyncDataSizeLimit},
{"numOfCores", &tsNumOfCores},
{"enableCoreFile", &tsEnableCoreFile},
{"telemetryInterval", &tsTelemInterval},
{"telemetryPort", &tsTelemPort},
{"cacheLazyLoadThreshold", &tsCacheLazyLoadThreshold},
{"checkpointInterval", &tsStreamCheckpointInterval},
{"concurrentCheckpoint", &tsMaxConcurrentCheckpoint},
{"retentionSpeedLimitMB", &tsRetentionSpeedLimitMB},
{"trimVDbIntervalSec", &tsTrimVDbIntervalSec},
{"ttlChangeOnWrite", &tsTtlChangeOnWrite},
{"keepAliveIdle", &tsKeepAliveIdle},
{"logKeepDays", &tsLogKeepDays},
{"maxStreamBackendCache", &tsMaxStreamBackendCache},
@ -2256,15 +2296,31 @@ static int32_t taosCfgDynamicOptionsForServer(SConfig *pCfg, const char *name) {
{"ttlBatchDropNum", &tsTtlBatchDropNum},
{"ttlFlushThreshold", &tsTtlFlushThreshold},
{"ttlPushInterval", &tsTtlPushIntervalSec},
{"ttlUnit", &tsTtlUnit},
{"udf", &tsStartUdfd},
{"udfdLdLibPath", &tsUdfdLdLibPath},
{"udfdResFuncs", &tsUdfdResFuncs},
{"s3Accesskey", &tsS3AccessKey},
{"s3BucketName", &tsS3BucketName},
{"s3Endpoint", &tsS3Endpoint},
{"s3MigrateIntervalSec", &tsS3MigrateIntervalSec},
{"s3MigrateEnabled", &tsS3MigrateEnabled},
//{"s3BlockSize", &tsS3BlockSize},
{"s3BlockCacheSize", &tsS3BlockCacheSize},
{"s3PageCacheSize", &tsS3PageCacheSize},
{"s3UploadDelaySec", &tsS3UploadDelaySec},
{"mndSdbWriteDelta", &tsMndSdbWriteDelta},
{"mndLogRetention", &tsMndLogRetention},
{"supportVnodes", &tsNumOfSupportVnodes},
{"experimental", &tsExperimental},
{"maxTsmaNum", &tsMaxTsmaNum},
{"maxShellConns", &tsMaxShellConns},
{"numOfRpcSessions", &tsNumOfRpcSessions},
{"numOfRpcThreads", &tsNumOfRpcThreads},
{"rpcQueueMemoryAllowed", &tsQueueMemoryAllowed},
{"shellActivityTimer", &tsShellActivityTimer},
{"timeToGetAvailableConn", &tsTimeToGetAvailableConn},
{"tsReadTimeout", &tsReadTimeout},
{"safetyCheckLevel", &tsSafetyCheckLevel}};
if ((code = taosCfgSetOption(debugOptions, tListLen(debugOptions), pItem, true)) != TSDB_CODE_SUCCESS) {

2
source/dnode/mgmt/mgmt_dnode/src/dmHandle.c
View File

@ -453,7 +453,7 @@ int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SRpcMsg *pMsg) {
SConfig *pCfg = taosGetCfg();
SConfigItem *pItem = NULL;
code = cfgGetAndSetItem(pCfg, pItem, cfgReq.config, cfgReq.value, CFG_STYPE_ALTER_CMD, true);
code = cfgGetAndSetItem(pCfg, &pItem, cfgReq.config, cfgReq.value, CFG_STYPE_ALTER_CMD, true);
if (code != 0) {
if (strncasecmp(cfgReq.config, "resetlog", strlen("resetlog")) == 0) {
code = 0;

22
source/dnode/mnode/impl/src/mndConfig.c
View File

@ -25,6 +25,11 @@
#define CFG_VER_NUMBER 1
#define CFG_RESERVE_SIZE 63
enum CfgAlterType {
CFG_ALTER_DNODE,
CFG_ALTER_ALL_DNODES,
};
static int32_t mndMCfgGetValInt32(SMCfgDnodeReq *pInMCfgReq, int32_t optLen, int32_t *pOutValue);
static int32_t cfgUpdateItem(SConfigItem *pItem, SConfigObj *obj);
static int32_t mndConfigUpdateTrans(SMnode *pMnode, const char *name, char *pValue);
@ -249,7 +254,6 @@ int32_t mndInitWriteCfg(SMnode *pMnode) {
int code = -1;
size_t sz = 0;
SConfigObj obj = {0};
STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_NOTHING, NULL, "init-write-config");
if (pTrans == NULL) {
mError("failed to init write cfg in create trans, since %s", terrstr());
@ -257,8 +261,8 @@ int32_t mndInitWriteCfg(SMnode *pMnode) {
}
// encode mnd config version
obj = (SConfigObj){.name = "tsmmConfigVersion", .dtype = CFG_DTYPE_INT32, .i32 = tsmmConfigVersion};
if ((code = mndSetCreateConfigCommitLogs(pTrans, &obj)) != 0) {
SConfigObj *obj = mndInitConfigVersion();
if ((code = mndSetCreateConfigCommitLogs(pTrans, obj)) != 0) {
mError("failed to init mnd config version, since %s", terrstr());
}
sz = taosArrayGetSize(taosGetGlobalCfg(tsCfg));
@ -479,9 +483,11 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
updateIpWhiteList = 1;
}
TAOS_CHECK_GOTO(cfgCheckRangeForDynUpdate(taosGetCfg(), dcfgReq.config, dcfgReq.value, true), &lino, _err_out);
bool isUpdateAll = (cfgReq.dnodeId == 0 || cfgReq.dnodeId == -1) ? true : false;
TAOS_CHECK_GOTO(cfgCheckRangeForDynUpdate(taosGetCfg(), dcfgReq.config, dcfgReq.value, true, isUpdateAll), &lino,
_err_out);
}
// update config in sdb
// Update config in sdb.
TAOS_CHECK_GOTO(mndConfigUpdateTrans(pMnode, cfgReq.config, cfgReq.value), &lino, _err_out);
{ // audit
char obj[50] = {0};
@ -538,11 +544,13 @@ _err:
static int32_t mndConfigUpdateTrans(SMnode *pMnode, const char *name, char *pValue) {
int32_t code = -1;
int32_t lino = -1;
SConfigObj *pVersion = mndInitConfigVersion();
SConfigObj *pVersion = sdbAcquire(pMnode->pSdb, SDB_CFG, "tsmmConfigVersion");
if (pVersion == NULL) {
mWarn("failed to acquire tsmmConfigVersion while update config, since %s", terrstr());
code = terrno;
goto _OVER;
}
pVersion->i32 = ++tsmmConfigVersion;
SConfigObj *pObj = sdbAcquire(pMnode->pSdb, SDB_CFG, name);
if (pObj == NULL) {
mWarn("failed to acquire mnd config:%s while update config, since %s", name, terrstr());
@ -555,7 +563,7 @@ static int32_t mndConfigUpdateTrans(SMnode *pMnode, const char *name, char *pVal
if (terrno != 0) code = terrno;
goto _OVER;
}
mInfo("trans:%d, used to update config:%s to value:%s", pTrans->id, pObj->name, pObj->str);
mInfo("trans:%d, used to update config:%s to value:%s", pTrans->id, name, pValue);
TAOS_CHECK_GOTO(mndSetCreateConfigCommitLogs(pTrans, pVersion), &lino, _OVER);
TAOS_CHECK_GOTO(mndSetCreateConfigCommitLogs(pTrans, pObj), &lino, _OVER);
if ((code = mndTransPrepare(pMnode, pTrans)) != 0) goto _OVER;

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

@ -13,8 +13,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "command.h"
#include "catalog.h"
#include "command.h"
#include "commandInt.h"
#include "scheduler.h"
#include "systable.h"
@ -51,7 +51,7 @@ static int32_t buildRetrieveTableRsp(SSDataBlock* pBlock, int32_t numOfCols, SRe
(*pRsp)->numOfCols = htonl(numOfCols);
int32_t len = blockEncode(pBlock, (*pRsp)->data + PAYLOAD_PREFIX_LEN, dataEncodeBufSize, numOfCols);
if(len < 0) {
if (len < 0) {
taosMemoryFree(*pRsp);
return terrno;
}
@ -898,7 +898,7 @@ static int32_t execAlterLocal(SAlterLocalStmt* pStmt) {
goto _return;
}
if (cfgCheckRangeForDynUpdate(tsCfg, pStmt->config, pStmt->value, false)) {
if (cfgCheckRangeForDynUpdate(tsCfg, pStmt->config, pStmt->value, false, false)) {
return terrno;
}

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

@ -40,7 +40,7 @@ int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile);
int32_t cfgLoadFromEnvVar(SConfig *pConfig);
int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd);
int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url);
int32_t cfgSetItemVal(SConfigItem *item, ECfgDataType dtype);
int32_t cfgSetItemVal(SConfigItem *pItem, const char *name, const char *value, ECfgSrcType stype);
extern char **environ;
@ -354,7 +354,7 @@ int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcTy
TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
}
TAOS_CHECK_RETURN(cfgSetItemVal(pItem, pItem->dtype));
TAOS_CHECK_RETURN(cfgSetItemVal(pItem, name, value, stype));
if (lock) {
(void)taosThreadMutexUnlock(&pCfg->lock);
@ -363,7 +363,7 @@ int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcTy
TAOS_RETURN(code);
}
int32_t cfgGetAndSetItem(SConfig *pCfg, SConfigItem *pItem, const char *name, const char *value, ECfgSrcType stype,
int32_t cfgGetAndSetItem(SConfig *pCfg, SConfigItem **pItem, const char *name, const char *value, ECfgSrcType stype,
bool lock) {
// GRANT_CFG_SET;
int32_t code = TSDB_CODE_SUCCESS;
@ -372,13 +372,13 @@ int32_t cfgGetAndSetItem(SConfig *pCfg, SConfigItem *pItem, const char *name, co
(void)taosThreadMutexLock(&pCfg->lock);
}
pItem = cfgGetItem(pCfg, name);
*pItem = cfgGetItem(pCfg, name);
if (pItem == NULL) {
(void)taosThreadMutexUnlock(&pCfg->lock);
TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
}
TAOS_CHECK_RETURN(cfgSetItemVal(pItem, pItem->dtype));
TAOS_CHECK_RETURN(cfgSetItemVal(*pItem, name, value, stype));
if (lock) {
(void)taosThreadMutexUnlock(&pCfg->lock);
@ -387,34 +387,54 @@ int32_t cfgGetAndSetItem(SConfig *pCfg, SConfigItem *pItem, const char *name, co
TAOS_RETURN(code);
}
int32_t cfgSetItemVal(SConfigItem *item, ECfgDataType dtype) {
if (item == NULL) {
int32_t cfgSetItemVal(SConfigItem *pItem, const char *name, const char *value, ECfgSrcType stype) {
int32_t code = TSDB_CODE_SUCCESS;
if (pItem == NULL) {
TAOS_RETURN(TSDB_CODE_INVALID_CFG);
}
item->dtype = dtype;
switch (dtype) {
case CFG_DTYPE_BOOL:
item->bval = false;
switch (pItem->dtype) {
case CFG_DTYPE_BOOL: {
code = cfgSetBool(pItem, value, stype);
break;
case CFG_DTYPE_INT32:
item->i32 = 0;
}
case CFG_DTYPE_INT32: {
code = cfgSetInt32(pItem, value, stype);
break;
case CFG_DTYPE_INT64:
item->i64 = 0;
}
case CFG_DTYPE_INT64: {
code = cfgSetInt64(pItem, value, stype);
break;
}
case CFG_DTYPE_FLOAT:
case CFG_DTYPE_DOUBLE:
item->fval = 0;
case CFG_DTYPE_DOUBLE: {
code = cfgSetFloat(pItem, value, stype);
break;
case CFG_DTYPE_STRING:
case CFG_DTYPE_DIR:
case CFG_DTYPE_LOCALE:
case CFG_DTYPE_CHARSET:
case CFG_DTYPE_TIMEZONE:
item->str = NULL;
}
case CFG_DTYPE_STRING: {
code = cfgSetString(pItem, value, stype);
break;
}
case CFG_DTYPE_DIR: {
code = cfgSetDir(pItem, value, stype);
break;
}
case CFG_DTYPE_TIMEZONE: {
code = cfgSetTimezone(pItem, value, stype);
break;
}
case CFG_DTYPE_CHARSET: {
code = doSetConf(pItem, value, stype);
break;
}
case CFG_DTYPE_LOCALE: {
code = doSetConf(pItem, value, stype);
break;
}
case CFG_DTYPE_NONE:
default:
TAOS_RETURN(TSDB_CODE_INVALID_CFG);
code = TSDB_CODE_INVALID_CFG;
break;
}
TAOS_RETURN(TSDB_CODE_SUCCESS);
@ -450,7 +470,7 @@ void cfgLock(SConfig *pCfg) {
void cfgUnLock(SConfig *pCfg) { (void)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, bool isUpdateAll) {
ECfgDynType dynType = isServer ? CFG_DYN_SERVER : CFG_DYN_CLIENT;
cfgLock(pCfg);
@ -461,6 +481,11 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p
cfgUnLock(pCfg);
TAOS_RETURN(TSDB_CODE_INVALID_CFG);
}
if (!isUpdateAll && (pItem->category & CFG_CATEGORY_GLOBAL) == 0) {
uError("failed to config:%s, not support update global config on only one dnode", name);
cfgUnLock(pCfg);
TAOS_RETURN(TSDB_CODE_INVALID_CFG);
}
switch (pItem->dtype) {
case CFG_DTYPE_STRING: {