taosdata / TDengine / #5011

coverage: 72.3% (+0.008%) from 72.292%
#5011

push

travis-ci

web-flow 
merge: from main to 3.0 branch #35067

4053 of 5985 new or added lines in 68 files covered. (67.72%)

732 existing lines in 143 files now uncovered.

257430 of 356056 relevant lines covered (72.3%)

131834103.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.74
/source/common/src/tglobal.c
1 
/*
2 
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3 
 *
4 
 * This program is free software: you can use, redistribute, and/or modify
5 
 * it under the terms of the GNU Affero General Public License, version 3
6 
 * or later ("AGPL"), as published by the Free Software Foundation.
7 
 *
8 
 * This program is distributed in the hope that it will be useful, but WITHOUT
9 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 
 * FITNESS FOR A PARTICULAR PURPOSE.
11 
 *
12 
 * You should have received a copy of the GNU Affero General Public License
13 
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14 
 */
15 









16



#define _DEFAULT_SOURCE










17



#include "cJSON.h"










18



#include "defines.h"










19



#include "os.h"










20



#include "osString.h"










21



#include "tconfig.h"










22



#include "tencrypt.h"










23



#include "tglobal.h"










24



#include "tgrant.h"










25



#include "tjson.h"










26



#include "tlog.h"










27



#include "tmisce.h"










28



#include "tunit.h"










29












30



#include "tutil.h"










31












32



#define CONFIG_PATH_LEN (TSDB_FILENAME_LEN + 12)










33



#define CONFIG_FILE_LEN (CONFIG_PATH_LEN + 32)










34












35



// GRANT_CFG_DECLARE;










36












37



SConfig *tsCfg = NULL;










38



// cluster










39



char          tsFirst[TSDB_EP_LEN] = {0};










40



char          tsSecond[TSDB_EP_LEN] = {0};










41



char          tsLocalFqdn[TSDB_FQDN_LEN] = {0};










42



char          tsLocalEp[TSDB_EP_LEN] = {0};  // Local End Point, hostname:port










43



char          tsVersionName[16] = "community";










44



uint16_t      tsServerPort = 6030;










45



int32_t       tsVersion = 30000000;










46



int32_t       tsdmConfigVersion = -1;










47



int32_t       tsConfigInited = 0;










48



int32_t       tsLocalKeyVersion = 0;










49



int32_t       tsStatusInterval = 1;  // second










50



int32_t       tsStatusIntervalMs = 1000;










51



int32_t       tsStatusSRTimeoutMs = 5000;










52



int32_t       tsStatusTimeoutMs = 5000;










53



int32_t       tsNumOfSupportVnodes = 256;










54



uint16_t      tsMqttPort = 6083;










55



char          tsEncryptAlgorithm[16] = {0};










56



char          tsEncryptScope[100] = {0};










57



EEncryptAlgor tsiEncryptAlgorithm = 0;










58



EEncryptScope tsiEncryptScope = 0;










59



// char     tsAuthCode[500] = {0};










60



// char     tsEncryptKey[17] = {0};










61



char          tsEncryptKey[17] = {0};










62



int8_t        tsEnableStrongPassword = 1;










63












64



#ifdef TD_ENABLE_ADVANCED_SECURITY










65



int8_t        tsEnableAdvancedSecurity = 1;










66



#else










67



int8_t        tsEnableAdvancedSecurity = 0;










68



#endif










69



int8_t        tsEnableGrantLegacySyntax = 0;










70












71



char          tsEncryptPassAlgorithm[16] = {0};










72



EEncryptAlgor tsiEncryptPassAlgorithm = 0;










73












74



char tsTLSCaPath[PATH_MAX] = {0};










75



char tsTLSSvrCertPath[PATH_MAX] = {0};










76



char tsTLSSvrKeyPath[PATH_MAX] = {0};










77












78



char tsTLSCliCertPath[PATH_MAX] = {0};










79



char tsTLSCliKeyPath[PATH_MAX] = {0};










80












81



int8_t tsEnableTLS = 0;










82



int8_t tsEnableSasl = 0;










83



// common










84



int32_t tsMaxShellConns = 50000;










85



int32_t tsShellActivityTimer = 3;  // second










86












87



// memory pool










88



int8_t tsMemPoolFullFunc = 0;










89



#ifndef TD_ASTRA










90



int8_t tsQueryUseMemoryPool = 1;










91



#else










92



int8_t  tsQueryUseMemoryPool = 0;










93



#endif










94



int32_t tsQueryBufferPoolSize = 0;       // MB










95



int32_t tsSingleQueryMaxMemorySize = 0;  // MB










96



int32_t tsMinReservedMemorySize = 0;     // MB










97



int64_t tsCurrentAvailMemorySize = 0;










98



int8_t  tsNeedTrim = 0;










99












100



// queue & threads










101



int32_t tsQueryMinConcurrentTaskNum = 1;










102



int32_t tsQueryMaxConcurrentTaskNum = 0;










103



int32_t tsQueryConcurrentTaskNum = 0;










104



int32_t tsQueryNoFetchTimeoutSec = 3600 * 5;










105












106



int32_t tsNumOfRpcThreads = 1;










107



int32_t tsNumOfRpcSessions = 30000;










108



#ifdef WINDOWS










109



int32_t tsShareConnLimit = 1;










110



#else










111



int32_t tsShareConnLimit = 10;










112



#endif










113












114



int32_t tsReadTimeout = 900;










115



int32_t tsTimeToGetAvailableConn = 500000;










116



int8_t  tsEnableIpv6 = 0;










117












118



#ifdef TD_ENTERPRISE










119



bool    tsAuthServer = 0;










120



bool    tsAuthReq = 0;










121



int32_t tsAuthReqInterval = 2592000;










122



int32_t tsAuthReqHBInterval = 5;










123



char    tsAuthReqUrl[TSDB_FQDN_LEN] = {0};










124



#endif










125












126



int32_t tsNumOfQueryThreads = 0;










127



int32_t tsNumOfCommitThreads = 2;










128



int32_t tsNumOfTaskQueueThreads = 16;










129



int32_t tsNumOfMnodeQueryThreads = 16;










130



int32_t tsNumOfMnodeFetchThreads = 1;










131



int32_t tsNumOfMnodeReadThreads = 1;










132



int32_t tsNumOfVnodeQueryThreads = 16;










133



int32_t tsNumOfVnodeFetchThreads = 4;










134



int32_t tsNumOfVnodeRsmaThreads = 2;










135



int32_t tsNumOfQnodeQueryThreads = 16;










136



int32_t tsNumOfQnodeFetchThreads = 1;










137



int32_t tsNumOfSnodeStreamThreads = 4;










138



int32_t tsNumOfSnodeWriteThreads = 1;










139



int32_t tsPQSortMemThreshold = 16;    // M










140



int32_t tsRetentionSpeedLimitMB = 0;  // unlimited










141



int32_t tsNumOfMnodeStreamMgmtThreads = 2;










142



int32_t tsNumOfStreamMgmtThreads = 2;










143



int32_t tsNumOfVnodeStreamReaderThreads = 16;










144



int32_t tsNumOfStreamTriggerThreads = 4;










145



int32_t tsNumOfStreamRunnerThreads = 4;










146












147



int32_t tsNumOfCompactThreads = 2;










148



int32_t tsNumOfRetentionThreads = 1;










149



int32_t tsSecureEraseMode = 0;










150












151



// sync raft










152



int32_t tsElectInterval = 4000;










153



int32_t tsHeartbeatInterval = 1000;










154



int32_t tsVnodeElectIntervalMs = 4000;










155



int32_t tsVnodeHeartbeatIntervalMs = 1000;










156



int32_t tsMnodeElectIntervalMs = 3000;










157



int32_t tsMnodeHeartbeatIntervalMs = 500;










158



int32_t tsHeartbeatTimeout = 20 * 1000;










159



int32_t tsSnapReplMaxWaitN = 128;










160



int64_t tsLogBufferMemoryAllowed = 0;  // bytes










161



int64_t tsSyncApplyQueueSize = 512;










162



int32_t tsRoutineReportInterval = 300;










163



bool    tsSyncLogHeartbeat = false;










164



int32_t tsSyncTimeout = 0;










165












166



// mnode










167



int64_t tsMndSdbWriteDelta = 200;










168



int64_t tsMndLogRetention = 2000;










169



bool    tsMndSkipGrant = false;










170



bool    tsEnableWhiteList = false;  // ip white list cfg










171



bool    tsForceKillTrans = false;










172












173



// arbitrator










174



int32_t tsArbHeartBeatIntervalSec = 2;










175



int32_t tsArbCheckSyncIntervalSec = 3;










176



int32_t tsArbSetAssignedTimeoutSec = 14;










177



int32_t tsArbHeartBeatIntervalMs = 2000;










178



int32_t tsArbCheckSyncIntervalMs = 3000;










179



int32_t tsArbSetAssignedTimeoutMs = 14000;










180












181



// dnode










182



int64_t tsDndStart = 0;










183



int64_t tsDndStartOsUptime = 0;










184



int64_t tsDndUpTime = 0;










185












186



// dnode misc










187



uint32_t tsEncryptionKeyChksum = 0;










188



int8_t   tsEncryptionKeyStat = ENCRYPT_KEY_STAT_UNSET;










189












190



// taosk encryption keys (multi-layer encryption)










191



bool     tsUseTaoskEncryption = false;  // Flag: using taosk encrypt.bin format










192



bool     tsSkipKeyCheckMode = false;    // Flag: skip key check mode










193



int32_t  tsEncryptKeysStatus = 0;       // 0: not loaded, 1: loaded from file, 2: loaded from mnode










194



char     tsSvrKey[ENCRYPT_KEY_LEN + 1] = {0};   // SVR_KEY: exactly 16 bytes










195



char     tsDbKey[ENCRYPT_KEY_LEN + 1] = {0};    // DB_KEY: exactly 16 bytes










196



char     tsCfgKey[ENCRYPT_KEY_LEN + 1] = {0};   // CFG_KEY: exactly 16 bytes










197



char     tsMetaKey[ENCRYPT_KEY_LEN + 1] = {0};  // META_KEY: exactly 16 bytes










198



char     tsDataKey[ENCRYPT_KEY_LEN + 1] = {0};  // DATA_KEY: exactly 16 bytes










199



int32_t  tsEncryptAlgorithmType = 0;    // Algorithm type for master keys (SVR_KEY, DB_KEY)










200



int32_t  tsCfgAlgorithm = 0;            // Algorithm type for CFG_KEY










201



int32_t  tsMetaAlgorithm = 0;           // Algorithm type for META_KEY










202



int32_t  tsEncryptFileVersion = 0;      // File format version for compatibility










203



int32_t  tsEncryptKeyVersion = 0;       // Key update version (starts from 1, increments on update)










204



int64_t  tsEncryptKeyCreateTime = 0;    // Key creation timestamp










205



int64_t  tsSvrKeyUpdateTime = 0;        // SVR_KEY last update timestamp










206



int64_t  tsDbKeyUpdateTime = 0;         // DB_KEY last update timestamp










207



int32_t  tsKeyExpirationDays = 30;      // Key expiration days (default: 30)










208



char     tsKeyExpirationStrategy[ENCRYPT_KEY_EXPIRE_STRATEGY_LEN + 1] =










209



    "ALARM";  // Key expiration strategy (default: "ALARM")










210



uint32_t tsGrant = 1;










211












212



#if defined(TD_FLEX_DEPLOY)










213



int8_t   tsFlexDeploy = 1;










214



#else










215



int8_t   tsFlexDeploy = 0;










216



#endif










217












218



bool tsCompareAsStrInGreatest = true;










219












220



// monitor










221



#ifdef USE_MONITOR










222



bool tsEnableMonitor = true;










223



#else










224



bool    tsEnableMonitor = false;










225



#endif










226



int32_t  tsMonitorInterval = 30;










227



char     tsMonitorFqdn[TSDB_FQDN_LEN] = {0};










228



uint16_t tsMonitorPort = 6043;










229



int32_t  tsMonitorMaxLogs = 100;










230



bool     tsMonitorComp = false;










231



bool     tsMonitorLogProtocol = false;










232



int32_t  tsEnableMetrics = 0;     // 0: disable, 1: enable










233



int32_t  tsMetricsLevel = 0;      // 0: only high level metrics, 1: full metrics










234



int32_t  tsMetricsInterval = 30;  // second










235



#ifdef USE_MONITOR










236



bool tsMonitorForceV2 = true;










237



#else










238



bool    tsMonitorForceV2 = false;










239



#endif










240












241



// audit










242



#ifdef USE_AUDIT










243



bool    tsEnableAudit = true;










244



bool    tsEnableAuditCreateTable = true;










245



bool    tsEnableAuditDelete = true;










246



bool    tsEnableAuditSelect = true;










247



bool    tsEnableAuditInsert = true;










248



int32_t tsAuditInterval = 5000;










249



int32_t tsAuditLevel = AUDIT_LEVEL_DATABASE;










250



bool    tsAuditHttps = false;










251



bool    tsAuditUseToken = true;










252



bool    tsAuditSaveInSelf = false;










253



#else










254



bool    tsEnableAudit = false;










255



bool    tsEnableAuditCreateTable = false;










256



bool    tsEnableAuditDelete = false;










257



bool    tsEnableAuditSelect = false;










258



bool    tsEnableAuditInsert = false;










259



int32_t tsAuditInterval = 200000;










260



int32_t tsAuditLevel = AUDIT_LEVEL_NONE;










261



bool    tsAuditHttps = false;










262



bool    tsAuditUseToken = true;










263



bool    tsAuditSaveInSelf = false;










264



#endif










265












266



// telem










267



#if defined(TD_ENTERPRISE) || !defined(USE_REPORT)










268



bool tsEnableTelem = false;










269



#else










270



bool    tsEnableTelem = true;










271



#endif










272



int32_t  tsTelemInterval = 86400;










273



char     tsTelemServer[TSDB_FQDN_LEN] = "telemetry.tdengine.com";










274



uint16_t tsTelemPort = 80;










275



char    *tsTelemUri = "/report";










276












277



#if defined(TD_ENTERPRISE) || !defined(USE_REPORT)










278



bool tsEnableCrashReport = false;










279



#else










280



bool    tsEnableCrashReport = true;










281



#endif










282



char   *tsClientCrashReportUri = "/ccrashreport";










283



char   *tsSvrCrashReportUri = "/dcrashreport";










284



int32_t tsSafetyCheckLevel = TSDB_SAFETY_CHECK_LEVELL_NORMAL;










285












286



// schemaless










287



bool tsSmlDot2Underline = true;










288



char tsSmlTsDefaultName[TSDB_COL_NAME_LEN] = "_ts";










289



char tsSmlTagName[TSDB_COL_NAME_LEN] = "_tag_null";










290



char tsSmlChildTableName[TSDB_TABLE_NAME_LEN] = "";  // user defined child table name can be specified in tag value.










291



char tsSmlAutoChildTableNameDelimiter[TSDB_TABLE_NAME_LEN] = "";










292



// If set to empty system will generate table name using MD5 hash.










293



// true means that the name and order of cols in each line are the same(only for influx protocol)










294



// bool    tsSmlDataFormat = false;










295



// int32_t tsSmlBatchSize = 10000;










296












297



// checkpoint backup










298



char    tsSnodeAddress[TSDB_FQDN_LEN] = {0};










299



int32_t tsRsyncPort = 873;










300



#ifdef WINDOWS










301



char tsCheckpointBackupDir[PATH_MAX] = "C:\\TDengine\\data\\backup\\checkpoint\\";










302



#else










303



char    tsCheckpointBackupDir[PATH_MAX] = "/var/lib/taos/backup/checkpoint/";










304



#endif










305












306



// tmq










307



int32_t tmqMaxTopicNum = 20;










308



char    tmqWriteRefDB[TSDB_DB_NAME_LEN] = {0};










309



bool    tmqWriteCheckRef = false;










310












311



// query










312



int32_t tsQueryPolicy = 1;










313



bool    tsQueryTbNotExistAsEmpty = false;










314



int32_t tsQueryRspPolicy = 0;










315



int64_t tsQueryMaxConcurrentTables = 200;  // unit is TSDB_TABLE_NUM_UNIT










316



bool    tsEnableQueryHb = true;










317



bool    tsEnableScience = false;  // on taos-cli show float and doulbe with scientific notation if true










318



bool    tsSqlSecurityEnabled = false;










319



int32_t tsSqlSecurityWhitelistMode = 0;










320



bool    tsSqlSecurityStringCheck = true;










321



bool    tsSqlSecurityASTCheck = true;










322



#ifdef WINDOWS










323



char tsSqlSecurityRuleFile[PATH_MAX] = "C:\\TDengine\\data\\sql_rules.json";










324



#else










325



char tsSqlSecurityRuleFile[PATH_MAX] = "/var/lib/taos/sql_rules.json";










326



#endif










327



bool    tsWhitelistLearning = false;










328



int32_t tsWhitelistLearningPeriod = 7;










329



int32_t tsWhitelistLearningThreshold = 10;










330



int32_t tsQuerySmaOptimize = 0;










331



int32_t tsQueryRsmaTolerance = 1000;  // the tolerance time (ms) to judge from which level to query rsma data.










332



bool    tsQueryPlannerTrace = false;










333



int32_t tsQueryNodeChunkSize = 32 * 1024;










334



bool    tsQueryUseNodeAllocator = true;










335



bool    tsKeepColumnName = false;










336



int32_t tsRedirectPeriod = 10;










337



int32_t tsRedirectFactor = 2;










338



int32_t tsRedirectMaxPeriod = 1000;










339



int32_t tsMaxRetryWaitTime = 20000;










340



bool    tsUseAdapter = false;










341



int32_t tsMetaCacheMaxSize = -1;                   // MB










342



int32_t tsSlowLogThreshold = 10;                   // seconds










343



char    tsSlowLogExceptDb[TSDB_DB_NAME_LEN] = "";  // seconds










344



int32_t tsSlowLogScope = SLOW_LOG_TYPE_QUERY;










345



char   *tsSlowLogScopeString = "query";










346



int32_t tsSlowLogMaxLen = 4096;










347



int32_t tsTimeSeriesThreshold = 50;










348



bool    tsMultiResultFunctionStarReturnTags = false;










349












350



/*










351



 * denote if the server needs to compress response message at the application layer to client, including query rsp,










352



 * metricmeta rsp, and multi-meter query rsp message body. The client compress the submit message to server.










353



 *










354



 * 0: all data are compressed










355



 * -1: all data are not compressed










356



 * other values: if the message payload size is greater than the tsCompressMsgSize, the message will be compressed.










357



 */










358



int32_t tsCompressMsgSize = -1;










359












360



// count/hyperloglog function always return values in case of all NULL data or Empty data set.










361



int32_t tsCountAlwaysReturnValue = 1;










362












363



// 1 ms for sliding time, the value will changed in case of time precision changed










364



int32_t tsMinSlidingTime = 1;










365












366



// 1 database precision unit for interval time range, changed accordingly










367



int32_t tsMinIntervalTime = 1;










368












369



// maximum batch rows numbers imported from a single csv load










370



int32_t tsMaxInsertBatchRows = 1000000;










371












372



// maximum length of a SQL statement










373



int32_t tsMaxSQLLength = (4 * 1024 * 1024);  // 1MB










374












375



float   tsSelectivityRatio = 1.0;










376



int32_t tsTagFilterResCacheSize = 1024 * 10;










377



char    tsTagFilterCache = 0;










378



char    tsStableTagFilterCache = 0;










379



int64_t tsMetaEntryCacheSize = TSDB_DEFAULT_MECACHE_SIZE;










380



char    tsMetaEntryCache = 0;










381












382



int32_t tsBypassFlag = 0;










383












384



// the maximum allowed query buffer size during query processing for each data node.










385



// -1 no limit (default)










386



// 0  no query allowed, queries are disabled










387



// positive value (in MB)










388



int32_t tsQueryBufferSize = -1;










389



int64_t tsQueryBufferSizeBytes = -1;










390



int32_t tsCacheLazyLoadThreshold = 500;










391












392



int32_t  tsDiskCfgNum = 0;










393



SDiskCfg tsDiskCfg[TFS_MAX_DISKS] = {0};










394



int64_t  tsMinDiskFreeSize = TFS_MIN_DISK_FREE_SIZE;










395












396



/*










397



 * minimum scale for whole system, millisecond by default










398



 * for TSDB_TIME_PRECISION_MILLI: 60000L










399



 *     TSDB_TIME_PRECISION_MICRO: 60000000L










400



 *     TSDB_TIME_PRECISION_NANO:  60000000000L










401



 */










402



int64_t tsTickPerMin[] = {60000L, 60000000L, 60000000000L};










403



/*










404



 * millisecond by default










405



 * for TSDB_TIME_PRECISION_MILLI: 3600000L










406



 *     TSDB_TIME_PRECISION_MICRO: 3600000000L










407



 *     TSDB_TIME_PRECISION_NANO:  3600000000000L










408



 */










409



int64_t tsTickPerHour[] = {3600000L, 3600000000L, 3600000000000L};










410












411



int64_t tsSecTimes[] = {1e3L, 1e6L, 1e9L};  // for milli, micro, nano










412












413



// lossy compress 7










414



char tsLossyColumns[32] = "float|double";  // "float|double" means all float and double columns can be lossy compressed.










415



                                           // set empty can close lossy compress.










416



// below option can take effect when tsLossyColumns not empty










417



float    tsFPrecision = 1E-8;                   // float column precision










418



double   tsDPrecision = 1E-16;                  // double column precision










419



uint32_t tsMaxRange = 500;                      // max quantization intervals










420



uint32_t tsCurRange = 100;                      // current quantization intervals










421



bool     tsIfAdtFse = false;                    // ADT-FSE algorithom or original huffman algorithom










422



char     tsCompressor[32] = "ZSTD_COMPRESSOR";  // ZSTD_COMPRESSOR or GZIP_COMPRESSOR










423












424



// udf










425



#if defined(WINDOWS) || !defined(USE_UDF)










426



bool tsStartUdfd = false;










427



#else










428



bool    tsStartUdfd = true;










429



#endif










430












431



// wal










432



int64_t tsWalFsyncDataSizeLimit = (100 * 1024 * 1024L);










433



bool    tsWalForceRepair = 0;










434



bool    tsWalDeleteOnCorruption = false;










435












436



// ttl










437



bool    tsTtlChangeOnWrite = false;  // if true, ttl delete time changes on last write










438



int32_t tsTtlFlushThreshold = 100;   /* maximum number of dirty items in memory.










439



                                      * if -1, flush will not be triggered by write-ops










440



                                      */










441



int32_t tsTtlBatchDropNum = 10000;   // number of tables dropped per batch










442












443



// internal










444



bool    tsDiskIDCheckEnabled = false;










445



int32_t tsTransPullupInterval = 2;










446



int32_t tsCompactPullupInterval = 10;










447



int32_t tsScanPullupInterval = 10;










448



int32_t tsInstancePullupInterval = 5;










449



int32_t tsMqRebalanceInterval = 2;










450



int32_t tsTtlUnit = 86400;










451



int32_t tsTtlPushIntervalSec = 10;










452



int32_t tsTrimVDbIntervalSec = 60 * 60;  // interval of trimming db in all vgroups










453



int32_t tsQueryTrimIntervalSec = 10;     // interval of query trim in all vgroups










454



int32_t tsGrantHBInterval = 60;










455



int32_t tsUptimeInterval = 300;    // seconds










456



char    tsUdfdResFuncs[512] = "";  // udfd resident funcs that teardown when udfd exits










457



char    tsUdfdLdLibPath[512] = "";










458



bool    tsDisableStream = false;










459



int32_t tsStreamBufferSize = 0;       // MB










460



int64_t tsStreamBufferSizeBytes = 0;  // bytes










461



bool    tsStreamPerfLogEnabled = false;










462



bool    tsFilterScalarMode = false;










463












464



bool tsUpdateCacheBatch = true;










465












466



int32_t tsSsEnabled = 0;  // enable shared storage, 0: disabled, 1: enabled, 2: enabled with auto migration










467



char    tsSsAccessString[1024] = "";










468



int32_t tsSsAutoMigrateIntervalSec = 60 * 60;  // auto migrate interval of shared storage migration










469



int32_t tsSsBlockSize = -1;        // number of tsdb pages (4096). note: some related (but unused) code hasn't check the










470



                                   // negative value, which is a bug.










471



int32_t tsSsBlockCacheSize = 16;   // number of blocks










472



int32_t tsSsPageCacheSize = 4096;  // number of pages










473



int32_t tsSsUploadDelaySec = 60;










474



int32_t tsQuerySsMigrateIntervalSec = 10;  // interval of query ssmigrate in all vgroups










475












476



bool tsExperimental = true;










477












478



int32_t tsMaxTsmaNum = 10;










479



int32_t tsMaxTsmaCalcDelay = 600;










480



int64_t tsmaDataDeleteMark = 1000 * 60 * 60 * 24;  // in ms, default to 1d










481



void   *pTimezoneNameMap = NULL;










482












483



int32_t tsStreamNotifyMessageSize = 8 * 1024;  // KB, default 8MB










484



int32_t tsStreamNotifyFrameSize = 256;         // KB, default 256KB










485



int32_t tsStreamBatchRequestWaitMs = 5000;     // ms, default 5s










486












487



bool    tsShowFullCreateTableColumn = 0;  // 0: show full create table, 1: show only table name and db name










488












489



int64_t tsTimestampDeltaLimit = 900;  // s










490



int32_t tsRpcRecvLogThreshold = 3;        // in seconds, default 3s










491












492



int32_t sessionPerUser = -1;










493



int32_t sessionConnTime = -1;










494



int32_t sessionConnIdleTime = -1;










495



int32_t sessionMaxConcurrency = -1;










496



int32_t sessionMaxCallVnodeNum = -1;










497












498



bool    tsSessionControl = 1;










499



int32_t taosCheckCfgStrValueLen(const char *name, const char *value, int32_t len);










500












501



void taosSetSkipKeyCheckMode(void) { tsSkipKeyCheckMode = true; }




692,116✔





502












503



#define TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, pName) \










504



  if ((pItem = cfgGetItem(pCfg, pName)) == NULL) {  \










505



    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);           \










506



  }










507












508



#ifndef _STORAGE










509



int32_t taosSetTfsCfg(SConfig *pCfg) {










510



  SConfigItem *pItem = NULL;










511



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "dataDir");










512



  (void)memset(tsDataDir, 0, PATH_MAX);










513












514



  int32_t size = taosArrayGetSize(pItem->array);










515



  tsDiskCfgNum = 1;










516



  tstrncpy(tsDiskCfg[0].dir, pItem->str, TSDB_FILENAME_LEN);










517



  tsDiskCfg[0].level = 0;










518



  tsDiskCfg[0].primary = 1;










519



  tsDiskCfg[0].disable = 0;










520



  tstrncpy(tsDataDir, pItem->str, PATH_MAX);










521



  if (taosMulMkDir(tsDataDir) != 0) {










522



    int32_t code = TAOS_SYSTEM_ERROR(ERRNO);










523



    uError("failed to create dataDir:%s, since:%s", tsDataDir, tstrerror(code));










524



    TAOS_RETURN(code);










525



  }










526



  TAOS_RETURN(TSDB_CODE_SUCCESS);










527



}










528



#else










529



int32_t taosSetTfsCfg(SConfig *pCfg);










530



#endif










531












532



#ifndef _STORAGE










533



int32_t cfgUpdateTfsItemDisable(SConfig *pCfg, const char *value, void *pTfs) { return TSDB_CODE_INVALID_CFG; }










534



#else










535



int32_t cfgUpdateTfsItemDisable(SConfig *pCfg, const char *value, void *pTfs);










536



#endif










537












538



int32_t taosUpdateTfsItemDisable(SConfig *pCfg, const char *value, void *pTfs) {




3,585✔





539



  return cfgUpdateTfsItemDisable(pCfg, value, pTfs);




3,585✔





540



}










541












542



struct SConfig *taosGetCfg() { return tsCfg; }




353,716✔





543












544



static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *inputCfgDir, const char *envFile,




5,709,454✔





545



                           char *apolloUrl) {










546



  int32_t code = 0;




5,709,454✔





547



  char    cfgDir[PATH_MAX] = {0};




5,709,454✔





548



  char    cfgFile[PATH_MAX + 100] = {0};




5,709,454✔





549












550



  TAOS_CHECK_RETURN(taosExpandDir(inputCfgDir, cfgDir, PATH_MAX));




5,709,454✔





551



  int32_t pos = strlen(cfgDir);




5,709,454✔





552



  if (pos > 0) {




5,709,454✔





553



    pos -= 1;




5,709,322✔





554



  }










555



  char  lastC = cfgDir[pos];




5,709,454✔





556



  char *tdDirsep = TD_DIRSEP;




5,709,454✔





557



  if (lastC == '\\' || lastC == '/') {




5,709,454✔





558



    tdDirsep = "";




1,850,514✔





559



  }










560



  if (taosIsDir(cfgDir)) {




5,709,454✔





561



#ifdef CUS_PROMPT










562



    (void)snprintf(cfgFile, sizeof(cfgFile),




5,023,406✔





563



                   "%s"










564



                   "%s"










565



                   "%s.cfg",










566



                   cfgDir, tdDirsep, CUS_PROMPT);










567



#else










568



    (void)snprintf(cfgFile, sizeof(cfgFile),










569



                   "%s"










570



                   "%s"










571



                   "taos.cfg",










572



                   cfgDir, tdDirsep);










573



#endif










574



  } else {










575



    tstrncpy(cfgFile, cfgDir, sizeof(cfgDir));




686,048✔





576



  }










577












578



  if (apolloUrl != NULL && apolloUrl[0] == '\0') {




5,709,454✔





579



    (void)(cfgGetApollUrl(envCmd, envFile, apolloUrl));




1,341,222✔





580



  }










581












582



  if ((code = cfgLoad(pCfg, CFG_STYPE_APOLLO_URL, apolloUrl)) != 0) {




5,709,454✔





583



    (void)printf("failed to load from apollo url:%s since %s\n", apolloUrl, tstrerror(code));




16✔





584



    TAOS_RETURN(code);




16✔





585



  }










586












587



  if ((code = cfgLoad(pCfg, CFG_STYPE_CFG_FILE, cfgFile)) != 0) {




5,709,438✔





588



    (void)printf("failed to load from cfg file:%s since %s\n", cfgFile, tstrerror(code));




×







589



    TAOS_RETURN(code);




×







590



  }










591












592



  if ((code = cfgLoad(pCfg, CFG_STYPE_ENV_FILE, envFile)) != 0) {




5,709,438✔





593



    (void)printf("failed to load from env file:%s since %s\n", envFile, tstrerror(code));




16✔





594



    TAOS_RETURN(code);




16✔





595



  }










596












597



  if ((code = cfgLoad(pCfg, CFG_STYPE_ENV_VAR, NULL)) != 0) {




5,709,422✔





598



    (void)printf("failed to load from global env variables since %s\n", tstrerror(code));




×







599



    TAOS_RETURN(code);




×







600



  }










601












602



  if ((code = cfgLoad(pCfg, CFG_STYPE_ENV_CMD, envCmd)) != 0) {




5,709,422✔





603



    (void)printf("failed to load from cmd env variables since %s\n", tstrerror(code));




×







604



    TAOS_RETURN(code);




×







605



  }










606












607



  TAOS_RETURN(TSDB_CODE_SUCCESS);




5,709,422✔





608



}










609












610



int32_t taosAddClientLogCfg(SConfig *pCfg) {




5,709,454✔





611



  TAOS_CHECK_RETURN(cfgAddDir(pCfg, "configDir", configDir, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




5,709,454✔





612



  TAOS_CHECK_RETURN(cfgAddDir(pCfg, "scriptDir", configDir, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




5,709,454✔





613



  TAOS_CHECK_RETURN(cfgAddDir(pCfg, "logDir", tsLogDir, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




5,709,454✔





614



  TAOS_CHECK_RETURN(cfgAddFloat(pCfg, "minimalLogDirGB", 1.0f, 0.001f, 10000000, CFG_SCOPE_BOTH, CFG_DYN_CLIENT,




5,709,454✔





615



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










616



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfLogLines", tsNumOfLogLines, 1000, 2000000000, CFG_SCOPE_BOTH,




5,709,454✔





617



                                CFG_DYN_ENT_BOTH, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










618



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "asyncLog", tsAsyncLog, CFG_SCOPE_BOTH, CFG_DYN_BOTH, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




5,709,454✔





619



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "logKeepDays", 0, -365000, 365000, CFG_SCOPE_BOTH, CFG_DYN_ENT_BOTH,




5,709,454✔





620



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










621



  TAOS_CHECK_RETURN(




5,709,454✔





622



      cfgAddInt32(pCfg, "debugFlag", 0, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH, CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










623



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "simDebugFlag", simDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




5,709,454✔





624



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










625



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tmrDebugFlag", tmrDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




5,709,454✔





626



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










627



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "uDebugFlag", uDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




5,709,454✔





628



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










629



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "rpcDebugFlag", rpcDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




5,709,454✔





630



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










631



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "jniDebugFlag", jniDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




5,709,454✔





632



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










633



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "qDebugFlag", qDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




5,709,454✔





634



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










635



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "cDebugFlag", cDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




5,709,454✔





636



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










637



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tqClientDebugFlag", tqClientDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_SERVER,




5,709,454✔





638



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










639



  TAOS_RETURN(TSDB_CODE_SUCCESS);




5,709,454✔





640



}










641












642



static int32_t taosAddServerLogCfg(SConfig *pCfg) {




2,715,230✔





643



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "dDebugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





644



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










645



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "vDebugFlag", vDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





646



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










647



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "mDebugFlag", mDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





648



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










649



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "wDebugFlag", wDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





650



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










651



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "azDebugFlag", azDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





652



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










653



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tssDebugFlag", tssDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





654



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










655



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "sDebugFlag", sDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





656



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










657



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tsdbDebugFlag", tsdbDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





658



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










659



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tqDebugFlag", tqDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





660



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










661



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tqClientDebug", tqClientDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





662



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










663



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "fsDebugFlag", fsDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





664



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










665



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "udfDebugFlag", udfDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





666



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










667



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "smaDebugFlag", smaDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





668



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










669



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "idxDebugFlag", idxDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





670



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










671



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tdbDebugFlag", tdbDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





672



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










673



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "metaDebugFlag", metaDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





674



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










675



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "stDebugFlag", stDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





676



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










677



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "sndDebugFlag", sndDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





678



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










679



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "bseDebugFlag", bseDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





680



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










681



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "bndDebugFlag", bndDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





682



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










683



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "xndDebugFlag", xndDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,715,230✔





684



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










685



  TAOS_RETURN(TSDB_CODE_SUCCESS);




2,715,230✔





686



}










687












688



static int32_t taosAddClientCfg(SConfig *pCfg) {




2,854,749✔





689



  char    defaultFqdn[TSDB_FQDN_LEN] = {0};




2,854,749✔





690



  int32_t defaultServerPort = 6030;




2,854,749✔





691



  int32_t defaultMqttPort = 6083;




2,854,749✔





692



  int64_t cost = 0;




2,854,749✔





693



  if (taosGetFqdnWithTimeCost(defaultFqdn, &cost) != 0) {




2,854,749✔





694



    tstrncpy(defaultFqdn, "localhost", TSDB_FQDN_LEN);




×







695



  }










696



  if (cost >= 1000) {




2,854,749✔





697



    printf("warning: get fqdn cost %" PRId64 " ms\n", cost);




×







698



  }










699












700



  TAOS_CHECK_RETURN(




2,854,749✔





701



      cfgAddString(pCfg, "firstEp", "", CFG_SCOPE_BOTH, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










702



  TAOS_CHECK_RETURN(




2,854,749✔





703



      cfgAddString(pCfg, "secondEp", "", CFG_SCOPE_BOTH, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










704



  TAOS_CHECK_RETURN(




2,854,749✔





705



      cfgAddString(pCfg, "fqdn", defaultFqdn, CFG_SCOPE_SERVER, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










706



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "serverPort", defaultServerPort, 1, 65056, CFG_SCOPE_SERVER, CFG_DYN_CLIENT,




2,854,749✔





707



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










708



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "mqttPort", defaultMqttPort, 1, 65056, CFG_SCOPE_SERVER, CFG_DYN_CLIENT,




2,854,749✔





709



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










710



  TAOS_CHECK_RETURN(




2,854,749✔





711



      cfgAddDir(pCfg, "tempDir", tsTempDir, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










712



  TAOS_CHECK_RETURN(cfgAddFloat(pCfg, "minimalTmpDirGB", 1.0f, 0.001f, 10000000, CFG_SCOPE_BOTH, CFG_DYN_CLIENT,




2,854,749✔





713



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










714



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "shellActivityTimer", tsShellActivityTimer, 1, 120, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




2,854,749✔





715



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










716



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "compressMsgSize", tsCompressMsgSize, -1, 100000000, CFG_SCOPE_BOTH,




2,854,749✔





717



                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










718



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryPolicy", tsQueryPolicy, 1, 4, CFG_SCOPE_CLIENT, CFG_DYN_ENT_CLIENT,




2,854,749✔





719



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










720



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "queryTableNotExistAsEmpty", tsQueryTbNotExistAsEmpty, CFG_SCOPE_CLIENT,




2,854,749✔





721



                               CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










722



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableQueryHb", tsEnableQueryHb, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





723



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










724



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableScience", tsEnableScience, CFG_SCOPE_CLIENT, CFG_DYN_NONE,




2,854,749✔





725



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










726



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "querySmaOptimize", tsQuerySmaOptimize, 0, 1, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





727



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










728



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "queryPlannerTrace", tsQueryPlannerTrace, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





729



                               CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










730



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryNodeChunkSize", tsQueryNodeChunkSize, 1024, 128 * 1024, CFG_SCOPE_CLIENT,




2,854,749✔





731



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










732



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "queryUseNodeAllocator", tsQueryUseNodeAllocator, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





733



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










734



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "keepColumnName", tsKeepColumnName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





735



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










736



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlChildTableName", tsSmlChildTableName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





737



                                 CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










738



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlAutoChildTableNameDelimiter", tsSmlAutoChildTableNameDelimiter,




2,854,749✔





739



                                 CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










740



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlTagName", tsSmlTagName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL,




2,854,749✔





741



                                 CFG_PRIV_SYSTEM));










742



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlTsDefaultName", tsSmlTsDefaultName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





743



                                 CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










744



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "smlDot2Underline", tsSmlDot2Underline, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





745



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










746












747



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "minSlidingTime", tsMinSlidingTime, 1, 1000000, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





748



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










749



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "minIntervalTime", tsMinIntervalTime, 1, 1000000, CFG_SCOPE_CLIENT,




2,854,749✔





750



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










751



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxInsertBatchRows", tsMaxInsertBatchRows, 1, INT32_MAX, CFG_SCOPE_CLIENT,




2,854,749✔





752



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM) != 0);










753



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxRetryWaitTime", tsMaxRetryWaitTime, 3000, 86400000, CFG_SCOPE_SERVER,




2,854,749✔





754



                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










755



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "useAdapter", tsUseAdapter, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL,




2,854,749✔





756



                               CFG_PRIV_SYSTEM));










757



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "crashReporting", tsEnableCrashReport, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




2,854,749✔





758



                               CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










759



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "queryMaxConcurrentTables", tsQueryMaxConcurrentTables, INT64_MIN, INT64_MAX,




2,854,749✔





760



                                CFG_SCOPE_CLIENT, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










761



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "metaCacheMaxSize", tsMetaCacheMaxSize, -1, INT32_MAX, CFG_SCOPE_CLIENT,




2,854,749✔





762



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










763



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "randErrorChance", tsRandErrChance, 0, 10000, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




2,854,749✔





764



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_DEBUG));










765



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "randErrorDivisor", tsRandErrDivisor, 1, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




2,854,749✔





766



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_DEBUG));










767



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "randErrorScope", tsRandErrScope, 0, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




2,854,749✔





768



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_DEBUG));










769



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "safetyCheckLevel", tsSafetyCheckLevel, 0, 5, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




2,854,749✔





770



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










771



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "bypassFlag", tsBypassFlag, 0, INT32_MAX, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




2,854,749✔





772



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










773



  tsNumOfRpcThreads = tsNumOfCores / 2;




2,854,749✔





774



  tsNumOfRpcThreads = TRANGE(tsNumOfRpcThreads, 2, TSDB_MAX_RPC_THREADS);




2,854,749✔





775



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfRpcThreads", tsNumOfRpcThreads, 1, 1024, CFG_SCOPE_BOTH, CFG_DYN_BOTH_LAZY,




2,854,749✔





776



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










777












778



  tsNumOfRpcSessions = TRANGE(tsNumOfRpcSessions, 100, 100000);




2,854,749✔





779



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfRpcSessions", tsNumOfRpcSessions, 1, 100000, CFG_SCOPE_BOTH,




2,854,749✔





780



                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










781



  tsShareConnLimit = TRANGE(tsShareConnLimit, 1, 512);




2,854,749✔





782



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "shareConnLimit", tsShareConnLimit, 1, 512, CFG_SCOPE_BOTH, CFG_DYN_BOTH_LAZY,




2,854,749✔





783



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










784












785



  tsReadTimeout = TRANGE(tsReadTimeout, 64, 24 * 3600 * 7);




2,854,749✔





786



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "readTimeout", tsReadTimeout, 64, 24 * 3600 * 7, CFG_SCOPE_BOTH,




2,854,749✔





787



                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










788



  tsTimeToGetAvailableConn = TRANGE(tsTimeToGetAvailableConn, 20, 10000000);




2,854,749✔





789



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "timeToGetAvailableConn", tsTimeToGetAvailableConn, 20, 1000000, CFG_SCOPE_BOTH,




2,854,749✔





790



                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










791



  tsNumOfTaskQueueThreads = tsNumOfCores * 2;




2,854,749✔





792



  tsNumOfTaskQueueThreads = TMAX(tsNumOfTaskQueueThreads, 16);




2,854,749✔





793












794



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfTaskQueueThreads", tsNumOfTaskQueueThreads, 4, 1024, CFG_SCOPE_CLIENT,




2,854,749✔





795



                                CFG_DYN_CLIENT_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










796



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "experimental", tsExperimental, CFG_SCOPE_BOTH, CFG_DYN_BOTH_LAZY,




2,854,749✔





797



                               CFG_CATEGORY_GLOBAL, CFG_PRIV_DEBUG));










798



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "multiResultFunctionStarReturnTags", tsMultiResultFunctionStarReturnTags,




2,854,749✔





799



                               CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










800



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "countAlwaysReturnValue", tsCountAlwaysReturnValue, 0, 1, CFG_SCOPE_BOTH,




2,854,749✔





801



                                CFG_DYN_BOTH, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










802



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxTsmaCalcDelay", tsMaxTsmaCalcDelay, 600, 86400, CFG_SCOPE_CLIENT,




2,854,749✔





803



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










804



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tsmaDataDeleteMark", tsmaDataDeleteMark, 60 * 60 * 1000, INT64_MAX,




2,854,749✔





805



                                CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










806












807



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "compareAsStrInGreatest", tsCompareAsStrInGreatest, CFG_SCOPE_CLIENT,




2,854,749✔





808



                               CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










809












810



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "showFullCreateTableColumn", tsShowFullCreateTableColumn, CFG_SCOPE_CLIENT,




2,854,749✔





811



                               CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










812












813



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "sessionPerUser", sessionPerUser, -1, INT32_MAX, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





814



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










815



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "sessionConnTime", sessionConnTime, -1, INT32_MAX, CFG_SCOPE_CLIENT,




2,854,749✔





816



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










817



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "sessionConnIdleTime", sessionConnIdleTime, -1, INT32_MAX, CFG_SCOPE_CLIENT,




2,854,749✔





818



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










819












820



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "sessionMaxConcurrency", sessionMaxConcurrency, -1, INT32_MAX, CFG_SCOPE_CLIENT,




2,854,749✔





821



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










822












823



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "sessionMaxCallVnodeNum", sessionMaxCallVnodeNum, -1, INT32_MAX, CFG_SCOPE_CLIENT,




2,854,749✔





824



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










825












826



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxSQLLength", tsMaxSQLLength, 1024 * 1024, 64 * 1024 * 1024, CFG_SCOPE_CLIENT,




2,854,749✔





827



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










828












829



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "sessionControl", tsSessionControl, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT_LAZY,




2,854,749✔





830



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










831












832



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "tmqWriteRefDB", tmqWriteRefDB, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL,




2,854,749✔





833



                                 CFG_PRIV_SYSTEM));










834












835



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "tmqWriteCheckRef", tmqWriteCheckRef, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





836



                               CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










837



  // sql fire wall configuration










838



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "sqlSecurity", tsSqlSecurityEnabled, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





839



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










840



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "sqlSecurityWhitelistMode", tsSqlSecurityWhitelistMode, 0, 3, CFG_SCOPE_CLIENT,




2,854,749✔





841



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










842



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "sqlSecurityStringCheck", tsSqlSecurityStringCheck, CFG_SCOPE_CLIENT,




2,854,749✔





843



                               CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










844



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "sqlSecurityASTCheck", tsSqlSecurityASTCheck, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





845



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










846



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "sqlSecurityRuleFile", tsSqlSecurityRuleFile, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





847



                                 CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










848



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "whitelistLearning", tsWhitelistLearning, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT,




2,854,749✔





849



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










850



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "whitelistLearningPeriod", tsWhitelistLearningPeriod, 1, 365, CFG_SCOPE_CLIENT,




2,854,749✔





851



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










852



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "whitelistLearningThreshold", tsWhitelistLearningThreshold, 1, 10000,




2,854,749✔





853



                                CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










854



  TAOS_RETURN(TSDB_CODE_SUCCESS);




2,854,749✔





855



}










856












857



static int32_t taosAddSystemCfg(SConfig *pCfg) {




2,854,749✔





858



  SysNameInfo info = taosGetSysNameInfo();




2,854,749✔





859












860



  TAOS_CHECK_RETURN(cfgAddTimezone(pCfg, "timezone", tsTimezoneStr, CFG_SCOPE_BOTH, CFG_DYN_BOTH, CFG_CATEGORY_GLOBAL));




2,854,749✔





861



  TAOS_CHECK_RETURN(cfgAddLocale(pCfg, "locale", tsLocale, CFG_SCOPE_BOTH, CFG_DYN_BOTH, CFG_CATEGORY_GLOBAL));




2,854,749✔





862



  TAOS_CHECK_RETURN(cfgAddCharset(pCfg, "charset", tsCharset, CFG_SCOPE_BOTH, CFG_DYN_BOTH, CFG_CATEGORY_GLOBAL));




2,854,749✔





863



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableCoreFile", tsEnableCoreFile, CFG_SCOPE_BOTH, CFG_DYN_BOTH_LAZY,




2,854,749✔





864



                               CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










865



  TAOS_CHECK_RETURN(cfgAddFloat(pCfg, "numOfCores", tsNumOfCores, 1, 100000, CFG_SCOPE_BOTH, CFG_DYN_BOTH_LAZY,




2,854,749✔





866



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










867












868



  TAOS_CHECK_RETURN(




2,854,749✔





869



      cfgAddBool(pCfg, "simdEnable", tsSIMDEnable, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










870



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "AVX512Enable", tsAVX512Enable, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL,




2,854,749✔





871



                               CFG_PRIV_SYSTEM));










872



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "tagFilterCache", tsTagFilterCache, CFG_SCOPE_BOTH, CFG_DYN_BOTH,




2,854,749✔





873



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










874



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "stableTagFilterCache", tsStableTagFilterCache, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




2,854,749✔





875



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










876



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "metaEntryCache", tsMetaEntryCache, CFG_SCOPE_SERVER, CFG_DYN_NONE,




2,854,749✔





877



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










878



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "metaEntryCacheSize", tsMetaEntryCacheSize, TSDB_MIN_MECACHE_SIZE,




2,854,749✔





879



                                TSDB_MAX_MECACHE_SIZE, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER, CFG_CATEGORY_LOCAL,










880



                                CFG_PRIV_SYSTEM));










881












882



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "openMax", tsOpenMax, 0, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_NONE,




2,854,749✔





883



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










884



#if !defined(_ALPINE)










885



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "streamMax", tsStreamMax, 0, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_NONE,




2,854,749✔





886



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










887



#endif










888



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "pageSizeKB", tsPageSizeKB, 0, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_NONE,




2,854,749✔





889



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










890



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "totalMemoryKB", tsTotalMemoryKB, 0, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_NONE,




2,854,749✔





891



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










892



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "os sysname", info.sysname, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL,




2,854,749✔





893



                                 CFG_PRIV_SYSTEM));










894



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "os nodename", info.nodename, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL,




2,854,749✔





895



                                 CFG_PRIV_SYSTEM));










896



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "os release", info.release, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL,




2,854,749✔





897



                                 CFG_PRIV_SYSTEM));










898



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "os version", info.version, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL,




2,854,749✔





899



                                 CFG_PRIV_SYSTEM));










900



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "os machine", info.machine, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL,




2,854,749✔





901



                                 CFG_PRIV_SYSTEM));










902












903



  TAOS_CHECK_RETURN(




2,854,749✔





904



      cfgAddString(pCfg, "version", td_version, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










905



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "compatible_version", td_compatible_version, CFG_SCOPE_BOTH, CFG_DYN_NONE,




2,854,749✔





906



                                 CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










907



  TAOS_CHECK_RETURN(




2,854,749✔





908



      cfgAddString(pCfg, "gitinfo", td_gitinfo, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










909



  TAOS_CHECK_RETURN(




2,854,749✔





910



      cfgAddString(pCfg, "buildinfo", td_buildinfo, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










911












912



  TAOS_CHECK_RETURN(




2,854,749✔





913



      cfgAddBool(pCfg, "enableIpv6", tsEnableIpv6, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










914












915



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "tlsCaPath", tsTLSCaPath, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_GLOBAL,




2,854,749✔





916



                                 CFG_PRIV_SECURITY));










917



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "tlsSvrCertPath", tsTLSSvrCertPath, CFG_SCOPE_BOTH, CFG_DYN_NONE,




2,854,749✔





918



                                 CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));










919



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "tlsSvrKeyPath", tsTLSSvrKeyPath, CFG_SCOPE_BOTH, CFG_DYN_NONE,




2,854,749✔





920



                                 CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));










921



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "tlsCliCertPath", tsTLSCliCertPath, CFG_SCOPE_BOTH, CFG_DYN_NONE,




2,854,749✔





922



                                 CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));










923



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "tlsCliKeyPath", tsTLSCliKeyPath, CFG_SCOPE_BOTH, CFG_DYN_NONE,




2,854,749✔





924



                                 CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));










925












926



  TAOS_CHECK_RETURN(




2,854,749✔





927



      cfgAddBool(pCfg, "enableTLS", tsEnableTLS, CFG_SCOPE_BOTH, CFG_DYN_BOTH, CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));










928












929



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableSasl", tsEnableSasl, CFG_SCOPE_BOTH, CFG_DYN_BOTH, CFG_CATEGORY_GLOBAL,




2,854,749✔





930



                               CFG_PRIV_SECURITY));










931



  TAOS_RETURN(TSDB_CODE_SUCCESS);




2,854,749✔





932



}










933












934



static int32_t taosAddServerCfg(SConfig *pCfg) {




1,357,599✔





935



  tsNumOfCommitThreads = tsNumOfCores / 2;




1,357,599✔





936



  tsNumOfCommitThreads = TRANGE(tsNumOfCommitThreads, 2, 4);




1,357,599✔





937












938



  tsNumOfSupportVnodes = tsNumOfCores * 2 + 5;




1,357,599✔





939



  tsNumOfSupportVnodes = TMAX(tsNumOfSupportVnodes, 2);




1,357,599✔





940












941



  tsNumOfMnodeReadThreads = tsNumOfCores / 8;




1,357,599✔





942



  tsNumOfMnodeReadThreads = TRANGE(tsNumOfMnodeReadThreads, 1, 4);




1,357,599✔





943












944



  tsNumOfVnodeQueryThreads = tsNumOfCores * 2;




1,357,599✔





945



  tsNumOfVnodeQueryThreads = TMAX(tsNumOfVnodeQueryThreads, 16);




1,357,599✔





946












947



  tsNumOfVnodeFetchThreads = tsNumOfCores / 4;




1,357,599✔





948



  tsNumOfVnodeFetchThreads = TMAX(tsNumOfVnodeFetchThreads, 4);




1,357,599✔





949












950



  tsNumOfVnodeRsmaThreads = tsNumOfCores / 4;




1,357,599✔





951



  tsNumOfVnodeRsmaThreads = TMAX(tsNumOfVnodeRsmaThreads, 4);




1,357,599✔





952












953



  tsNumOfQnodeQueryThreads = tsNumOfCores * 2;




1,357,599✔





954



  tsNumOfQnodeQueryThreads = TMAX(tsNumOfQnodeQueryThreads, 16);




1,357,599✔





955












956



  tsNumOfMnodeStreamMgmtThreads = tsNumOfCores / 4;




1,357,599✔





957



  tsNumOfMnodeStreamMgmtThreads = TRANGE(tsNumOfMnodeStreamMgmtThreads, 2, 5);




1,357,599✔





958












959



  tsNumOfStreamMgmtThreads = tsNumOfCores / 8;




1,357,599✔





960



  tsNumOfStreamMgmtThreads = TRANGE(tsNumOfStreamMgmtThreads, 2, 5);




1,357,599✔





961












962



  tsNumOfVnodeStreamReaderThreads = tsNumOfCores / 2;




1,357,599✔





963



  tsNumOfVnodeStreamReaderThreads = TMAX(tsNumOfVnodeStreamReaderThreads, 2);




1,357,599✔





964












965



  tsNumOfStreamTriggerThreads = tsNumOfCores;




1,357,599✔





966



  tsNumOfStreamTriggerThreads = TMAX(tsNumOfStreamTriggerThreads, 4);




1,357,599✔





967












968



  tsNumOfStreamRunnerThreads = tsNumOfCores;




1,357,599✔





969



  tsNumOfStreamRunnerThreads = TMAX(tsNumOfStreamRunnerThreads, 4);




1,357,599✔





970












971



  tsQueueMemoryAllowed = tsTotalMemoryKB * 1024 * RPC_MEMORY_USAGE_RATIO * QUEUE_MEMORY_USAGE_RATIO;




1,357,599✔





972



  tsQueueMemoryAllowed = TRANGE(tsQueueMemoryAllowed, TSDB_MAX_MSG_SIZE * QUEUE_MEMORY_USAGE_RATIO * 10LL,




1,357,599✔





973



                                TSDB_MAX_MSG_SIZE * QUEUE_MEMORY_USAGE_RATIO * 10000LL);










974












975



  tsApplyMemoryAllowed = tsTotalMemoryKB * 1024 * RPC_MEMORY_USAGE_RATIO * (1 - QUEUE_MEMORY_USAGE_RATIO);




1,357,599✔





976



  tsApplyMemoryAllowed = TRANGE(tsApplyMemoryAllowed, TSDB_MAX_MSG_SIZE * (1 - QUEUE_MEMORY_USAGE_RATIO) * 10LL,




1,357,599✔





977



                                TSDB_MAX_MSG_SIZE * (1 - QUEUE_MEMORY_USAGE_RATIO) * 10000LL);










978












979



  tsLogBufferMemoryAllowed = tsTotalMemoryKB * 1024 * 0.1;




1,357,599✔





980



  tsLogBufferMemoryAllowed = TRANGE(tsLogBufferMemoryAllowed, TSDB_MAX_MSG_SIZE * 10LL, TSDB_MAX_MSG_SIZE * 10000LL);




1,357,599✔





981












982



  tsStreamBufferSize = tsTotalMemoryKB / 1024 * 0.3;




1,357,599✔





983



  tsStreamBufferSizeBytes = tsStreamBufferSize * 1048576L;




1,357,599✔





984












985



  // clang-format off










986



  TAOS_CHECK_RETURN(cfgAddDir(pCfg, "dataDir", tsDataDir, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





987



  TAOS_CHECK_RETURN(cfgAddFloat(pCfg, "minimalDataDirGB", 2.0f, 0.001f, 10000000, CFG_SCOPE_SERVER, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





988



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "supportVnodes", tsNumOfSupportVnodes, 0, 1024, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





989












990



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "encryptAlgorithm", tsEncryptAlgorithm, CFG_SCOPE_SERVER, CFG_DYN_NONE, CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));




1,357,599✔





991



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "encryptScope", tsEncryptScope, CFG_SCOPE_SERVER, CFG_DYN_NONE,CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));




1,357,599✔





992



  TAOS_CHECK_RETURN(cfgAddDir(pCfg, "encryptExtDir", tsEncryptExtDir, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL, CFG_PRIV_SECURITY));




1,357,599✔





993



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableStrongPassword", tsEnableStrongPassword, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));




1,357,599✔





994



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableAdvancedSecurity", tsEnableAdvancedSecurity, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));




1,357,599✔





995



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableGrantLegacySyntax", tsEnableGrantLegacySyntax, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));




1,357,599✔





996



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "encryptPassAlgorithm", tsEncryptPassAlgorithm, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY, CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));




1,357,599✔





997












998



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "statusInterval", tsStatusInterval, 1, 30, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





999



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "metricsInterval", tsMetricsInterval, 1, 3600, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1000



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "enableMetrics", tsEnableMetrics, 0, 1, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1001



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "metricsLevel", tsMetricsLevel, 0, 1, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1002



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxShellConns", tsMaxShellConns, 10, 50000000, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1003



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "statusIntervalMs", tsStatusIntervalMs, 50, 30000, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1004



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "statusSRTimeoutMs", tsStatusSRTimeoutMs, 50, 30000, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1005



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "statusTimeoutMs", tsStatusTimeoutMs, 50, 30000, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1006












1007



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryBufferSize", tsQueryBufferSize, -1, 500000000000, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1008



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryRspPolicy", tsQueryRspPolicy, 0, 1, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1009



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfCommitThreads", tsNumOfCommitThreads, 1, 1024, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1010



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfCompactThreads", tsNumOfCompactThreads, 1, 16, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1011



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "secureEraseMode", tsSecureEraseMode, 0, 1, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1012



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "retentionSpeedLimitMB", tsRetentionSpeedLimitMB, 0, 1024, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1013



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "queryUseMemoryPool", tsQueryUseMemoryPool, CFG_SCOPE_SERVER, CFG_DYN_BOTH_LAZY,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM) != 0);




1,357,599✔





1014



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "memPoolFullFunc", tsMemPoolFullFunc, CFG_SCOPE_SERVER, CFG_DYN_NONE,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM) != 0);




1,357,599✔





1015



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "singleQueryMaxMemorySize", tsSingleQueryMaxMemorySize, 0, 1000000000, CFG_SCOPE_SERVER, CFG_DYN_BOTH_LAZY,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM) != 0);




1,357,599✔





1016



  //TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryBufferPoolSize", tsQueryBufferPoolSize, 0, 1000000000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER) != 0);










1017



  TAOS_CHECK_RETURN(cfgAddInt32Ex(pCfg, "minReservedMemorySize", 0, 1024, 1000000000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM) != 0);




1,357,599✔





1018



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryNoFetchTimeoutSec", tsQueryNoFetchTimeoutSec, 60, 1000000000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM) != 0);




1,357,599✔





1019












1020



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfMnodeReadThreads", tsNumOfMnodeReadThreads, 1, 1024, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1021



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfVnodeQueryThreads", tsNumOfVnodeQueryThreads, 1, 1024, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1022



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfVnodeFetchThreads", tsNumOfVnodeFetchThreads, 4, 1024, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1023












1024



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfVnodeRsmaThreads", tsNumOfVnodeRsmaThreads, 1, 1024, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1025



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfQnodeQueryThreads", tsNumOfQnodeQueryThreads, 1, 1024, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1026












1027












1028



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfMnodeStreamMgmtThreads", tsNumOfMnodeStreamMgmtThreads, 2, 5, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1029



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfStreamMgmtThreads", tsNumOfStreamMgmtThreads, 2, 5, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1030



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfVnodeStreamReaderThreads", tsNumOfVnodeStreamReaderThreads, 2, INT32_MAX, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1031



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfStreamTriggerThreads", tsNumOfStreamTriggerThreads, 4, INT32_MAX, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1032



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfStreamRunnerThreads", tsNumOfStreamRunnerThreads, 4, INT32_MAX, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1033



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "rpcQueueMemoryAllowed", tsQueueMemoryAllowed, TSDB_MAX_MSG_SIZE * RPC_MEMORY_USAGE_RATIO * 10L, INT64_MAX, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1034



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncElectInterval", tsElectInterval, 10, 1000 * 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1035



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncHeartbeatInterval", tsHeartbeatInterval, 10, 1000 * 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1036



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncVnodeElectIntervalMs", tsVnodeElectIntervalMs, 10, 1000 * 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1037



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncVnodeHeartbeatIntervalMs", tsVnodeHeartbeatIntervalMs, 10, 1000 * 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1038



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncMnodeElectIntervalMs", tsMnodeElectIntervalMs, 10, 1000 * 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1039



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncMnodeHeartbeatIntervalMs", tsMnodeHeartbeatIntervalMs, 10, 1000 * 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1040



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncHeartbeatTimeout", tsHeartbeatTimeout, 10, 1000 * 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1041



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncSnapReplMaxWaitN", tsSnapReplMaxWaitN, 16, (TSDB_SYNC_SNAP_BUFFER_SIZE >> 2), CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1042



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "syncLogBufferMemoryAllowed", tsLogBufferMemoryAllowed, TSDB_MAX_MSG_SIZE * 10L, INT64_MAX, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1043



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "syncApplyQueueSize", tsSyncApplyQueueSize, 32, 2048, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1044



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncRoutineReportInterval", tsRoutineReportInterval, 5, 600, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1045



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "syncLogHeartbeat", tsSyncLogHeartbeat, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1046



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "walDeleteOnCorruption", tsWalDeleteOnCorruption, CFG_SCOPE_SERVER, CFG_DYN_NONE,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1047












1048



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncTimeout", tsSyncTimeout, 0, 60 * 24 * 2 * 1000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1049












1050



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "arbHeartBeatIntervalSec", tsArbHeartBeatIntervalSec, 1, 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1051



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "arbCheckSyncIntervalSec", tsArbCheckSyncIntervalSec, 1, 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1052



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "arbSetAssignedTimeoutSec", tsArbSetAssignedTimeoutSec, 1, 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1053



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "arbHeartBeatIntervalMs", tsArbHeartBeatIntervalMs, 100, 60 * 24 * 2 * 1000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1054



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "arbCheckSyncIntervalMs", tsArbCheckSyncIntervalMs, 100, 60 * 24 * 2 * 1000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1055



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "arbSetAssignedTimeoutMs", tsArbSetAssignedTimeoutMs, 100, 60 * 24 * 2 * 1000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1056












1057



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "mndSdbWriteDelta", tsMndSdbWriteDelta, 20, 10000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL,CFG_PRIV_SYSTEM));




1,357,599✔





1058



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "mndLogRetention", tsMndLogRetention, 500, 10000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL,CFG_PRIV_SYSTEM));




1,357,599✔





1059



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "skipGrant", tsMndSkipGrant, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL,CFG_PRIV_SECURITY));




1,357,599✔





1060












1061



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "monitor", tsEnableMonitor, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1062



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "monitorInterval", tsMonitorInterval, 1, 86400, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1063












1064



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "slowLogThreshold", tsSlowLogThreshold, 1, INT32_MAX, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1065



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "slowLogMaxLen", tsSlowLogMaxLen, 1, 16384, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1066



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "slowLogScope", tsSlowLogScopeString, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1067



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "slowLogExceptDb", tsSlowLogExceptDb, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1068












1069



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "monitorFqdn", tsMonitorFqdn, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1070



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "monitorPort", tsMonitorPort, 1, 65056, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1071



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "monitorMaxLogs", tsMonitorMaxLogs, 1, 1000000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1072



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "monitorComp", tsMonitorComp, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1073



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "monitorLogProtocol", tsMonitorLogProtocol, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1074



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "monitorForceV2", tsMonitorForceV2, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1075












1076



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "audit", tsEnableAudit, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_AUDIT));




1,357,599✔





1077



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableAuditDelete", tsEnableAuditDelete, CFG_SCOPE_SERVER, CFG_DYN_NONE,CFG_CATEGORY_GLOBAL, CFG_PRIV_AUDIT));




1,357,599✔





1078



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableAuditSelect", tsEnableAuditSelect, CFG_SCOPE_SERVER, CFG_DYN_NONE,CFG_CATEGORY_GLOBAL, CFG_PRIV_AUDIT));




1,357,599✔





1079



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableAuditInsert", tsEnableAuditInsert, CFG_SCOPE_SERVER, CFG_DYN_NONE,CFG_CATEGORY_GLOBAL, CFG_PRIV_AUDIT));




1,357,599✔





1080



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "auditLevel", tsAuditLevel, 0, 5, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_AUDIT));




1,357,599✔





1081



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "auditCreateTable", tsEnableAuditCreateTable, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_AUDIT));




1,357,599✔





1082



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "auditInterval", tsAuditInterval, 500, 200000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_AUDIT));




1,357,599✔





1083



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "auditHttps", tsAuditHttps, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_AUDIT));




1,357,599✔





1084



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "auditUseToken", tsAuditUseToken, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_AUDIT));




1,357,599✔





1085



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "auditSaveInSelf", tsAuditSaveInSelf, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER, CFG_CATEGORY_GLOBAL, CFG_PRIV_AUDIT));




1,357,599✔





1086



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "telemetryReporting", tsEnableTelem, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1087



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "telemetryInterval", tsTelemInterval, 1, 200000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1088



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "telemetryServer", tsTelemServer, CFG_SCOPE_SERVER, CFG_DYN_BOTH,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1089



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "telemetryPort", tsTelemPort, 1, 65056, CFG_SCOPE_SERVER, CFG_DYN_NONE,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1090












1091



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "rsyncPort", tsRsyncPort, 1, 65535, CFG_SCOPE_SERVER, CFG_DYN_NONE,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1092



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "snodeAddress", tsSnodeAddress, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1093



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "checkpointBackupDir", tsCheckpointBackupDir, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1094












1095



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tmqMaxTopicNum", tmqMaxTopicNum, 1, 10000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1096












1097



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxTsmaNum", tsMaxTsmaNum, 0, 10, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1098



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "diskIDCheckEnabled", tsDiskIDCheckEnabled,  CFG_SCOPE_SERVER, CFG_DYN_NONE,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1099



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "transPullupInterval", tsTransPullupInterval, 1, 10000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1100



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "compactPullupInterval", tsCompactPullupInterval, 1, 10000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1101



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "mqRebalanceInterval", tsMqRebalanceInterval, 1, 10000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1102












1103



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "ttlUnit", tsTtlUnit, 1, 86400 * 365, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1104



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "ttlPushInterval", tsTtlPushIntervalSec, 1, 100000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1105



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "ttlBatchDropNum", tsTtlBatchDropNum, 0, INT32_MAX, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1106



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "ttlChangeOnWrite", tsTtlChangeOnWrite, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1107



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "ttlFlushThreshold", tsTtlFlushThreshold, -1, 1000000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1108



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "trimVDbIntervalSec", tsTrimVDbIntervalSec, 1, 100000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1109



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryTrimIntervalSec", tsQueryTrimIntervalSec, 1, 100000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1110



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "querySsMigrateIntervalSec", tsQuerySsMigrateIntervalSec, 1, 100000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1111



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "uptimeInterval", tsUptimeInterval, 1, 100000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1112



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryRsmaTolerance", tsQueryRsmaTolerance, 0, 900000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1113



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "timeseriesThreshold", tsTimeSeriesThreshold, 0, 2000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1114












1115



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "walFsyncDataSizeLimit", tsWalFsyncDataSizeLimit, 100 * 1024 * 1024, INT64_MAX, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1116



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "walForceRepair", tsWalForceRepair, CFG_SCOPE_SERVER, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1117












1118



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "udf", tsStartUdfd, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1119



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "udfdResFuncs", tsUdfdResFuncs, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1120



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "udfdLdLibPath", tsUdfdLdLibPath, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1121



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "cacheLazyLoadThreshold", tsCacheLazyLoadThreshold, 0, 100000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1122












1123



  TAOS_CHECK_RETURN(cfgAddFloat(pCfg, "fPrecision", tsFPrecision, 0.0f, 100000.0f, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1124



  TAOS_CHECK_RETURN(cfgAddFloat(pCfg, "dPrecision", tsDPrecision, 0.0f, 1000000.0f, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1125



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxRange", tsMaxRange, 0, 65536, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1126



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "curRange", tsCurRange, 0, 65536, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1127



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "ifAdtFse", tsIfAdtFse, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1128



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "compressor", tsCompressor, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1129



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "disableStream", tsDisableStream, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL,CFG_PRIV_SYSTEM));




1,357,599✔





1130



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "streamBufferSize", tsStreamBufferSize, 128, INT32_MAX, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL,CFG_PRIV_SYSTEM));




1,357,599✔





1131



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "ssEnabled", tsSsEnabled, 0, 2, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1132



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "ssAccessString", tsSsAccessString, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1133



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "ssAutoMigrateIntervalSec", tsSsAutoMigrateIntervalSec, 600, 100000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1134



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "ssPageCacheSize", tsSsPageCacheSize, 4, 1024 * 1024 * 1024, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER_LAZY,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1135



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "ssUploadDelaySec", tsSsUploadDelaySec, 1, 60 * 60 * 24 * 30, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1136












1137












1138



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "filterScalarMode", tsFilterScalarMode, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL,CFG_PRIV_SYSTEM));




1,357,599✔





1139



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "pqSortMemThreshold", tsPQSortMemThreshold, 1, 10240, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL,CFG_PRIV_SYSTEM));




1,357,599✔





1140



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "rpcRecvLogThreshold", tsRpcRecvLogThreshold, 1, 1024 * 1024, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));




1,357,599✔





1141



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "minDiskFreeSize", tsMinDiskFreeSize, TFS_MIN_DISK_FREE_SIZE, TFS_MIN_DISK_FREE_SIZE_MAX, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER,CFG_CATEGORY_LOCAL,CFG_PRIV_SYSTEM));




1,357,599✔





1142



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableWhiteList", tsEnableWhiteList, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL,CFG_PRIV_SYSTEM));




1,357,599✔





1143



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "forceKillTrans", tsForceKillTrans, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_GLOBAL,CFG_PRIV_SYSTEM));




1,357,599✔





1144












1145



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "streamNotifyMessageSize", tsStreamNotifyMessageSize, 8, 1024 * 1024, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL,CFG_PRIV_SYSTEM));




1,357,599✔





1146



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "streamNotifyFrameSize", tsStreamNotifyFrameSize, 8, 1024 * 1024, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL,CFG_PRIV_SYSTEM));




1,357,599✔





1147



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "streamBatchRequestWaitMs", tsStreamBatchRequestWaitMs, 0, 30 * 60 * 1000, CFG_SCOPE_SERVER, CFG_DYN_SERVER_LAZY,CFG_CATEGORY_LOCAL,CFG_PRIV_SYSTEM));




1,357,599✔





1148



#ifdef TD_ENTERPRISE










1149



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "authServer", tsAuthServer, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1150



  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "authReq", tsAuthReq, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1151



  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "authReqInterval", tsAuthReqInterval, 1, 86400 * 30, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1152



  TAOS_CHECK_RETURN(cfgAddString(pCfg, "authReqUrl", tsAuthReqUrl, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,357,599✔





1153



#endif










1154



  // clang-format on










1155












1156



  // GRANT_CFG_ADD;










1157



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,357,599✔





1158



}










1159












1160



static int32_t taosUpdateServerCfg(SConfig *pCfg) {




1,866,674✔





1161



  SConfigItem *pItem;










1162



  ECfgSrcType  stype;










1163



  int32_t      numOfCores;










1164



  int64_t      totalMemoryKB;










1165












1166



  pItem = cfgGetItem(pCfg, "numOfCores");




1,866,674✔





1167



  if (pItem == NULL) {




1,866,674✔





1168



    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);




×







1169



  } else {










1170



    stype = pItem->stype;




1,866,674✔





1171



    numOfCores = pItem->fval;




1,866,674✔





1172



  }










1173












1174



  pItem = cfgGetItem(pCfg, "supportVnodes");




1,866,674✔





1175



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1176



    tsNumOfSupportVnodes = numOfCores * 2 + 5;




120✔





1177



    tsNumOfSupportVnodes = TMAX(tsNumOfSupportVnodes, 2);




120✔





1178



    pItem->i32 = tsNumOfSupportVnodes;




120✔





1179



    pItem->stype = stype;




120✔





1180



  }










1181












1182



  pItem = cfgGetItem(pCfg, "numOfRpcThreads");




1,866,674✔





1183



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1184



    tsNumOfRpcThreads = TRANGE(tsNumOfRpcThreads, 1, TSDB_MAX_RPC_THREADS);




1,865,654✔





1185



    pItem->i32 = tsNumOfRpcThreads;




1,865,654✔





1186



    pItem->stype = stype;




1,865,654✔





1187



  }










1188












1189



  pItem = cfgGetItem(pCfg, "numOfRpcSessions");




1,866,674✔





1190



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1191



    tsNumOfRpcSessions = TRANGE(tsNumOfRpcSessions, 100, 10000);




1,865,654✔





1192



    pItem->i32 = tsNumOfRpcSessions;




1,865,654✔





1193



    pItem->stype = stype;




1,865,654✔





1194



  }










1195












1196



  pItem = cfgGetItem(pCfg, "shareConnLimit");




1,866,674✔





1197



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1198



    tsShareConnLimit = TRANGE(tsShareConnLimit, 1, 512);




1,866,164✔





1199



    pItem->i32 = tsShareConnLimit;




1,866,164✔





1200



    pItem->stype = stype;




1,866,164✔





1201



  }










1202












1203



  pItem = cfgGetItem(pCfg, "readTimeout");




1,866,674✔





1204



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1205



    tsReadTimeout = TRANGE(tsReadTimeout, 64, 24 * 3600 * 7);




1,866,164✔





1206



    pItem->i32 = tsReadTimeout;




1,866,164✔





1207



    pItem->stype = stype;




1,866,164✔





1208



  }










1209












1210



  pItem = cfgGetItem(pCfg, "timeToGetAvailableConn");




1,866,674✔





1211



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1212



    tsTimeToGetAvailableConn = TRANGE(tsTimeToGetAvailableConn, 20, 1000000);




1,866,164✔





1213



    pItem->i32 = tsTimeToGetAvailableConn;




1,866,164✔





1214



    pItem->stype = stype;




1,866,164✔





1215



  }










1216












1217



  pItem = cfgGetItem(pCfg, "numOfCommitThreads");




1,866,674✔





1218



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1219



    tsNumOfCommitThreads = numOfCores / 2;




1,866,164✔





1220



    tsNumOfCommitThreads = TRANGE(tsNumOfCommitThreads, 2, 4);




1,866,164✔





1221



    pItem->i32 = tsNumOfCommitThreads;




1,866,164✔





1222



    pItem->stype = stype;




1,866,164✔





1223



  }










1224












1225



  pItem = cfgGetItem(pCfg, "numOfCompactThreads");




1,866,674✔





1226



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1227



    pItem->i32 = tsNumOfCompactThreads;




1,866,164✔





1228



    pItem->stype = stype;




1,866,164✔





1229



  }










1230












1231



  pItem = cfgGetItem(pCfg, "numOfMnodeReadThreads");




1,866,674✔





1232



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1233



    tsNumOfMnodeReadThreads = numOfCores / 8;




1,866,164✔





1234



    tsNumOfMnodeReadThreads = TRANGE(tsNumOfMnodeReadThreads, 1, 4);




1,866,164✔





1235



    pItem->i32 = tsNumOfMnodeReadThreads;




1,866,164✔





1236



    pItem->stype = stype;




1,866,164✔





1237



  }










1238












1239



  pItem = cfgGetItem(pCfg, "numOfVnodeQueryThreads");




1,866,674✔





1240



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1241



    tsNumOfVnodeQueryThreads = numOfCores * 2;




1,864,898✔





1242



    tsNumOfVnodeQueryThreads = TMAX(tsNumOfVnodeQueryThreads, 16);




1,864,898✔





1243



    pItem->i32 = tsNumOfVnodeQueryThreads;




1,864,898✔





1244



    pItem->stype = stype;




1,864,898✔





1245



  }










1246












1247



  pItem = cfgGetItem(pCfg, "numOfVnodeFetchThreads");




1,866,674✔





1248



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1249



    tsNumOfVnodeFetchThreads = numOfCores / 4;




1,866,164✔





1250



    tsNumOfVnodeFetchThreads = TMAX(tsNumOfVnodeFetchThreads, 4);




1,866,164✔





1251



    pItem->i32 = tsNumOfVnodeFetchThreads;




1,866,164✔





1252



    pItem->stype = stype;




1,866,164✔





1253



  }










1254












1255



  pItem = cfgGetItem(pCfg, "numOfVnodeRsmaThreads");




1,866,674✔





1256



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1257



    tsNumOfVnodeRsmaThreads = numOfCores;




1,866,164✔





1258



    tsNumOfVnodeRsmaThreads = TMAX(tsNumOfVnodeRsmaThreads, 4);




1,866,164✔





1259



    pItem->i32 = tsNumOfVnodeRsmaThreads;




1,866,164✔





1260



    pItem->stype = stype;




1,866,164✔





1261



  }










1262












1263



  pItem = cfgGetItem(pCfg, "numOfQnodeQueryThreads");




1,866,674✔





1264



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1265



    tsNumOfQnodeQueryThreads = numOfCores * 2;




1,866,164✔





1266



    tsNumOfQnodeQueryThreads = TMAX(tsNumOfQnodeQueryThreads, 16);




1,866,164✔





1267



    pItem->i32 = tsNumOfQnodeQueryThreads;




1,866,164✔





1268



    pItem->stype = stype;




1,866,164✔





1269



  }










1270












1271



  pItem = cfgGetItem(pCfg, "totalMemoryKB");




1,866,674✔





1272



  if (pItem == NULL) {




1,866,674✔





1273



    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);




×







1274



  } else {










1275



    stype = pItem->stype;




1,866,674✔





1276



    totalMemoryKB = pItem->i64;




1,866,674✔





1277



  }










1278












1279



  pItem = cfgGetItem(pCfg, "rpcQueueMemoryAllowed");




1,866,674✔





1280



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1281



    tsQueueMemoryAllowed = totalMemoryKB * 1024 * 0.1;




1,864,573✔





1282



    tsQueueMemoryAllowed = TRANGE(tsQueueMemoryAllowed, TSDB_MAX_MSG_SIZE * 10LL, TSDB_MAX_MSG_SIZE * 10000LL);




1,864,573✔





1283



    pItem->i64 = tsQueueMemoryAllowed;




1,864,573✔





1284



    pItem->stype = stype;




1,864,573✔





1285



  }










1286












1287



  pItem = cfgGetItem(tsCfg, "syncLogBufferMemoryAllowed");




1,866,674✔





1288



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1289



    tsLogBufferMemoryAllowed = totalMemoryKB * 1024 * 0.1;




1,865,590✔





1290



    tsLogBufferMemoryAllowed = TRANGE(tsLogBufferMemoryAllowed, TSDB_MAX_MSG_SIZE * 10LL, TSDB_MAX_MSG_SIZE * 10000LL);




1,865,590✔





1291



    pItem->i64 = tsLogBufferMemoryAllowed;




1,865,590✔





1292



    pItem->stype = stype;




1,865,590✔





1293



  }










1294












1295



  pItem = cfgGetItem(tsCfg, "syncApplyQueueSize");




1,866,674✔





1296



  if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {




1,866,674✔





1297



    pItem->i64 = tsSyncApplyQueueSize;




1,866,658✔





1298



    pItem->stype = stype;




1,866,658✔





1299



  }










1300












1301



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,866,674✔





1302



}










1303












1304



static int32_t taosSetLogOutput(SConfig *pCfg) {




5,712,884✔





1305



  if (tsLogOutput) {




5,712,884✔





1306



    char *pLog = tsLogOutput;




2,622✔





1307



    char *pEnd = NULL;




2,622✔





1308



    if (strcasecmp(pLog, "stdout") && strcasecmp(pLog, "stderr") && strcasecmp(pLog, "/dev/null")) {




2,622✔





1309



      if ((pEnd = strrchr(pLog, '/')) || (pEnd = strrchr(pLog, '\\'))) {




366✔





1310



        int32_t pathLen = POINTER_DISTANCE(pEnd, pLog) + 1;




302✔





1311



        if (*pLog == '/' || *pLog == '\\') {




302✔





1312



          if (pathLen <= 0 || pathLen > PATH_MAX) TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);




120✔





1313



          tstrncpy(tsLogDir, pLog, pathLen);




120✔





1314



        } else {










1315



          int32_t len = strlen(tsLogDir);




182✔





1316



          if (len < 0 || len >= (PATH_MAX - 1)) TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);




182✔





1317



          if (len == 0 || (tsLogDir[len - 1] != '/' && tsLogDir[len - 1] != '\\')) {




182✔





1318



            tsLogDir[len++] = TD_DIRSEP_CHAR;




123✔





1319



          }










1320



          int32_t remain = PATH_MAX - len - 1;




182✔





1321



          if (remain < pathLen) TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);




182✔





1322



          tstrncpy(tsLogDir + len, pLog, pathLen);




182✔





1323



        }










1324



        TAOS_CHECK_RETURN(cfgSetItem(pCfg, "logDir", tsLogDir, CFG_STYPE_DEFAULT, true));




302✔





1325



      }










1326



    } else {










1327



      tstrncpy(tsLogDir, pLog, PATH_MAX);




2,256✔





1328



      TAOS_CHECK_RETURN(cfgSetItem(pCfg, "logDir", tsLogDir, CFG_STYPE_DEFAULT, true));




2,256✔





1329



    }










1330



  }










1331



  return 0;




5,712,884✔





1332



}










1333












1334



static int32_t taosSetClientLogCfg(SConfig *pCfg) {




5,712,884✔





1335



  SConfigItem *pItem = NULL;




5,712,884✔





1336












1337



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "logDir");




5,712,884✔





1338



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




5,712,884✔





1339



  tstrncpy(tsLogDir, pItem->str, PATH_MAX);




5,712,884✔





1340



  TAOS_CHECK_RETURN(taosExpandDir(tsLogDir, tsLogDir, PATH_MAX));




5,712,884✔





1341



  TAOS_CHECK_RETURN(taosSetLogOutput(pCfg));




5,712,884✔





1342












1343



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minimalLogDirGB");




5,712,884✔





1344



  tsLogSpace.reserved = (int64_t)(((double)pItem->fval) * 1024 * 1024 * 1024);




5,712,884✔





1345












1346



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfLogLines");




5,712,884✔





1347



  tsNumOfLogLines = pItem->i32;




5,712,884✔





1348












1349



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "asyncLog");




5,712,884✔





1350



  tsAsyncLog = pItem->bval;




5,712,884✔





1351












1352



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "logKeepDays");




5,712,884✔





1353



  tsLogKeepDays = pItem->i32;




5,712,884✔





1354












1355



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tmrDebugFlag");




5,712,884✔





1356



  tmrDebugFlag = pItem->i32;




5,712,884✔





1357












1358



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "uDebugFlag");




5,712,884✔





1359



  uDebugFlag = pItem->i32;




5,712,884✔





1360












1361



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "jniDebugFlag");




5,712,884✔





1362



  jniDebugFlag = pItem->i32;




5,712,884✔





1363












1364



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "rpcDebugFlag");




5,712,884✔





1365



  rpcDebugFlag = pItem->i32;




5,712,884✔





1366












1367



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "qDebugFlag");




5,712,884✔





1368



  qDebugFlag = pItem->i32;




5,712,884✔





1369












1370



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "cDebugFlag");




5,712,884✔





1371



  cDebugFlag = pItem->i32;




5,712,884✔





1372












1373



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "simDebugFlag");




5,712,884✔





1374



  simDebugFlag = pItem->i32;




5,712,884✔





1375












1376



  TAOS_RETURN(TSDB_CODE_SUCCESS);




5,712,884✔





1377



}










1378












1379



static int32_t taosSetServerLogCfg(SConfig *pCfg) {




1,357,599✔





1380



  SConfigItem *pItem = NULL;




1,357,599✔





1381



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "dDebugFlag");




1,357,599✔





1382



  dDebugFlag = pItem->i32;




1,357,599✔





1383












1384



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "vDebugFlag");




1,357,599✔





1385



  vDebugFlag = pItem->i32;




1,357,599✔





1386












1387



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mDebugFlag");




1,357,599✔





1388



  mDebugFlag = pItem->i32;




1,357,599✔





1389












1390



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "wDebugFlag");




1,357,599✔





1391



  wDebugFlag = pItem->i32;




1,357,599✔





1392












1393



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "azDebugFlag");




1,357,599✔





1394



  azDebugFlag = pItem->i32;




1,357,599✔





1395












1396



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tssDebugFlag");




1,357,599✔





1397



  tssDebugFlag = pItem->i32;




1,357,599✔





1398












1399



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sDebugFlag");




1,357,599✔





1400



  sDebugFlag = pItem->i32;




1,357,599✔





1401












1402



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tsdbDebugFlag");




1,357,599✔





1403



  tsdbDebugFlag = pItem->i32;




1,357,599✔





1404












1405



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tqDebugFlag");




1,357,599✔





1406



  tqDebugFlag = pItem->i32;




1,357,599✔





1407












1408



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "fsDebugFlag");




1,357,599✔





1409



  fsDebugFlag = pItem->i32;




1,357,599✔





1410












1411



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udfDebugFlag");




1,357,599✔





1412



  udfDebugFlag = pItem->i32;




1,357,599✔





1413












1414



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smaDebugFlag");




1,357,599✔





1415



  smaDebugFlag = pItem->i32;




1,357,599✔





1416












1417



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "idxDebugFlag");




1,357,599✔





1418



  idxDebugFlag = pItem->i32;




1,357,599✔





1419












1420



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tdbDebugFlag");




1,357,599✔





1421



  tdbDebugFlag = pItem->i32;




1,357,599✔





1422












1423



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metaDebugFlag");




1,357,599✔





1424



  metaDebugFlag = pItem->i32;




1,357,599✔





1425












1426



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "stDebugFlag");




1,357,599✔





1427



  stDebugFlag = pItem->i32;




1,357,599✔





1428












1429



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sndDebugFlag");




1,357,599✔





1430



  sndDebugFlag = pItem->i32;




1,357,599✔





1431












1432



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "bseDebugFlag");




1,357,599✔





1433



  bseDebugFlag = pItem->i32;




1,357,599✔





1434



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "bndDebugFlag");




1,357,599✔





1435



  bndDebugFlag = pItem->i32;




1,357,599✔





1436












1437



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "xndDebugFlag");




1,357,599✔





1438



  xndDebugFlag = pItem->i32;




1,357,599✔





1439












1440



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,357,599✔





1441



}










1442












1443



int32_t taosSetSlowLogScope(char *pScopeStr, int32_t *pScope) {




1,866,674✔





1444



  if (NULL == pScopeStr || 0 == strlen(pScopeStr)) {




1,866,674✔





1445



    *pScope = SLOW_LOG_TYPE_QUERY;




×







1446



    TAOS_RETURN(TSDB_CODE_SUCCESS);




×







1447



  }










1448












1449



  int32_t slowScope = 0;




1,866,674✔





1450












1451



  char *scope = NULL;




1,866,674✔





1452



  char *tmp = NULL;




1,866,674✔





1453



  while ((scope = strsep(&pScopeStr, "|")) != NULL) {




3,733,348✔





1454



    taosMemoryFreeClear(tmp);




1,866,674✔





1455



    tmp = taosStrdup(scope);




1,866,674✔





1456



    if (tmp == NULL) {




1,866,674✔





1457



      TAOS_RETURN(terrno);




×







1458



    }










1459



    (void)strtrim(tmp);




1,866,674✔





1460



    if (0 == strcasecmp(tmp, "all")) {




1,866,674✔





1461



      slowScope |= SLOW_LOG_TYPE_ALL;




×







1462



      continue;




×







1463



    }










1464












1465



    if (0 == strcasecmp(tmp, "query")) {




1,866,674✔





1466



      slowScope |= SLOW_LOG_TYPE_QUERY;




1,844,213✔





1467



      continue;




1,844,213✔





1468



    }










1469












1470



    if (0 == strcasecmp(tmp, "insert")) {




22,461✔





1471



      slowScope |= SLOW_LOG_TYPE_INSERT;




2,134✔





1472



      continue;




2,134✔





1473



    }










1474












1475



    if (0 == strcasecmp(tmp, "others")) {




20,327✔





1476



      slowScope |= SLOW_LOG_TYPE_OTHERS;




3,554✔





1477



      continue;




3,554✔





1478



    }










1479












1480



    if (0 == strcasecmp(tmp, "none")) {




16,773✔





1481



      slowScope |= SLOW_LOG_TYPE_NULL;




16,773✔





1482



      continue;




16,773✔





1483



    }










1484












1485



    taosMemoryFreeClear(tmp);




×







1486



    uError("Invalid slowLog scope value:%s", pScopeStr);




×







1487



    TAOS_RETURN(TSDB_CODE_INVALID_CFG_VALUE);




×







1488



  }










1489












1490



  *pScope = slowScope;




1,866,674✔





1491



  taosMemoryFreeClear(tmp);




1,866,674✔





1492



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,866,674✔





1493



}










1494












1495



// for common configs










1496



static int32_t taosSetClientCfg(SConfig *pCfg) {




3,368,861✔





1497



  SConfigItem *pItem = NULL;




3,368,861✔





1498












1499



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "fqdn");




3,368,861✔





1500



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_FQDN_LEN));




3,367,286✔





1501



  tstrncpy(tsLocalFqdn, pItem->str, TSDB_FQDN_LEN);




3,367,286✔





1502












1503



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "serverPort");




3,367,286✔





1504



  tsServerPort = (uint16_t)pItem->i32;




3,367,286✔





1505



  (void)snprintf(tsLocalEp, sizeof(tsLocalEp), "%s:%u", tsLocalFqdn, tsServerPort);




3,367,286✔





1506












1507



  char defaultFirstEp[TSDB_EP_LEN] = {0};




3,367,286✔





1508



  (void)snprintf(defaultFirstEp, TSDB_EP_LEN, "%s:%u", tsLocalFqdn, tsServerPort);




3,367,286✔





1509












1510



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mqttPort");




3,367,286✔





1511



  tsMqttPort = (uint16_t)pItem->i32;




3,367,286✔





1512



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableIpv6");




3,367,286✔





1513



  tsEnableIpv6 = pItem->bval;




3,367,286✔





1514












1515



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "firstEp");




3,367,286✔





1516



  SEp firstEp = {0};




3,367,286✔





1517



  TAOS_CHECK_RETURN(taosGetFqdnPortFromEp(strlen(pItem->str) == 0 ? defaultFirstEp : pItem->str, &firstEp));




3,367,286✔





1518



  (void)snprintf(tsFirst, sizeof(tsFirst), "%s:%u", firstEp.fqdn, firstEp.port);




3,367,286✔





1519



  TAOS_CHECK_RETURN(cfgSetItem(pCfg, "firstEp", tsFirst, pItem->stype, true));




3,367,286✔





1520












1521



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "secondEp");




3,367,286✔





1522



  SEp secondEp = {0};




3,367,286✔





1523



  TAOS_CHECK_RETURN(taosGetFqdnPortFromEp(strlen(pItem->str) == 0 ? defaultFirstEp : pItem->str, &secondEp));




3,367,286✔





1524



  (void)snprintf(tsSecond, sizeof(tsSecond), "%s:%u", secondEp.fqdn, secondEp.port);




3,367,286✔





1525



  TAOS_CHECK_RETURN(cfgSetItem(pCfg, "secondEp", tsSecond, pItem->stype, true));




3,367,286✔





1526












1527



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tempDir");




3,367,286✔





1528



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




3,367,286✔





1529



  tstrncpy(tsTempDir, pItem->str, PATH_MAX);




3,367,286✔





1530



  TAOS_CHECK_RETURN(taosExpandDir(tsTempDir, tsTempDir, PATH_MAX));




3,367,286✔





1531












1532



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minimalTmpDirGB");




3,367,286✔





1533



  tsTempSpace.reserved = (int64_t)(((double)pItem->fval) * 1024 * 1024 * 1024);




3,367,286✔





1534



  if (taosMulMkDir(tsTempDir) != 0) {




3,367,286✔





1535



    int32_t code = TAOS_SYSTEM_ERROR(ERRNO);




×







1536



    uError("failed to create tempDir:%s since %s", tsTempDir, tstrerror(code));




×







1537



    TAOS_RETURN(code);




×







1538



  }










1539












1540



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlAutoChildTableNameDelimiter");




3,367,286✔





1541



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_TABLE_NAME_LEN));




3,367,286✔





1542



  tstrncpy(tsSmlAutoChildTableNameDelimiter, pItem->str, TSDB_TABLE_NAME_LEN);




3,367,286✔





1543












1544



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlChildTableName");




3,367,286✔





1545



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_TABLE_NAME_LEN));




3,367,286✔





1546



  tstrncpy(tsSmlChildTableName, pItem->str, TSDB_TABLE_NAME_LEN);




3,367,286✔





1547












1548



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlTagName");




3,367,286✔





1549



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_COL_NAME_LEN));




3,367,286✔





1550



  tstrncpy(tsSmlTagName, pItem->str, TSDB_COL_NAME_LEN);




3,367,286✔





1551












1552



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlTsDefaultName");




3,367,286✔





1553



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_COL_NAME_LEN));




3,367,286✔





1554



  tstrncpy(tsSmlTsDefaultName, pItem->str, TSDB_COL_NAME_LEN);




3,367,286✔





1555












1556



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlDot2Underline");




3,367,286✔





1557



  tsSmlDot2Underline = pItem->bval;




3,367,286✔





1558












1559



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxInsertBatchRows");




3,367,286✔





1560



  tsMaxInsertBatchRows = pItem->i32;




3,367,286✔





1561












1562



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "shellActivityTimer");




3,367,286✔





1563



  tsShellActivityTimer = pItem->i32;




3,367,286✔





1564












1565



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "compressMsgSize");




3,367,286✔





1566



  tsCompressMsgSize = pItem->i32;




3,367,286✔





1567












1568



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfTaskQueueThreads");




3,367,286✔





1569



  tsNumOfTaskQueueThreads = pItem->i32;




3,367,286✔





1570












1571



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryPolicy");




3,367,286✔





1572



  tsQueryPolicy = pItem->i32;




3,367,286✔





1573












1574



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryTableNotExistAsEmpty");




3,367,286✔





1575



  tsQueryTbNotExistAsEmpty = pItem->bval;




3,367,286✔





1576












1577



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableQueryHb");




3,367,286✔





1578



  tsEnableQueryHb = pItem->bval;




3,367,286✔





1579












1580



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableScience");




3,367,286✔





1581



  tsEnableScience = pItem->bval;




3,367,286✔





1582












1583



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "querySmaOptimize");




3,367,286✔





1584



  tsQuerySmaOptimize = pItem->i32;




3,367,286✔





1585












1586



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tmqWriteRefDB");




3,367,286✔





1587



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_DB_NAME_LEN));




3,367,286✔





1588



  tstrncpy(tmqWriteRefDB, pItem->str, TSDB_DB_NAME_LEN);




3,367,286✔





1589












1590



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tmqWriteCheckRef");




3,367,286✔





1591



  tmqWriteCheckRef = pItem->bval;




3,367,286✔





1592












1593



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sqlSecurity");




3,367,286✔





1594



  tsSqlSecurityEnabled = pItem->bval;




3,367,286✔





1595



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sqlSecurityWhitelistMode");




3,367,286✔





1596



  tsSqlSecurityWhitelistMode = pItem->i32;




3,367,286✔





1597



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sqlSecurityStringCheck");




3,367,286✔





1598



  tsSqlSecurityStringCheck = pItem->bval;




3,367,286✔





1599



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sqlSecurityASTCheck");




3,367,286✔





1600



  tsSqlSecurityASTCheck = pItem->bval;




3,367,286✔





1601



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sqlSecurityRuleFile");




3,367,286✔





1602



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




3,367,286✔





1603



  tstrncpy(tsSqlSecurityRuleFile, pItem->str, PATH_MAX);




3,367,286✔





1604



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "whitelistLearning");




3,367,286✔





1605



  tsWhitelistLearning = pItem->bval;




3,367,286✔





1606



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "whitelistLearningPeriod");




3,367,286✔





1607



  tsWhitelistLearningPeriod = pItem->i32;




3,367,286✔





1608



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "whitelistLearningThreshold");




3,367,286✔





1609



  tsWhitelistLearningThreshold = pItem->i32;




3,367,286✔





1610












1611



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryPlannerTrace");




3,367,286✔





1612



  tsQueryPlannerTrace = pItem->bval;




3,367,286✔





1613












1614



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryNodeChunkSize");




3,367,286✔





1615



  tsQueryNodeChunkSize = pItem->i32;




3,367,286✔





1616












1617



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryUseNodeAllocator");




3,367,286✔





1618



  tsQueryUseNodeAllocator = pItem->bval;




3,367,286✔





1619












1620



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "keepColumnName");




3,367,286✔





1621



  tsKeepColumnName = pItem->bval;




3,367,286✔





1622












1623



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "useAdapter");




3,367,286✔





1624



  tsUseAdapter = pItem->bval;




3,367,286✔





1625












1626



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "crashReporting");




3,367,286✔





1627



  tsEnableCrashReport = pItem->bval;




3,367,286✔





1628












1629



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryMaxConcurrentTables");




3,367,286✔





1630



  tsQueryMaxConcurrentTables = pItem->i64;




3,367,286✔





1631












1632



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metaCacheMaxSize");




3,367,286✔





1633



  tsMetaCacheMaxSize = pItem->i32;




3,367,286✔





1634












1635



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "randErrorChance");




3,367,286✔





1636



  tsRandErrChance = pItem->i32;




3,367,286✔





1637












1638



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "randErrorDivisor");




3,367,286✔





1639



  tsRandErrDivisor = pItem->i64;




3,367,286✔





1640












1641



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "randErrorScope");




3,367,286✔





1642



  tsRandErrScope = pItem->i64;




3,367,286✔





1643












1644



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "countAlwaysReturnValue");




3,367,286✔





1645



  tsCountAlwaysReturnValue = pItem->i32;




3,367,286✔





1646












1647



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxRetryWaitTime");




3,367,286✔





1648



  tsMaxRetryWaitTime = pItem->i32;




3,367,286✔





1649












1650



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcThreads");




3,367,286✔





1651



  tsNumOfRpcThreads = pItem->i32;




3,367,286✔





1652












1653



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcSessions");




3,367,286✔





1654



  tsNumOfRpcSessions = pItem->i32;




3,367,286✔





1655












1656



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "shareConnLimit");




3,367,286✔





1657



  tsShareConnLimit = pItem->i32;




3,367,286✔





1658












1659



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "readTimeout");




3,367,286✔





1660



  tsReadTimeout = pItem->i32;




3,367,286✔





1661












1662



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timeToGetAvailableConn");




3,367,286✔





1663



  tsTimeToGetAvailableConn = pItem->i32;




3,367,286✔





1664












1665



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "experimental");




3,367,286✔





1666



  tsExperimental = pItem->bval;




3,367,286✔





1667












1668



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "multiResultFunctionStarReturnTags");




3,367,286✔





1669



  tsMultiResultFunctionStarReturnTags = pItem->bval;




3,367,286✔





1670












1671



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxTsmaCalcDelay");




3,367,286✔





1672



  tsMaxTsmaCalcDelay = pItem->i32;




3,367,286✔





1673












1674



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tsmaDataDeleteMark");




3,367,286✔





1675



  tsmaDataDeleteMark = pItem->i32;




3,367,286✔





1676












1677



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "safetyCheckLevel");




3,367,286✔





1678



  tsSafetyCheckLevel = pItem->i32;




3,367,286✔





1679












1680



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "bypassFlag");




3,367,286✔





1681



  tsBypassFlag = pItem->i32;




3,367,286✔





1682












1683



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "compareAsStrInGreatest");




3,367,286✔





1684



  tsCompareAsStrInGreatest = pItem->bval;




3,367,286✔





1685












1686



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "showFullCreateTableColumn");




3,367,286✔





1687



  tsShowFullCreateTableColumn = pItem->bval;




3,367,286✔





1688












1689



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCliKeyPath");




3,367,286✔





1690



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




3,367,286✔





1691



  tstrncpy(tsTLSCliKeyPath, pItem->str, PATH_MAX);




3,367,286✔





1692












1693



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCliCertPath");




3,367,286✔





1694



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




3,367,286✔





1695



  tstrncpy(tsTLSCliCertPath, pItem->str, PATH_MAX);




3,367,286✔





1696












1697



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCaPath");




3,367,286✔





1698



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




3,367,286✔





1699



  tstrncpy(tsTLSCaPath, pItem->str, PATH_MAX);




3,367,286✔





1700












1701



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableTLS");




3,367,286✔





1702



  tsEnableTLS = pItem->bval;




3,367,286✔





1703












1704



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableSasl");




3,367,286✔





1705



  tsEnableSasl = pItem->bval;




3,367,286✔





1706



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxSQLLength");




3,367,286✔





1707



  tsMaxSQLLength = pItem->i32;




3,367,286✔





1708












1709



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sessionControl");




3,367,286✔





1710



  tsSessionControl = pItem->bval;




3,367,286✔





1711












1712



  TAOS_RETURN(TSDB_CODE_SUCCESS);




3,367,286✔





1713



}










1714












1715



static int32_t taosSetSystemCfg(SConfig *pCfg) {




3,367,286✔





1716



  SConfigItem *pItem = NULL;




3,367,286✔





1717












1718



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableCoreFile");




3,367,286✔





1719



  tsEnableCoreFile = pItem->bval;




3,367,286✔





1720



  taosSetCoreDump(tsEnableCoreFile);




3,367,286✔





1721












1722



  // todo










1723



  tsVersion = 30000000;




3,367,286✔





1724












1725



  TAOS_RETURN(TSDB_CODE_SUCCESS);




3,367,286✔





1726



}










1727












1728



// for server configs










1729



static int32_t taosSetServerCfg(SConfig *pCfg) {




1,866,674✔





1730



  SConfigItem *pItem = NULL;




1,866,674✔





1731












1732



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minimalDataDirGB");




1,866,674✔





1733



  tsDataSpace.reserved = (int64_t)(((double)pItem->fval) * 1024 * 1024 * 1024);




1,866,674✔





1734












1735



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "supportVnodes");




1,866,674✔





1736



  tsNumOfSupportVnodes = pItem->i32;




1,866,674✔





1737












1738



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxShellConns");




1,866,674✔





1739



  tsMaxShellConns = pItem->i32;




1,866,674✔





1740












1741



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "statusInterval");




1,866,674✔





1742



  tsStatusInterval = pItem->i32;




1,866,674✔





1743



  tsStatusIntervalMs = pItem->i32 * 1000;




1,866,674✔





1744












1745



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "statusIntervalMs");




1,866,674✔





1746



  tsStatusIntervalMs = pItem->i32;




1,866,674✔





1747












1748



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "statusSRTimeoutMs");




1,866,674✔





1749



  tsStatusSRTimeoutMs = pItem->i32;




1,866,674✔





1750












1751



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "statusTimeoutMs");




1,866,674✔





1752



  tsStatusTimeoutMs = pItem->i32;




1,866,674✔





1753












1754



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableMetrics");




1,866,674✔





1755



  tsEnableMetrics = pItem->bval;




1,866,674✔





1756












1757



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metricsLevel");




1,866,674✔





1758



  tsMetricsLevel = pItem->i32;




1,866,674✔





1759












1760



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metricsInterval");




1,866,674✔





1761



  tsMetricsInterval = pItem->i32;




1,866,674✔





1762












1763



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minSlidingTime");




1,866,674✔





1764



  tsMinSlidingTime = pItem->i32;




1,866,674✔





1765












1766



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minIntervalTime");




1,866,674✔





1767



  tsMinIntervalTime = pItem->i32;




1,866,674✔





1768












1769



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryBufferSize");




1,866,674✔





1770



  tsQueryBufferSize = pItem->i32;




1,866,674✔





1771












1772



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "encryptAlgorithm");




1,866,674✔





1773



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, 16));




1,866,674✔





1774



  tstrncpy(tsEncryptAlgorithm, pItem->str, 16);




1,866,674✔





1775












1776



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "encryptExtDir");




1,866,674✔





1777



  tstrncpy(tsEncryptExtDir, pItem->str, PATH_MAX);




1,866,674✔





1778












1779



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "encryptScope");




1,866,674✔





1780



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, 100));




1,866,674✔





1781



  tstrncpy(tsEncryptScope, pItem->str, 100);




1,866,674✔





1782












1783



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableStrongPassword");




1,866,674✔





1784



  tsEnableStrongPassword = pItem->i32;




1,866,674✔





1785












1786



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableAdvancedSecurity");




1,866,674✔





1787



  tsEnableAdvancedSecurity = pItem->i32;




1,866,674✔





1788












1789



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableGrantLegacySyntax");




1,866,674✔





1790



  tsEnableGrantLegacySyntax = pItem->i32;




1,866,674✔





1791












1792



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "encryptPassAlgorithm");




1,866,674✔





1793



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, 16));




1,866,674✔





1794



  tstrncpy(tsEncryptPassAlgorithm, pItem->str, 16);




1,866,674✔





1795












1796



  if (strlen(tsEncryptPassAlgorithm) > 0) {




1,866,674✔





1797



    if (strcmp(tsEncryptPassAlgorithm, "sm4") == 0) {




564✔





1798



      tsiEncryptPassAlgorithm = DND_CA_SM4;




564✔





1799



    } else {










1800



      uError("invalid tsEncryptAlgorithm:%s", tsEncryptPassAlgorithm);




×







1801



    }










1802



  }










1803












1804



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcThreads");




1,866,674✔





1805



  tsNumOfRpcThreads = pItem->i32;




1,866,674✔





1806












1807



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcSessions");




1,866,674✔





1808



  tsNumOfRpcSessions = pItem->i32;




1,866,674✔





1809












1810



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "shareConnLimit");




1,866,674✔





1811



  tsShareConnLimit = pItem->i32;




1,866,674✔





1812












1813



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "readTimeout");




1,866,674✔





1814



  tsReadTimeout = pItem->i32;




1,866,674✔





1815












1816



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timeToGetAvailableConn");




1,866,674✔





1817



  tsTimeToGetAvailableConn = pItem->i32;




1,866,674✔





1818












1819



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfCommitThreads");




1,866,674✔





1820



  tsNumOfCommitThreads = pItem->i32;




1,866,674✔





1821












1822



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfCompactThreads");




1,866,674✔





1823



  tsNumOfCompactThreads = pItem->i32;




1,866,674✔





1824












1825



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "secureEraseMode");




1,866,674✔





1826



  tsSecureEraseMode = pItem->i32;




1,866,674✔





1827












1828



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableIpv6");




1,866,674✔





1829



  tsEnableIpv6 = pItem->bval;




1,866,674✔





1830












1831



#ifdef TD_ENTERPRISE










1832



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "authServer");




1,866,674✔





1833



  tsAuthServer = pItem->bval;




1,866,674✔





1834












1835



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "authReq");




1,866,674✔





1836



  tsAuthReq = pItem->bval;




1,866,674✔





1837












1838



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "authReqInterval");




1,866,674✔





1839



  tsAuthReqInterval = pItem->i32;




1,866,674✔





1840












1841



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "authReqUrl");




1,866,674✔





1842



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_FQDN_LEN));




1,866,674✔





1843



  tstrncpy(tsAuthReqUrl, pItem->str, TSDB_FQDN_LEN);




1,866,674✔





1844



#endif










1845












1846



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "retentionSpeedLimitMB");




1,866,674✔





1847



  tsRetentionSpeedLimitMB = pItem->i32;




1,866,674✔





1848












1849



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfMnodeReadThreads");




1,866,674✔





1850



  tsNumOfMnodeReadThreads = pItem->i32;




1,866,674✔





1851












1852



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfVnodeQueryThreads");




1,866,674✔





1853



  tsNumOfVnodeQueryThreads = pItem->i32;




1,866,674✔





1854












1855



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfVnodeFetchThreads");




1,866,674✔





1856



  tsNumOfVnodeFetchThreads = pItem->i32;




1,866,674✔





1857












1858



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfVnodeRsmaThreads");




1,866,674✔





1859



  tsNumOfVnodeRsmaThreads = pItem->i32;




1,866,674✔





1860












1861



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfQnodeQueryThreads");




1,866,674✔





1862



  tsNumOfQnodeQueryThreads = pItem->i32;




1,866,674✔





1863












1864



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "rpcQueueMemoryAllowed");




1,866,674✔





1865



  tsQueueMemoryAllowed = cfgGetItem(pCfg, "rpcQueueMemoryAllowed")->i64 * QUEUE_MEMORY_USAGE_RATIO;




1,866,674✔





1866



  tsApplyMemoryAllowed = cfgGetItem(pCfg, "rpcQueueMemoryAllowed")->i64 * (1 - QUEUE_MEMORY_USAGE_RATIO);




1,866,674✔





1867












1868



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "simdEnable");




1,866,674✔





1869



  tsSIMDEnable = (bool)pItem->bval;




1,866,674✔





1870












1871



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "AVX512Enable");




1,866,674✔





1872



  tsAVX512Enable = (bool)pItem->bval;




1,866,674✔





1873












1874



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tagFilterCache");




1,866,674✔





1875



  tsTagFilterCache = (bool)pItem->bval;




1,866,674✔





1876












1877



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "stableTagFilterCache");




1,866,674✔





1878



  tsStableTagFilterCache = pItem->bval;




1,866,674✔





1879



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metaEntryCache");




1,866,674✔





1880



  tsMetaEntryCache = (bool)pItem->bval;




1,866,674✔





1881



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metaEntryCacheSize");




1,866,674✔





1882



  tsMetaEntryCacheSize = pItem->i64;




1,866,674✔





1883












1884



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogExceptDb");




1,866,674✔





1885



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_DB_NAME_LEN));




1,866,674✔





1886



  tstrncpy(tsSlowLogExceptDb, pItem->str, TSDB_DB_NAME_LEN);




1,866,674✔





1887












1888



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogThreshold");




1,866,674✔





1889



  tsSlowLogThreshold = pItem->i32;




1,866,674✔





1890












1891



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogMaxLen");




1,866,674✔





1892



  tsSlowLogMaxLen = pItem->i32;




1,866,674✔





1893












1894



  int32_t scope = 0;




1,866,674✔





1895



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogScope");




1,866,674✔





1896



  TAOS_CHECK_RETURN(taosSetSlowLogScope(pItem->str, &scope));




1,866,674✔





1897



  tsSlowLogScope = scope;




1,866,674✔





1898












1899



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryRspPolicy");




1,866,674✔





1900



  tsQueryRspPolicy = pItem->i32;




1,866,674✔





1901



#ifdef USE_MONITOR










1902



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitor");




1,866,674✔





1903



  tsEnableMonitor = pItem->bval;




1,866,674✔





1904












1905



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorInterval");




1,866,674✔





1906



  tsMonitorInterval = pItem->i32;




1,866,674✔





1907












1908



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorFqdn");




1,866,674✔





1909



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_FQDN_LEN));




1,866,674✔





1910



  tstrncpy(tsMonitorFqdn, pItem->str, TSDB_FQDN_LEN);




1,866,674✔





1911












1912



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorPort");




1,866,674✔





1913



  tsMonitorPort = (uint16_t)pItem->i32;




1,866,674✔





1914












1915



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorMaxLogs");




1,866,674✔





1916



  tsMonitorMaxLogs = pItem->i32;




1,866,674✔





1917












1918



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorComp");




1,866,674✔





1919



  tsMonitorComp = pItem->bval;




1,866,674✔





1920












1921



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorLogProtocol");




1,866,674✔





1922



  tsMonitorLogProtocol = pItem->bval;




1,866,674✔





1923












1924



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorForceV2");




1,866,674✔





1925



  tsMonitorForceV2 = pItem->i32;




1,866,674✔





1926



#endif










1927



#ifdef USE_AUDIT










1928



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "audit");




1,866,674✔





1929



  tsEnableAudit = pItem->bval;




1,866,674✔





1930












1931



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditCreateTable");




1,866,674✔





1932



  tsEnableAuditCreateTable = pItem->bval;




1,866,674✔





1933












1934



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableAuditDelete");




1,866,674✔





1935



  tsEnableAuditDelete = pItem->bval;




1,866,674✔





1936












1937



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableAuditSelect");




1,866,674✔





1938



  tsEnableAuditSelect = pItem->bval;




1,866,674✔





1939












1940



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableAuditInsert");




1,866,674✔





1941



  tsEnableAuditInsert = pItem->bval;




1,866,674✔





1942












1943



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditLevel");




1,866,674✔





1944



  tsAuditLevel = pItem->i32;




1,866,674✔





1945












1946



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditHttps");




1,866,674✔





1947



  tsAuditHttps = pItem->bval;




1,866,674✔





1948












1949



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditUseToken");




1,866,674✔





1950



  tsAuditUseToken = pItem->bval;




1,866,674✔





1951












1952



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditSaveInSelf");




1,866,674✔





1953



  tsAuditSaveInSelf = pItem->bval;




1,866,674✔





1954












1955



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditInterval");




1,866,674✔





1956



  tsAuditInterval = pItem->i32;




1,866,674✔





1957



#endif










1958



#ifdef USE_REPORT










1959



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryReporting");




1,866,674✔





1960



  tsEnableTelem = pItem->bval;




1,866,674✔





1961












1962



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "crashReporting");




1,866,674✔





1963



  tsEnableCrashReport = pItem->bval;




1,866,674✔





1964












1965



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryInterval");




1,866,674✔





1966



  tsTelemInterval = pItem->i32;




1,866,674✔





1967












1968



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryServer");




1,866,674✔





1969



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_FQDN_LEN));




1,866,674✔





1970



  tstrncpy(tsTelemServer, pItem->str, TSDB_FQDN_LEN);




1,866,674✔





1971



#endif










1972












1973



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlChangeOnWrite");




1,866,674✔





1974



  tsTtlChangeOnWrite = pItem->bval;




1,866,674✔





1975












1976



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlFlushThreshold");




1,866,674✔





1977



  tsTtlFlushThreshold = pItem->i32;




1,866,674✔





1978












1979



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "rsyncPort");




1,866,674✔





1980



  tsRsyncPort = pItem->i32;




1,866,674✔





1981












1982



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "snodeAddress");




1,866,674✔





1983



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_FQDN_LEN));




1,866,674✔





1984



  tstrncpy(tsSnodeAddress, pItem->str, TSDB_FQDN_LEN);




1,866,674✔





1985












1986



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "checkpointBackupDir");




1,866,674✔





1987



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




1,866,674✔





1988



  tstrncpy(tsCheckpointBackupDir, pItem->str, PATH_MAX);




1,866,674✔





1989












1990



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryPort");




1,866,674✔





1991



  tsTelemPort = (uint16_t)pItem->i32;




1,866,674✔





1992












1993



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tmqMaxTopicNum");




1,866,674✔





1994



  tmqMaxTopicNum = pItem->i32;




1,866,674✔





1995












1996



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxTsmaNum");




1,866,674✔





1997



  tsMaxTsmaNum = pItem->i32;




1,866,674✔





1998












1999



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "diskIDCheckEnabled");




1,866,674✔





2000



  tsDiskIDCheckEnabled = pItem->bval;




1,866,674✔





2001












2002



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "transPullupInterval");




1,866,674✔





2003



  tsTransPullupInterval = pItem->i32;




1,866,674✔





2004












2005



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "compactPullupInterval");




1,866,674✔





2006



  tsCompactPullupInterval = pItem->i32;




1,866,674✔





2007












2008



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mqRebalanceInterval");




1,866,674✔





2009



  tsMqRebalanceInterval = pItem->i32;




1,866,674✔





2010












2011



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlUnit");




1,866,674✔





2012



  tsTtlUnit = pItem->i32;




1,866,674✔





2013












2014



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlPushInterval");




1,866,674✔





2015



  tsTtlPushIntervalSec = pItem->i32;




1,866,674✔





2016












2017



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlBatchDropNum");




1,866,674✔





2018



  tsTtlBatchDropNum = pItem->i32;




1,866,674✔





2019












2020



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "trimVDbIntervalSec");




1,866,674✔





2021



  tsTrimVDbIntervalSec = pItem->i32;




1,866,674✔





2022












2023



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryTrimIntervalSec");




1,866,674✔





2024



  tsQueryTrimIntervalSec = pItem->i32;




1,866,674✔





2025












2026



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "querySsMigrateIntervalSec");




1,866,674✔





2027



  tsQuerySsMigrateIntervalSec = pItem->i32;




1,866,674✔





2028












2029



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "uptimeInterval");




1,866,674✔





2030



  tsUptimeInterval = pItem->i32;




1,866,674✔





2031












2032



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryRsmaTolerance");




1,866,674✔





2033



  tsQueryRsmaTolerance = pItem->i32;




1,866,674✔





2034












2035



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timeseriesThreshold");




1,866,674✔





2036



  tsTimeSeriesThreshold = pItem->i32;




1,866,674✔





2037












2038



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "walForceRepair");




1,866,674✔





2039



  tsWalForceRepair = pItem->bval;




1,866,674✔





2040












2041



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "walFsyncDataSizeLimit");




1,866,674✔





2042



  tsWalFsyncDataSizeLimit = pItem->i64;




1,866,674✔





2043












2044



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncElectInterval");




1,866,674✔





2045



  tsElectInterval = pItem->i32;




1,866,674✔





2046












2047



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncHeartbeatInterval");




1,866,674✔





2048



  tsHeartbeatInterval = pItem->i32;




1,866,674✔





2049












2050



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncVnodeElectIntervalMs");




1,866,674✔





2051



  tsVnodeElectIntervalMs = pItem->i32;




1,866,674✔





2052












2053



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncVnodeHeartbeatIntervalMs");




1,866,674✔





2054



  tsVnodeHeartbeatIntervalMs = pItem->i32;




1,866,674✔





2055












2056



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncMnodeElectIntervalMs");




1,866,674✔





2057



  tsMnodeElectIntervalMs = pItem->i32;




1,866,674✔





2058












2059



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncMnodeHeartbeatIntervalMs");




1,866,674✔





2060



  tsMnodeHeartbeatIntervalMs = pItem->i32;




1,866,674✔





2061












2062



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncHeartbeatTimeout");




1,866,674✔





2063



  tsHeartbeatTimeout = pItem->i32;




1,866,674✔





2064












2065



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncSnapReplMaxWaitN");




1,866,674✔





2066



  tsSnapReplMaxWaitN = pItem->i32;




1,866,674✔





2067












2068



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncLogBufferMemoryAllowed");




1,866,674✔





2069



  tsLogBufferMemoryAllowed = pItem->i64;




1,866,674✔





2070












2071



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncApplyQueueSize");




1,866,674✔





2072



  tsSyncApplyQueueSize = pItem->i64;




1,866,674✔





2073












2074



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncRoutineReportInterval");




1,866,674✔





2075



  tsRoutineReportInterval = pItem->i32;




1,866,674✔





2076












2077



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncLogHeartbeat");




1,866,674✔





2078



  tsSyncLogHeartbeat = pItem->bval;




1,866,674✔





2079












2080



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbHeartBeatIntervalSec");




1,866,674✔





2081



  tsArbHeartBeatIntervalMs = pItem->i32 * 1000;




1,866,674✔





2082












2083



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbCheckSyncIntervalSec");




1,866,674✔





2084



  tsArbCheckSyncIntervalMs = pItem->i32 * 1000;




1,866,674✔





2085












2086



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbSetAssignedTimeoutSec");




1,866,674✔





2087



  tsArbSetAssignedTimeoutMs = pItem->i32 * 1000;




1,866,674✔





2088












2089



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbHeartBeatIntervalMs");




1,866,674✔





2090



  tsArbHeartBeatIntervalMs = pItem->i32;




1,866,674✔





2091












2092



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbCheckSyncIntervalMs");




1,866,674✔





2093



  tsArbCheckSyncIntervalMs = pItem->i32;




1,866,674✔





2094












2095



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbSetAssignedTimeoutMs");




1,866,674✔





2096



  tsArbSetAssignedTimeoutMs = pItem->i32;




1,866,674✔





2097












2098



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncTimeout");




1,866,674✔





2099



  tsSyncTimeout = pItem->i32;




1,866,674✔





2100












2101



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mndSdbWriteDelta");




1,866,674✔





2102



  tsMndSdbWriteDelta = pItem->i64;




1,866,674✔





2103












2104



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mndLogRetention");




1,866,674✔





2105



  tsMndLogRetention = pItem->i64;




1,866,674✔





2106












2107



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "skipGrant");




1,866,674✔





2108



  tsMndSkipGrant = pItem->bval;




1,866,674✔





2109












2110



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableWhiteList");




1,866,674✔





2111



  tsEnableWhiteList = pItem->bval;




1,866,674✔





2112












2113



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "forceKillTrans");




1,866,674✔





2114



  tsForceKillTrans = pItem->bval;




1,866,674✔





2115



#ifdef USE_UDF










2116



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udf");




1,866,674✔





2117



  tsStartUdfd = pItem->bval;




1,866,674✔





2118












2119



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udfdResFuncs");




1,866,674✔





2120



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, sizeof(tsUdfdResFuncs)));




1,866,674✔





2121



  tstrncpy(tsUdfdResFuncs, pItem->str, sizeof(tsUdfdResFuncs));




1,866,674✔





2122












2123



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udfdLdLibPath");




1,866,674✔





2124



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, sizeof(tsUdfdLdLibPath)));




1,866,674✔





2125



  tstrncpy(tsUdfdLdLibPath, pItem->str, sizeof(tsUdfdLdLibPath));




1,866,674✔





2126



  if (tsQueryBufferSize >= 0) {




1,866,674✔





2127



    tsQueryBufferSizeBytes = tsQueryBufferSize * 1048576UL;




16,773✔





2128



  }










2129



#endif










2130



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "cacheLazyLoadThreshold");




1,866,674✔





2131



  tsCacheLazyLoadThreshold = pItem->i32;




1,866,674✔





2132












2133



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "fPrecision");




1,866,674✔





2134



  tsFPrecision = pItem->fval;




1,866,674✔





2135












2136



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "dPrecision");




1,866,674✔





2137



  tsDPrecision = pItem->fval;




1,866,674✔





2138












2139



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxRange");




1,866,674✔





2140



  tsMaxRange = pItem->i32;




1,866,674✔





2141












2142



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "curRange");




1,866,674✔





2143



  tsCurRange = pItem->i32;




1,866,674✔





2144












2145



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ifAdtFse");




1,866,674✔





2146



  tsIfAdtFse = pItem->bval;




1,866,674✔





2147












2148



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "compressor");




1,866,674✔





2149



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, sizeof(tsCompressor)));




1,866,674✔





2150



  tstrncpy(tsCompressor, pItem->str, sizeof(tsCompressor));




1,866,674✔





2151












2152



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "disableStream");




1,866,674✔





2153



  tsDisableStream = pItem->bval;




1,866,674✔





2154












2155



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamBufferSize");




1,866,674✔





2156



  tsStreamBufferSize = pItem->i32;




1,866,674✔





2157



  tsStreamBufferSizeBytes = tsStreamBufferSize * 1048576L;




1,866,674✔





2158












2159



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfMnodeStreamMgmtThreads");




1,866,674✔





2160



  tsNumOfMnodeStreamMgmtThreads = pItem->i32;




1,866,674✔





2161












2162



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfStreamMgmtThreads");




1,866,674✔





2163



  tsNumOfStreamMgmtThreads = pItem->i32;




1,866,674✔





2164












2165



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfVnodeStreamReaderThreads");




1,866,674✔





2166



  tsNumOfVnodeStreamReaderThreads = pItem->i32;




1,866,674✔





2167












2168



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfStreamTriggerThreads");




1,866,674✔





2169



  tsNumOfStreamTriggerThreads = pItem->i32;




1,866,674✔





2170












2171



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfStreamRunnerThreads");




1,866,674✔





2172



  tsNumOfStreamRunnerThreads = pItem->i32;




1,866,674✔





2173












2174



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "filterScalarMode");




1,866,674✔





2175



  tsFilterScalarMode = pItem->bval;




1,866,674✔





2176












2177



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "pqSortMemThreshold");




1,866,674✔





2178



  tsPQSortMemThreshold = pItem->i32;




1,866,674✔





2179












2180



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minDiskFreeSize");




1,866,674✔





2181



  tsMinDiskFreeSize = pItem->i64;




1,866,674✔





2182












2183



#ifdef USE_SHARED_STORAGE










2184



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ssEnabled");




1,866,674✔





2185



  tsSsEnabled = pItem->i32;




1,866,674✔





2186












2187



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ssAccessString");




1,866,674✔





2188



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, sizeof(tsSsAccessString)));




1,866,674✔





2189



  tstrncpy(tsSsAccessString, pItem->str, sizeof(tsSsAccessString));




1,866,674✔





2190












2191



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ssAutoMigrateIntervalSec");




1,866,674✔





2192



  tsSsAutoMigrateIntervalSec = pItem->i32;




1,866,674✔





2193












2194



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ssPageCacheSize");




1,866,674✔





2195



  tsSsPageCacheSize = pItem->i32;




1,866,674✔





2196












2197



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ssUploadDelaySec");




1,866,674✔





2198



  tsSsUploadDelaySec = pItem->i32;




1,866,674✔





2199



#endif










2200












2201



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "experimental");




1,866,674✔





2202



  tsExperimental = pItem->bval;




1,866,674✔





2203












2204



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryUseMemoryPool");




1,866,674✔





2205



  tsQueryUseMemoryPool = pItem->bval;




1,866,674✔





2206












2207



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "memPoolFullFunc");




1,866,674✔





2208



  tsMemPoolFullFunc = pItem->bval;




1,866,674✔





2209












2210



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "singleQueryMaxMemorySize");




1,866,674✔





2211



  tsSingleQueryMaxMemorySize = pItem->i32;




1,866,674✔





2212












2213



  // TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryBufferPoolSize");










2214



  // tsQueryBufferPoolSize = pItem->i32;










2215












2216



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minReservedMemorySize");




1,866,674✔





2217



  tsMinReservedMemorySize = pItem->i32;




1,866,674✔





2218












2219



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamNotifyMessageSize");




1,866,674✔





2220



  tsStreamNotifyMessageSize = pItem->i32;




1,866,674✔





2221












2222



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamNotifyFrameSize");




1,866,674✔





2223



  tsStreamNotifyFrameSize = pItem->i32;




1,866,674✔





2224












2225



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamBatchRequestWaitMs");




1,866,674✔





2226



  tsStreamBatchRequestWaitMs = pItem->i32;




1,866,674✔





2227












2228



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCliKeyPath");




1,866,674✔





2229



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




1,866,674✔





2230



  tstrncpy(tsTLSCliKeyPath, pItem->str, PATH_MAX);




1,866,674✔





2231












2232



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCliCertPath");




1,866,674✔





2233



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




1,866,674✔





2234



  tstrncpy(tsTLSCliCertPath, pItem->str, PATH_MAX);




1,866,674✔





2235












2236



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCaPath");




1,866,674✔





2237



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




1,866,674✔





2238



  tstrncpy(tsTLSCaPath, pItem->str, PATH_MAX);




1,866,674✔





2239












2240



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsSvrKeyPath");




1,866,674✔





2241



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




1,866,674✔





2242



  tstrncpy(tsTLSSvrKeyPath, pItem->str, PATH_MAX);




1,866,674✔





2243












2244



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsSvrCertPath");




1,866,674✔





2245



  TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX));




1,866,674✔





2246



  tstrncpy(tsTLSSvrCertPath, pItem->str, PATH_MAX);




1,866,674✔





2247












2248



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableTLS");




1,866,674✔





2249



  tsEnableTLS = pItem->bval;




1,866,674✔





2250












2251



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableSasl");




1,866,674✔





2252



  tsEnableSasl = pItem->bval;




1,866,674✔





2253



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "rpcRecvLogThreshold");




1,866,674✔





2254



  tsRpcRecvLogThreshold = pItem->i32;




1,866,674✔





2255












2256



  // GRANT_CFG_GET;










2257












2258



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "walDeleteOnCorruption");




1,866,674✔





2259



  tsWalDeleteOnCorruption = pItem->bval;




1,866,674✔





2260












2261



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,866,674✔





2262



}










2263












2264



#ifndef TD_ENTERPRISE










2265



static int32_t taosSetReleaseCfg(SConfig *pCfg) { return 0; }










2266



#else










2267



int32_t taosSetReleaseCfg(SConfig *pCfg);










2268



#endif










2269












2270



static int32_t taosSetAllDebugFlag(SConfig *pCfg, int32_t flag);










2271












2272



static int8_t tsLogCreated = 0;










2273












2274



int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDir, const char **envCmd,




2,858,167✔





2275



                      const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc) {










2276



  int32_t  code = TSDB_CODE_SUCCESS;




2,858,167✔





2277



  int32_t  lino = 0;




2,858,167✔





2278



  int32_t  mode = tsc ? LOG_MODE_TAOSC : LOG_MODE_TAOSD;




2,858,167✔





2279



  SConfig *pCfg = NULL;




2,858,167✔





2280












2281



  if (atomic_val_compare_exchange_8(&tsLogCreated, 0, 1) != 0) return 0;




2,858,167✔





2282












2283



  if (tsCfg == NULL) {




2,854,705✔





2284



    TAOS_CHECK_GOTO(osDefaultInit(), &lino, _exit);




2,854,705✔





2285



  }










2286












2287



  TAOS_CHECK_GOTO(cfgInit(&pCfg), &lino, _exit);




2,854,705✔





2288












2289



#ifdef TAOSD_INTEGRATED










2290



  mode |= LOG_MODE_TAOSD;










2291



  tsLogEmbedded = 1;










2292



#else










2293



  tsLogEmbedded = (mode & LOG_MODE_TAOSC) ? 0 : 1;




2,854,705✔





2294



#endif










2295



  TAOS_CHECK_GOTO(taosAddClientLogCfg(pCfg), &lino, _exit);




2,854,705✔





2296



  if (mode & LOG_MODE_TAOSD) {




2,854,705✔





2297



    TAOS_CHECK_GOTO(taosAddServerLogCfg(pCfg), &lino, _exit);




1,357,631✔





2298



  }










2299












2300



  if ((code = taosLoadCfg(pCfg, envCmd, cfgDir, envFile, apolloUrl)) != TSDB_CODE_SUCCESS) {




2,854,705✔





2301



    (void)printf("failed to load cfg since %s\n", tstrerror(code));




32✔





2302



    goto _exit;




32✔





2303



  }










2304












2305



  if ((code = cfgLoadFromArray(pCfg, pArgs)) != TSDB_CODE_SUCCESS) {




2,854,673✔





2306



    (void)printf("failed to load cfg from array since %s\n", tstrerror(code));




×







2307



    goto _exit;




×







2308



  }










2309












2310



  TAOS_CHECK_GOTO(taosSetClientLogCfg(pCfg), &lino, _exit);




2,854,673✔





2311



  if (mode & LOG_MODE_TAOSD) {




2,854,673✔





2312



    TAOS_CHECK_GOTO(taosSetServerLogCfg(pCfg), &lino, _exit);




1,357,599✔





2313



  }










2314












2315



  SConfigItem *pDebugItem = NULL;




2,854,673✔





2316



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pDebugItem, "debugFlag");




2,854,673✔





2317



  TAOS_CHECK_GOTO(taosSetAllDebugFlag(pCfg, pDebugItem->i32), &lino, _exit);




2,854,673✔





2318












2319



  if ((code = taosMulModeMkDir(tsLogDir, 0777, true)) != TSDB_CODE_SUCCESS) {




2,854,673✔





2320



    (void)printf("failed to create dir:%s since %s\n", tsLogDir, tstrerror(code));




56✔





2321



    goto _exit;




56✔





2322



  }










2323












2324



  if ((code = taosInitLog(logname, logFileNum, mode)) != 0) {




2,854,617✔





2325



    (void)printf("failed to init log file since %s\n", tstrerror(code));




×







2326



    goto _exit;




×







2327



  }










2328












2329



_exit:




2,854,673✔





2330



  if (TSDB_CODE_SUCCESS != code) {




2,854,705✔





2331



    (void)printf("failed to create log at %d since %s\n", lino, tstrerror(code));




88✔





2332



  }










2333












2334



  cfgCleanup(pCfg);




2,854,705✔





2335



  TAOS_RETURN(code);




2,854,705✔





2336



}










2337












2338



int32_t taosReadDataFolder(const char *cfgDir, const char **envCmd, const char *envFile, char *apolloUrl,




×







2339



                           SArray *pArgs) {










2340



  int32_t code = TSDB_CODE_SUCCESS;




×







2341



  int32_t lino = -1;




×







2342



  if (tsCfg == NULL) code = osDefaultInit();




×







2343



  if (code != 0) {




×







2344



    (void)printf("failed to init os since %s\n", tstrerror(code));




×







2345



  }










2346












2347



  SConfig *pCfg = NULL;




×







2348



  TAOS_CHECK_RETURN(cfgInit(&pCfg));




×







2349



  TAOS_CHECK_EXIT(




×







2350



      cfgAddDir(pCfg, "dataDir", tsDataDir, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










2351



  TAOS_CHECK_EXIT(cfgAddInt32(pCfg, "debugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




×







2352



                              CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










2353



  TAOS_CHECK_EXIT(cfgAddInt32(pCfg, "dDebugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER,




×







2354



                              CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










2355



  if ((code = taosLoadCfg(pCfg, envCmd, cfgDir, envFile, apolloUrl)) != 0) {




×







2356



    (void)printf("failed to load cfg since %s\n", tstrerror(code));




×







2357



    goto _exit;




×







2358



  }










2359












2360



  if ((code = cfgLoadFromArray(pCfg, pArgs)) != 0) {




×







2361



    (void)printf("failed to load cfg from array since %s\n", tstrerror(code));




×







2362



    goto _exit;




×







2363



  }










2364












2365



  TAOS_CHECK_GOTO(taosSetTfsCfg(pCfg), &lino, _exit);




×







2366












2367



  SConfigItem *pItem = NULL;




×







2368



  if ((pItem = cfgGetItem(pCfg, "dDebugFlag")) == NULL) {




×







2369



    code = TSDB_CODE_CFG_NOT_FOUND;




×







2370



    goto _exit;




×







2371



  }










2372












2373



  dDebugFlag = pItem->i32;




×







2374












2375



_exit:




×







2376



  cfgCleanup(pCfg);




×







2377



  TAOS_RETURN(code);




×







2378



}










2379












2380



static int32_t taosCheckGlobalCfg() {




2,858,211✔





2381



  SIpAddr addr = {0};




2,858,211✔





2382



  uInfo("check global fqdn:%s and port:%u", tsLocalFqdn, tsServerPort);




2,858,211✔





2383



  int32_t code = taosGetIpFromFqdn(tsEnableIpv6, tsLocalFqdn, &addr);




2,858,211✔





2384



  if (code) {




2,858,211✔





2385



    uError("failed to get ip from fqdn:%s since %s, can not be initialized", tsLocalFqdn, tstrerror(code));




×







2386



    TAOS_RETURN(TSDB_CODE_RPC_FQDN_ERROR);




×







2387



  }










2388












2389



  if (tsServerPort <= 0) {




2,858,211✔





2390



    uError("invalid server port:%u, can not be initialized", tsServerPort);




×







2391



    TAOS_RETURN(TSDB_CODE_RPC_FQDN_ERROR);




×







2392



  }










2393












2394



  if (tsMqttPort <= 0 || tsMqttPort == tsServerPort) {




2,858,211✔





2395



    uError("invalid mqtt port:%u, can not be initialized", tsMqttPort);




×







2396



    TAOS_RETURN(TSDB_CODE_RPC_FQDN_ERROR);




×







2397



  }










2398












2399



  TAOS_RETURN(TSDB_CODE_SUCCESS);




2,858,211✔





2400



}










2401












2402



static int32_t cfgInitWrapper(SConfig **pCfg) {




2,854,749✔





2403



  if (*pCfg == NULL) {




2,854,749✔





2404



    TAOS_CHECK_RETURN(cfgInit(pCfg));




2,854,749✔





2405



  }










2406



  TAOS_RETURN(TSDB_CODE_SUCCESS);




2,854,749✔





2407



}










2408












2409



int32_t setAllConfigs(SConfig *pCfg) {




510,650✔





2410



  int32_t code = 0;




510,650✔





2411



  int32_t lino = -1;




510,650✔





2412



  TAOS_CHECK_GOTO(taosSetClientCfg(tsCfg), &lino, _exit);




510,650✔





2413



  TAOS_CHECK_GOTO(taosUpdateServerCfg(tsCfg), &lino, _exit);




509,075✔





2414



  TAOS_CHECK_GOTO(taosSetServerCfg(tsCfg), &lino, _exit);




509,075✔





2415



  TAOS_CHECK_GOTO(taosSetReleaseCfg(tsCfg), &lino, _exit);




509,075✔





2416



  TAOS_CHECK_GOTO(taosSetTfsCfg(tsCfg), &lino, _exit);




509,075✔





2417



  TAOS_CHECK_GOTO(taosSetSystemCfg(tsCfg), &lino, _exit);




509,075✔





2418



  TAOS_CHECK_GOTO(taosSetFileHandlesLimit(), &lino, _exit);




509,075✔





2419



_exit:




509,075✔





2420



  TAOS_RETURN(code);




510,650✔





2421



}










2422












2423



int32_t cfgDeserialize(SArray *array, char *buf, bool isGlobal) {




637,526✔





2424



  int32_t code = TSDB_CODE_SUCCESS;




637,526✔





2425












2426



  cJSON *pRoot = cJSON_Parse(buf);




637,526✔





2427



  if (pRoot == NULL) {




637,526✔





2428



    return TSDB_CODE_OUT_OF_MEMORY;




×







2429



  }










2430



  if (isGlobal) {




637,526✔





2431



    cJSON *pItem = cJSON_GetObjectItem(pRoot, "version");




318,763✔





2432



    if (pItem == NULL) {




318,763✔





2433



      code = TSDB_CODE_OUT_OF_MEMORY;




×







2434



      goto _exit;




×







2435



    }










2436



    tsdmConfigVersion = pItem->valueint;




318,763✔





2437



  }










2438












2439



  int32_t sz = taosArrayGetSize(array);




637,526✔





2440



  cJSON  *configs = cJSON_GetObjectItem(pRoot, "configs");




637,526✔





2441



  if (configs == NULL) {




637,526✔





2442



    code = TSDB_CODE_OUT_OF_MEMORY;




×







2443



    goto _exit;




×







2444



  }










2445



  for (int i = 0; i < sz; i++) {




88,616,114✔





2446



    SConfigItem *pItem = (SConfigItem *)taosArrayGet(array, i);




87,978,588✔





2447



    cJSON       *pJson = cJSON_GetObjectItem(configs, pItem->name);




87,978,588✔





2448



    if (pJson == NULL) {




87,978,588✔





2449



      continue;




×







2450



    }










2451



    if (strcasecmp(pItem->name, "dataDir") == 0) {




87,978,588✔





2452



      if (!tsDiskIDCheckEnabled) {




318,763✔





2453



        continue;




318,763✔





2454



      }










2455



      int    sz = cJSON_GetArraySize(pJson);




×







2456



      cJSON *filed = NULL;




×







2457



      // check disk id for each dir










2458



      for (int j = 0; j < sz; j++) {




×







2459



        cJSON *diskCfgJson = cJSON_GetArrayItem(pJson, j);




×







2460



        if (diskCfgJson == NULL) {




×







2461



          code = TSDB_CODE_OUT_OF_MEMORY;




×







2462



          goto _exit;




×







2463



        }










2464












2465



        filed = cJSON_GetObjectItem(diskCfgJson, "dir");




×







2466



        if (filed == NULL) {




×







2467



          code = TSDB_CODE_OUT_OF_MEMORY;




×







2468



          goto _exit;




×







2469



        }










2470












2471



        char *dir = cJSON_GetStringValue(filed);




×







2472



        filed = cJSON_GetObjectItem(diskCfgJson, "disk_id");




×







2473



        if (filed == NULL) {




×







2474



          code = TSDB_CODE_OUT_OF_MEMORY;




×







2475



          goto _exit;




×







2476



        }










2477












2478



        int64_t actDiskID = 0;




×







2479



        int64_t expDiskID = taosStr2Int64(cJSON_GetStringValue(filed), NULL, 10);




×







2480



        if ((code = taosGetFileDiskID(dir, &actDiskID)) != 0) {




×







2481



          uError("failed to get disk id for dir:%s, since %s", dir, tstrerror(code));




×







2482



          goto _exit;




×







2483



        }










2484



        if (actDiskID != expDiskID) {




×







2485



          uError("failed to check disk id for dir:%s, actDiskID%" PRId64 ", expDiskID%" PRId64, dir, actDiskID,




×







2486



                 expDiskID);










2487



          code = TSDB_CODE_INVALID_DISK_ID;




×







2488



          goto _exit;




×







2489



        }










2490



      }










2491



      continue;




×







2492



    }










2493



    switch (pItem->dtype) {




87,659,825✔





2494



      {










2495



        case CFG_DTYPE_NONE:




×







2496



          break;




×







2497



        case CFG_DTYPE_BOOL:




19,444,543✔





2498



          pItem->bval = cJSON_IsTrue(pJson);




19,444,543✔





2499



          break;




19,444,543✔





2500



        case CFG_DTYPE_INT32:




47,495,687✔





2501



          pItem->i32 = pJson->valueint;




47,495,687✔





2502



          break;




47,495,687✔





2503



        case CFG_DTYPE_INT64:




4,462,682✔





2504



          pItem->i64 = atoll(cJSON_GetStringValue(pJson));




4,462,682✔





2505



          break;




4,462,682✔





2506



        case CFG_DTYPE_FLOAT:




1,912,578✔





2507



        case CFG_DTYPE_DOUBLE:










2508



          pItem->fval = taosStr2Float(cJSON_GetStringValue(pJson), NULL);




1,912,578✔





2509



          break;




1,912,578✔





2510



        case CFG_DTYPE_STRING:




14,344,335✔





2511



        case CFG_DTYPE_DIR:










2512



        case CFG_DTYPE_LOCALE:










2513



        case CFG_DTYPE_CHARSET:










2514



        case CFG_DTYPE_TIMEZONE:










2515



          taosMemoryFree(pItem->str);




14,344,335✔





2516



          pItem->str = taosStrdup(pJson->valuestring);




14,344,335✔





2517



          if (pItem->str == NULL) {




14,344,335✔





2518



            code = terrno;




×







2519



            goto _exit;




×







2520



          }










2521



          break;




14,344,335✔





2522



      }










2523



    }










2524



  }










2525



_exit:




637,526✔





2526



  if (code != TSDB_CODE_SUCCESS) {




637,526✔





2527



    uError("failed to deserialize config since %s", tstrerror(code));




×







2528



  }










2529



  cJSON_Delete(pRoot);




637,526✔





2530



  return code;




637,526✔





2531



}










2532












2533



int32_t stypeConfigDeserialize(SArray *array, char *buf) {




318,763✔





2534



  int32_t code = TSDB_CODE_SUCCESS;




318,763✔





2535



  cJSON  *pRoot = cJSON_Parse(buf);




318,763✔





2536



  if (pRoot == NULL) {




318,763✔





2537



    return TSDB_CODE_OUT_OF_MEMORY;




×







2538



  }










2539



  cJSON *stypes = cJSON_GetObjectItem(pRoot, "config_stypes");




318,763✔





2540



  if (stypes == NULL) {




318,763✔





2541



    code = TSDB_CODE_OUT_OF_MEMORY;




×







2542



    goto _exit;




×







2543



  }










2544



  int32_t sz = taosArrayGetSize(array);




318,763✔





2545



  for (int i = 0; i < sz; i++) {




51,320,843✔





2546



    SConfigItem *pItem = (SConfigItem *)taosArrayGet(array, i);




51,002,080✔





2547



    cJSON       *pJson = cJSON_GetObjectItem(stypes, pItem->name);




51,002,080✔





2548



    if (pJson == NULL) {




51,002,080✔





2549



      continue;




×







2550



    }










2551



    pItem->stype = pJson->valueint;




51,002,080✔





2552



  }










2553



  cJSON_Delete(pRoot);




318,763✔





2554



_exit:




318,763✔





2555



  return code;




318,763✔





2556



}










2557












2558



int32_t readStypeConfigFile(const char *path) {




1,357,599✔





2559



  int32_t   code = 0;




1,357,599✔





2560



  char      filename[CONFIG_FILE_LEN] = {0};




1,357,599✔





2561



  SArray   *array = NULL;




1,357,599✔





2562



  char     *buf = NULL;




1,357,599✔





2563



  int32_t   dataLen = 0;




1,357,599✔





2564












2565



  array = taosGetLocalCfg(tsCfg);




1,357,599✔





2566



  if (array == NULL) {




1,357,599✔





2567



    code = TSDB_CODE_OUT_OF_MEMORY;




×







2568



    goto _exit;




×







2569



  }










2570












2571



  snprintf(filename, sizeof(filename), "%s%sdnode%sconfig%sstype.json", path, TD_DIRSEP, TD_DIRSEP, TD_DIRSEP);




1,357,599✔





2572



  uInfo("start to read stype config file:%s", filename);




1,357,599✔





2573



  if (!taosCheckExistFile(filename)) {




1,357,599✔





2574



    uInfo("stype config file:%s does not exist", filename);




1,038,836✔





2575



    goto _exit;




1,038,836✔





2576



  }










2577












2578



  // Use taosReadCfgFile for automatic decryption support










2579



  code = taosReadCfgFile(filename, &buf, &dataLen);




318,763✔





2580



  if (code != TSDB_CODE_SUCCESS) {




318,763✔





2581



    uError("failed to read stype config file:%s since %s", filename, tstrerror(code));




×







2582



    goto _exit;




×







2583



  }










2584












2585



  if (buf == NULL || dataLen == 0) {




318,763✔





2586



    uInfo("stype config file:%s is empty", filename);




×







2587



    goto _exit;




×







2588



  }










2589












2590



  // Deserialize config (buf is already null-terminated or has padding zeros)










2591



  code = stypeConfigDeserialize(array, buf);




318,763✔





2592



  if (code != TSDB_CODE_SUCCESS) {




318,763✔





2593



    uError("failed to deserialize stype config file:%s since %s", filename, tstrerror(code));




×







2594



    goto _exit;




×







2595



  }










2596












2597



_exit:




1,351,302✔





2598



  if (code != TSDB_CODE_SUCCESS) {




1,357,599✔





2599



    uError("failed to read stype config file:%s since %s", filename, tstrerror(code));




×







2600



  }










2601



  taosMemoryFree(buf);




1,357,599✔





2602



  TAOS_RETURN(code);




1,357,599✔





2603



}










2604












2605



int32_t readCfgFile(const char *path, bool isGlobal) {




2,715,198✔





2606



  int32_t code = 0;




2,715,198✔





2607



  char    filename[CONFIG_FILE_LEN] = {0};




2,715,198✔





2608



  SArray *array = NULL;




2,715,198✔





2609



  char   *buf = NULL;




2,715,198✔





2610



  int32_t dataLen = 0;




2,715,198✔





2611












2612



  if (isGlobal) {




2,715,198✔





2613



    array = taosGetGlobalCfg(tsCfg);




1,357,599✔





2614



    snprintf(filename, sizeof(filename), "%s%sdnode%sconfig%sglobal.json", path, TD_DIRSEP, TD_DIRSEP, TD_DIRSEP);




1,357,599✔





2615



  } else {










2616



    array = taosGetLocalCfg(tsCfg);




1,357,599✔





2617



    snprintf(filename, sizeof(filename), "%s%sdnode%sconfig%slocal.json", path, TD_DIRSEP, TD_DIRSEP, TD_DIRSEP);




1,357,599✔





2618



  }










2619



  uInfo("start to read config file:%s", filename);




2,715,198✔





2620












2621



  if (!taosCheckExistFile(filename)) {




2,715,198✔





2622



    uInfo("config file:%s does not exist", filename);




2,077,672✔





2623



    TAOS_RETURN(TSDB_CODE_SUCCESS);




2,077,672✔





2624



  }










2625












2626



  // Use taosReadCfgFile for automatic decryption support










2627



  code = taosReadCfgFile(filename, &buf, &dataLen);




637,526✔





2628



  if (code != TSDB_CODE_SUCCESS) {




637,526✔





2629



    uError("failed to read config file:%s since %s", filename, tstrerror(code));




×







2630



    goto _exit;




×







2631



  }










2632












2633



  if (buf == NULL || dataLen == 0) {




637,526✔





2634



    uInfo("config file:%s is empty", filename);




×







2635



    TAOS_RETURN(TSDB_CODE_SUCCESS);




×







2636



  }










2637












2638



  // Deserialize config (buf is already null-terminated or has padding zeros)










2639



  code = cfgDeserialize(array, buf, isGlobal);




637,526✔





2640



  if (code != TSDB_CODE_SUCCESS) {




637,526✔





2641



    uError("failed to deserialize config from %s since %s", filename, tstrerror(code));




×







2642



    goto _exit;




×







2643



  }










2644












2645



_exit:




637,526✔





2646



  if (code != TSDB_CODE_SUCCESS) {




637,526✔





2647



    uError("failed to read config from %s since %s", filename, tstrerror(code));




×







2648



  }










2649



  taosMemoryFree(buf);




637,526✔





2650



  TAOS_RETURN(code);




637,526✔





2651



}










2652












2653



int32_t tryLoadCfgFromDataDir(SConfig *pCfg) {




1,357,599✔





2654



  int32_t code = 0;




1,357,599✔





2655



  code = readCfgFile(tsDataDir, true);




1,357,599✔





2656



  if (code != TSDB_CODE_SUCCESS) {




1,357,599✔





2657



    uError("failed to read global config from %s since %s", tsDataDir, tstrerror(code));




×







2658



    TAOS_RETURN(code);




×







2659



  }










2660



    uInfo("load config from tsDataDir:%s", tsDataDir);




1,357,599✔





2661



    code = readCfgFile(tsDataDir, false);




1,357,599✔





2662



    if (code != TSDB_CODE_SUCCESS) {




1,357,599✔





2663



      uError("failed to read local config from %s since %s", tsDataDir, tstrerror(code));




×







2664



      TAOS_RETURN(code);




×







2665



    }










2666



    code = readStypeConfigFile(tsDataDir);




1,357,599✔





2667



    if (code != TSDB_CODE_SUCCESS) {




1,357,599✔





2668



      uError("failed to read stype config from %s since %s", tsDataDir, tstrerror(code));




×







2669



      TAOS_RETURN(code);




×







2670



  }










2671



  TAOS_RETURN(code);




1,357,599✔





2672



}










2673



int32_t taosPreLoadCfg(const char *cfgDir, const char **envCmd, const char *envFile, char *apolloUrl, SArray *pArgs,




2,858,211✔





2674



                       bool tsc) {










2675



  if (tsCfg != NULL) TAOS_RETURN(TSDB_CODE_SUCCESS);




2,858,211✔





2676












2677



  int32_t code = TSDB_CODE_SUCCESS;




2,854,749✔





2678



  int32_t lino = -1;




2,854,749✔





2679












2680



  TAOS_CHECK_GOTO(cfgInitWrapper(&tsCfg), &lino, _exit);




2,854,749✔





2681












2682



  if (tsc) {




2,854,749✔





2683



    TAOS_CHECK_GOTO(taosAddClientCfg(tsCfg), &lino, _exit);




1,497,150✔





2684



    TAOS_CHECK_GOTO(taosAddClientLogCfg(tsCfg), &lino, _exit);




1,497,150✔





2685



  } else {










2686



    TAOS_CHECK_GOTO(taosAddClientCfg(tsCfg), &lino, _exit);




1,357,599✔





2687



    TAOS_CHECK_GOTO(taosAddServerCfg(tsCfg), &lino, _exit);




1,357,599✔





2688



    TAOS_CHECK_GOTO(taosAddClientLogCfg(tsCfg), &lino, _exit);




1,357,599✔





2689



    TAOS_CHECK_GOTO(taosAddServerLogCfg(tsCfg), &lino, _exit);




1,357,599✔





2690



  }










2691












2692



  TAOS_CHECK_GOTO(taosAddSystemCfg(tsCfg), &lino, _exit);




2,854,749✔





2693












2694



  if ((code = taosLoadCfg(tsCfg, envCmd, cfgDir, envFile, apolloUrl)) != 0) {




2,854,749✔





2695



    (void)printf("failed to load cfg since %s\n", tstrerror(code));




×







2696



    cfgCleanup(tsCfg);




×







2697



    tsCfg = NULL;




×







2698



    TAOS_RETURN(code);




×







2699



  }










2700












2701



  if ((code = cfgLoadFromArray(tsCfg, pArgs)) != 0) {




2,854,749✔





2702



    (void)printf("failed to load cfg from array since %s\n", tstrerror(code));




×







2703



    cfgCleanup(tsCfg);




×







2704



    tsCfg = NULL;




×







2705



    TAOS_RETURN(code);




×







2706



  }










2707



  if (!tsc) {




2,854,749✔





2708



    TAOS_CHECK_GOTO(taosSetTfsCfg(tsCfg), &lino, _exit);




1,357,599✔





2709



  }










2710












2711



_exit:




2,854,749✔





2712



  if (code != TSDB_CODE_SUCCESS) {




2,854,749✔





2713



    cfgCleanup(tsCfg);




×







2714



    tsCfg = NULL;




×







2715



    (void)printf("failed to pre load cfg at %d since %s\n", lino, tstrerror(code));




×







2716



  }










2717



  TAOS_RETURN(code);




2,854,749✔





2718



}










2719












2720



int32_t taosApplyCfg(const char *cfgDir, const char **envCmd, const char *envFile, char *apolloUrl, SArray *pArgs,




2,858,211✔





2721



                     bool tsc) {










2722



  int32_t code = TSDB_CODE_SUCCESS;




2,858,211✔





2723



  int32_t lino = -1;




2,858,211✔





2724



  if (!tsc) {




2,858,211✔





2725



    TAOS_CHECK_GOTO(taosSetTfsCfg(tsCfg), &lino, _exit);




1,357,599✔





2726



  }










2727












2728



  if (tsc) {




2,858,211✔





2729



    TAOS_CHECK_GOTO(taosSetClientLogCfg(tsCfg), &lino, _exit);




1,500,612✔





2730



    TAOS_CHECK_GOTO(taosSetClientCfg(tsCfg), &lino, _exit);




1,500,612✔





2731



  } else {










2732



    TAOS_CHECK_GOTO(taosSetClientLogCfg(tsCfg), &lino, _exit);




1,357,599✔





2733



    TAOS_CHECK_GOTO(taosSetClientCfg(tsCfg), &lino, _exit);




1,357,599✔





2734



    TAOS_CHECK_GOTO(taosUpdateServerCfg(tsCfg), &lino, _exit);




1,357,599✔





2735



    TAOS_CHECK_GOTO(taosSetServerCfg(tsCfg), &lino, _exit);




1,357,599✔





2736



    TAOS_CHECK_GOTO(taosSetReleaseCfg(tsCfg), &lino, _exit);




1,357,599✔





2737



  }










2738












2739



  TAOS_CHECK_GOTO(taosSetSystemCfg(tsCfg), &lino, _exit);




2,858,211✔





2740



  TAOS_CHECK_GOTO(taosSetFileHandlesLimit(), &lino, _exit);




2,858,211✔





2741












2742



  SConfigItem *pItem = cfgGetItem(tsCfg, "debugFlag");




2,858,211✔





2743



  if (NULL == pItem) {




2,858,211✔





2744



    (void)printf("debugFlag not found in cfg\n");




×







2745



    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);




×







2746



  }










2747



  TAOS_CHECK_GOTO(taosSetAllDebugFlag(tsCfg, pItem->i32), &lino, _exit);




2,858,211✔





2748












2749



  cfgDumpCfg(tsCfg, tsc, false);




2,858,211✔





2750



  TAOS_CHECK_GOTO(taosCheckGlobalCfg(), &lino, _exit);




2,858,211✔





2751












2752



  code = initTimezoneInfo();




2,858,211✔





2753



  if (code != TSDB_CODE_SUCCESS) {




2,858,211✔





2754



    return code;




×







2755



  }










2756



_exit:




2,858,211✔





2757



  if (code != TSDB_CODE_SUCCESS) {




2,858,211✔





2758



    uError("failed to apply cfg at %d since %s", lino, tstrerror(code));




×







2759



  }










2760



  TAOS_RETURN(code);




2,858,211✔





2761



}










2762












2763



int32_t taosInitCfg(const char *cfgDir, const char **envCmd, const char *envFile, char *apolloUrl, SArray *pArgs,




1,508,170✔





2764



                    bool tsc) {










2765



  int32_t code = TSDB_CODE_SUCCESS;




1,508,170✔





2766



  int32_t lino = -1;




1,508,170✔





2767












2768



  TAOS_CHECK_GOTO(taosPreLoadCfg(cfgDir, envCmd, envFile, apolloUrl, pArgs, tsc), &lino, _exit);




1,508,170✔





2769



  if (!tsc) {




1,508,170✔





2770



    TAOS_CHECK_GOTO(tryLoadCfgFromDataDir(tsCfg), &lino, _exit);




7,558✔





2771



  }










2772



  TAOS_CHECK_GOTO(taosApplyCfg(cfgDir, envCmd, envFile, apolloUrl, pArgs, tsc), &lino, _exit);




1,508,170✔





2773



_exit:




1,508,170✔





2774



  if (TSDB_CODE_SUCCESS != code) {




1,508,170✔





2775



    cfgCleanup(tsCfg);




×







2776



    tsCfg = NULL;




×







2777



    (void)printf("failed to init cfg at %d since %s\n", lino, tstrerror(code));




×







2778



  }










2779












2780



  TAOS_RETURN(code);




1,508,170✔





2781



}










2782












2783



void taosCleanupCfg() {




2,859,054✔





2784



  if (tsCfg) {




2,859,054✔





2785



    cfgCleanup(tsCfg);




2,856,124✔





2786



    tsCfg = NULL;




2,856,124✔





2787



    cleanupTimezoneInfo();




2,856,124✔





2788



  }










2789



}




2,859,054✔





2790












2791



typedef struct {










2792



  const char *optionName;










2793



  void       *optionVar;










2794



} OptionNameAndVar;










2795












2796



static int32_t taosCfgSetOption(OptionNameAndVar *pOptions, int32_t optionSize, SConfigItem *pItem, bool isDebugflag) {




1,125,751✔





2797



  int32_t code = TSDB_CODE_CFG_NOT_FOUND;




1,125,751✔





2798



  char   *name = pItem->name;




1,125,751✔





2799



  for (int32_t d = 0; d < optionSize; ++d) {




18,109,870✔





2800



    const char *optName = pOptions[d].optionName;




17,552,807✔





2801



    if (taosStrcasecmp(name, optName) != 0) continue;




17,552,807✔





2802



    code = TSDB_CODE_SUCCESS;




568,688✔





2803



    switch (pItem->dtype) {




568,688✔





2804



      case CFG_DTYPE_BOOL: {




24,457✔





2805



        int32_t flag = pItem->i32;




24,457✔





2806



        bool   *pVar = pOptions[d].optionVar;




24,457✔





2807



        uInfo("%s set from %d to %d", optName, *pVar, flag);




24,457✔





2808



        *pVar = flag;




24,457✔





2809



      } break;




24,457✔





2810



      case CFG_DTYPE_INT32: {




542,380✔





2811



        int32_t  flag = pItem->i32;




542,380✔





2812



        int32_t *pVar = pOptions[d].optionVar;




542,380✔





2813



        uInfo("%s set from %d to %d", optName, *pVar, flag);




542,380✔





2814



        *pVar = flag;




542,380✔





2815












2816



        if (isDebugflag) {




542,380✔





2817



          TAOS_CHECK_RETURN(taosSetDebugFlag(pOptions[d].optionVar, optName, flag));




11,625✔





2818



        }










2819



      } break;




542,380✔





2820



      case CFG_DTYPE_INT64: {




1,851✔





2821



        int64_t  flag = pItem->i64;




1,851✔





2822



        int64_t *pVar = pOptions[d].optionVar;




1,851✔





2823



        uInfo("%s set from %" PRId64 " to %" PRId64, optName, *pVar, flag);




1,851✔





2824



        *pVar = flag;




1,851✔





2825



      } break;




1,851✔





2826



      case CFG_DTYPE_FLOAT:




×







2827



      case CFG_DTYPE_DOUBLE: {










2828



        float  flag = pItem->fval;




×







2829



        float *pVar = pOptions[d].optionVar;




×







2830



        uInfo("%s set from %f to %f", optName, *pVar, flag);




×







2831



        *pVar = flag;




×







2832



      } break;




×







2833



      case CFG_DTYPE_STRING:




×







2834



      case CFG_DTYPE_DIR:










2835



      case CFG_DTYPE_LOCALE:










2836



      case CFG_DTYPE_CHARSET:










2837



      case CFG_DTYPE_TIMEZONE: {










2838



        if (strcasecmp(pItem->name, "slowLogExceptDb") == 0) {




×







2839



          TAOS_CHECK_RETURN(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_DB_NAME_LEN));




×







2840



          tstrncpy(tsSlowLogExceptDb, pItem->str, TSDB_DB_NAME_LEN);




×







2841



        } else {










2842



          uError("not support string type for %s", optName);




×







2843



          code = TSDB_CODE_INVALID_CFG;




×







2844



          break;




×







2845



        }










2846



        uInfo("%s set to %s", optName, pItem->str);




×







2847



      } break;




×







2848



      default:




×







2849



        code = TSDB_CODE_INVALID_CFG;




×







2850



        break;




×







2851



    }










2852












2853



    break;




568,688✔





2854



  }










2855












2856



  TAOS_RETURN(code);




1,125,751✔





2857



}










2858












2859



extern void tsdbAlterNumCompactThreads();










2860












2861



static int32_t taosCfgDynamicOptionsForServer(SConfig *pCfg, const char *name) {




92,548✔





2862



  int32_t code = TSDB_CODE_SUCCESS;




92,548✔





2863



  int32_t lino = -1;




92,548✔





2864












2865



  if (strcasecmp("timezone", name) == 0) {




92,548✔





2866



    TAOS_RETURN(TSDB_CODE_SUCCESS);




252✔





2867



  }










2868












2869



  if (strcasecmp(name, "resetlog") == 0) {




92,296✔





2870



    // trigger, no item in cfg










2871



    taosResetLog();




242✔





2872



    cfgDumpCfg(tsCfg, 0, false);




242✔





2873



    TAOS_RETURN(TSDB_CODE_SUCCESS);




242✔





2874



  }










2875












2876



  cfgLock(pCfg);




92,054✔





2877












2878



  SConfigItem *pItem = cfgGetItem(pCfg, name);




92,054✔





2879



  if (!pItem || (pItem->dynScope == CFG_DYN_CLIENT)) {




92,054✔





2880



    uError("failed to config:%s, not support", name);




×







2881



    code = TSDB_CODE_INVALID_CFG;




×







2882



    goto _exit;




×







2883



  }










2884












2885



  if (strncasecmp(name, "debugFlag", 9) == 0) {




92,054✔





2886



    code = taosSetAllDebugFlag(pCfg, pItem->i32);




21,340✔





2887



    goto _exit;




21,340✔





2888



  }










2889












2890



  if (strncasecmp(name, "enableCoreFile", 9) == 0) {




70,714✔





2891



    tsEnableCoreFile = pItem->bval;




×







2892



    taosSetCoreDump(tsEnableCoreFile);




×







2893



    uInfo("%s set to %d", name, tsEnableCoreFile);




×







2894



    goto _exit;




×







2895



  }










2896












2897



  if (strcasecmp("slowLogScope", name) == 0) {




70,714✔





2898



    int32_t scope = 0;




×







2899



    TAOS_CHECK_GOTO(taosSetSlowLogScope(pItem->str, &scope), &lino, _exit);




×







2900



    tsSlowLogScope = scope;




×







2901



    code = TSDB_CODE_SUCCESS;




×







2902



    goto _exit;




×







2903



  }










2904












2905



  if (strcasecmp("slowLogExceptDb", name) == 0) {




70,714✔





2906



    tstrncpy(tsSlowLogExceptDb, pItem->str, TSDB_DB_NAME_LEN);




×







2907



    code = TSDB_CODE_SUCCESS;




×







2908



    goto _exit;




×







2909



  }










2910



  if (strcasecmp(name, "dataDir") == 0) {




70,714✔





2911



    code = TSDB_CODE_SUCCESS;




×







2912



    goto _exit;




×







2913



  }










2914



  if (strcasecmp("rpcQueueMemoryAllowed", name) == 0) {




70,714✔





2915



    tsQueueMemoryAllowed = cfgGetItem(pCfg, "rpcQueueMemoryAllowed")->i64 * QUEUE_MEMORY_USAGE_RATIO;




84✔





2916



    tsApplyMemoryAllowed = cfgGetItem(pCfg, "rpcQueueMemoryAllowed")->i64 * (1 - QUEUE_MEMORY_USAGE_RATIO);




84✔





2917



    code = TSDB_CODE_SUCCESS;




84✔





2918



    goto _exit;




84✔





2919



  }










2920












2921



  if (strcasecmp(name, "numOfCompactThreads") == 0) {




70,630✔





2922



#ifdef TD_ENTERPRISE










2923



    tsNumOfCompactThreads = pItem->i32;




×







2924



    code = TSDB_CODE_SUCCESS;




×







2925



    // tsdbAlterNumCompactThreads();










2926



#else










2927



    code = TSDB_CODE_INVALID_CFG;










2928



#endif










2929



    goto _exit;




×







2930



  }










2931



#ifdef TD_ENTERPRISE










2932



  if (strcasecmp(name, "authServer") == 0) {




70,630✔





2933



    tsAuthServer = pItem->bval;




×







2934



    goto _exit;




×







2935



  }










2936



  if (strcasecmp(name, "authReq") == 0) {




70,630✔





2937



    tsAuthReq = pItem->bval;




×







2938



    goto _exit;




×







2939



  }










2940



  if (strcasecmp(name, "authReqInterval") == 0) {




70,630✔





2941



    tsAuthReqInterval = pItem->i32;




×







2942



    goto _exit;




×







2943



  }










2944



  if (strcasecmp(name, "authReqUrl") == 0) {




70,630✔





2945



    TAOS_CHECK_GOTO(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_FQDN_LEN), &lino, _exit);




×







2946



    tstrncpy(tsAuthReqUrl, pItem->str, TSDB_FQDN_LEN);




×







2947



    goto _exit;




×







2948



  }










2949



#endif










2950












2951



  if (strcasecmp(name, "minReservedMemorySize") == 0) {




70,630✔





2952



    tsMinReservedMemorySize = pItem->i32;




252✔





2953



    code = taosMemoryPoolCfgUpdateReservedSize(tsMinReservedMemorySize);




252✔





2954



    goto _exit;




252✔





2955



  }










2956












2957



  if (strcasecmp(name, "streamBufferSize") == 0) {




70,378✔





2958



    tsStreamBufferSize = pItem->i32;




287✔





2959



    atomic_store_64(&tsStreamBufferSizeBytes, tsStreamBufferSize * 1048576);




287✔





2960



    goto _exit;




287✔





2961



  }










2962












2963



  {  //  'bool/int32_t/int64_t/float/double' variables with general modification function










2964



    static OptionNameAndVar debugOptions[] = {










2965



        {"dDebugFlag", &dDebugFlag},       {"vDebugFlag", &vDebugFlag},     {"mDebugFlag", &mDebugFlag},










2966



        {"wDebugFlag", &wDebugFlag},       {"azDebugFlag", &azDebugFlag},   {"sDebugFlag", &sDebugFlag},










2967



        {"tsdbDebugFlag", &tsdbDebugFlag}, {"tqDebugFlag", &tqDebugFlag},   {"fsDebugFlag", &fsDebugFlag},










2968



        {"udfDebugFlag", &udfDebugFlag},   {"smaDebugFlag", &smaDebugFlag}, {"idxDebugFlag", &idxDebugFlag},










2969



        {"tdbDebugFlag", &tdbDebugFlag},   {"tmrDebugFlag", &tmrDebugFlag}, {"uDebugFlag", &uDebugFlag},










2970



        {"smaDebugFlag", &smaDebugFlag},   {"rpcDebugFlag", &rpcDebugFlag}, {"qDebugFlag", &qDebugFlag},










2971



        {"metaDebugFlag", &metaDebugFlag}, {"stDebugFlag", &stDebugFlag},   {"bseDebugFlag", &bseDebugFlag},










2972



        {"sndDebugFlag", &sndDebugFlag},   {"bndDebugFlag", &bndDebugFlag}, {"tqClientDebugFlag", &tqClientDebugFlag},










2973



        {"tssDebugFlag", &tssDebugFlag},   {"xndDebugFlag", &xndDebugFlag},










2974



    };










2975












2976



    static OptionNameAndVar options[] = {{"audit", &tsEnableAudit},










2977



                                         {"asynclog", &tsAsyncLog},










2978



                                         {"countAlwaysReturnValue", &tsCountAlwaysReturnValue},










2979



                                         {"enableWhiteList", &tsEnableWhiteList},










2980



                                         {"statusInterval", &tsStatusInterval},










2981



                                         {"statusIntervalMs", &tsStatusIntervalMs},










2982



                                         {"statusSRTimeoutMs", &tsStatusSRTimeoutMs},










2983



                                         {"statusTimeoutMs", &tsStatusTimeoutMs},










2984



                                         {"telemetryReporting", &tsEnableTelem},










2985



                                         {"monitor", &tsEnableMonitor},










2986



                                         {"monitorInterval", &tsMonitorInterval},










2987



                                         {"monitorComp", &tsMonitorComp},










2988



                                         {"monitorForceV2", &tsMonitorForceV2},










2989



                                         {"monitorLogProtocol", &tsMonitorLogProtocol},










2990



                                         {"monitorMaxLogs", &tsMonitorMaxLogs},










2991



                                         {"auditCreateTable", &tsEnableAuditCreateTable},










2992



                                         {"auditInterval", &tsAuditInterval},










2993



                                         {"auditLevel", &tsAuditLevel},










2994



                                         {"auditHttps", &tsAuditHttps},










2995



                                         {"auditUseToken", &tsAuditUseToken},










2996



                                         {"auditSaveInSelf", &tsAuditSaveInSelf},










2997



                                         {"slowLogThreshold", &tsSlowLogThreshold},










2998



                                         {"compressMsgSize", &tsCompressMsgSize},










2999



                                         {"compressor", &tsCompressor},










3000



                                         {"dPrecision", &tsDPrecision},










3001



                                         {"fPrecision", &tsFPrecision},










3002



                                         {"maxRange", &tsMaxRange},










3003



                                         {"maxTsmaNum", &tsMaxTsmaNum},










3004



                                         {"queryRsmaTolerance", &tsQueryRsmaTolerance},










3005



                                         {"uptimeInterval", &tsUptimeInterval},










3006












3007



                                         {"slowLogMaxLen", &tsSlowLogMaxLen},










3008



                                         {"slowLogScope", &tsSlowLogScope},










3009



                                         {"slowLogExceptDb", &tsSlowLogExceptDb},










3010












3011



                                         {"mndSdbWriteDelta", &tsMndSdbWriteDelta},










3012



                                         {"minDiskFreeSize", &tsMinDiskFreeSize},










3013



                                         {"randErrorChance", &tsRandErrChance},










3014



                                         {"randErrorDivisor", &tsRandErrDivisor},










3015



                                         {"randErrorScope", &tsRandErrScope},










3016



                                         {"syncLogBufferMemoryAllowed", &tsLogBufferMemoryAllowed},










3017



                                         {"syncApplyQueueSize", &tsSyncApplyQueueSize},










3018



                                         {"syncHeartbeatInterval", &tsHeartbeatInterval},










3019



                                         {"syncElectInterval", &tsElectInterval},










3020



                                         {"syncVnodeHeartbeatIntervalMs", &tsVnodeHeartbeatIntervalMs},










3021



                                         {"syncVnodeElectIntervalMs", &tsVnodeElectIntervalMs},










3022



                                         {"syncMnodeHeartbeatIntervalMs", &tsMnodeHeartbeatIntervalMs},










3023



                                         {"syncMnodeElectIntervalMs", &tsMnodeElectIntervalMs},










3024



                                         {"syncHeartbeatTimeout", &tsHeartbeatTimeout},










3025



                                         {"syncSnapReplMaxWaitN", &tsSnapReplMaxWaitN},










3026



                                         {"syncRoutineReportInterval", &tsRoutineReportInterval},










3027



                                         {"syncLogHeartbeat", &tsSyncLogHeartbeat},










3028



                                         {"syncTimeout", &tsSyncTimeout},










3029



                                         {"walFsyncDataSizeLimit", &tsWalFsyncDataSizeLimit},










3030












3031



                                         {"numOfCores", &tsNumOfCores},










3032












3033



                                         {"enableCoreFile", &tsEnableCoreFile},










3034












3035



                                         {"telemetryInterval", &tsTelemInterval},










3036












3037



                                         {"cacheLazyLoadThreshold", &tsCacheLazyLoadThreshold},










3038












3039



                                         {"retentionSpeedLimitMB", &tsRetentionSpeedLimitMB},










3040



                                         {"ttlChangeOnWrite", &tsTtlChangeOnWrite},










3041












3042



                                         {"logKeepDays", &tsLogKeepDays},










3043



                                         {"metaEntryCacheSize", &tsMetaEntryCacheSize},










3044



                                         {"mqRebalanceInterval", &tsMqRebalanceInterval},










3045



                                         {"numOfLogLines", &tsNumOfLogLines},










3046



                                         {"queryRspPolicy", &tsQueryRspPolicy},










3047



                                         {"timeseriesThreshold", &tsTimeSeriesThreshold},










3048



                                         {"tmqMaxTopicNum", &tmqMaxTopicNum},










3049



                                         {"transPullupInterval", &tsTransPullupInterval},










3050



                                         {"compactPullupInterval", &tsCompactPullupInterval},










3051



                                         {"queryTrimIntervalSec", &tsQueryTrimIntervalSec},










3052



                                         {"querySsMigrateIntervalSec", &tsQuerySsMigrateIntervalSec},










3053



                                         {"trimVDbIntervalSec", &tsTrimVDbIntervalSec},










3054



                                         {"ttlBatchDropNum", &tsTtlBatchDropNum},










3055



                                         {"ttlFlushThreshold", &tsTtlFlushThreshold},










3056



                                         {"ttlPushInterval", &tsTtlPushIntervalSec},










3057



                                         {"ttlUnit", &tsTtlUnit},










3058



                                         {"ssAutoMigrateIntervalSec", &tsSsAutoMigrateIntervalSec},










3059



                                         {"ssBlockCacheSize", &tsSsBlockCacheSize},










3060



                                         {"ssPageCacheSize", &tsSsPageCacheSize},










3061



                                         {"ssUploadDelaySec", &tsSsUploadDelaySec},










3062



                                         {"mndLogRetention", &tsMndLogRetention},










3063



                                         {"supportVnodes", &tsNumOfSupportVnodes},










3064



                                         {"experimental", &tsExperimental},










3065












3066



                                         {"numOfRpcSessions", &tsNumOfRpcSessions},










3067



                                         {"shellActivityTimer", &tsShellActivityTimer},










3068



                                         {"readTimeout", &tsReadTimeout},










3069



                                         {"safetyCheckLevel", &tsSafetyCheckLevel},










3070



                                         {"bypassFlag", &tsBypassFlag},










3071



                                         {"arbHeartBeatIntervalSec", &tsArbHeartBeatIntervalSec},










3072



                                         {"arbCheckSyncIntervalSec", &tsArbCheckSyncIntervalSec},










3073



                                         {"arbSetAssignedTimeoutSec", &tsArbSetAssignedTimeoutSec},










3074



                                         {"arbHeartBeatIntervalMs", &tsArbHeartBeatIntervalMs},










3075



                                         {"arbCheckSyncIntervalMs", &tsArbCheckSyncIntervalMs},










3076



                                         {"arbSetAssignedTimeoutMs", &tsArbSetAssignedTimeoutMs},










3077



                                         {"queryNoFetchTimeoutSec", &tsQueryNoFetchTimeoutSec},










3078



                                         {"enableStrongPassword", &tsEnableStrongPassword},










3079



                                         {"enableAdvancedSecurity", &tsEnableAdvancedSecurity},










3080



                                         {"enableGrantLegacySyntax", &tsEnableGrantLegacySyntax},










3081



                                         {"enableMetrics", &tsEnableMetrics},










3082



                                         {"metricsInterval", &tsMetricsInterval},










3083



                                         {"metricsLevel", &tsMetricsLevel},










3084



                                         {"forceKillTrans", &tsForceKillTrans},










3085



                                         {"enableTLS", &tsEnableTLS},










3086



                                         {"enableSasl", &tsEnableSasl},










3087



                                         {"rpcRecvLogThreshold", &tsRpcRecvLogThreshold},










3088



                                         {"tagFilterCache", &tsTagFilterCache},










3089



                                         {"stableTagFilterCache", &tsStableTagFilterCache}};










3090












3091



    if ((code = taosCfgSetOption(debugOptions, tListLen(debugOptions), pItem, true)) != TSDB_CODE_SUCCESS) {




70,091✔





3092



      code = taosCfgSetOption(options, tListLen(options), pItem, false);




58,466✔





3093



    }










3094



  }










3095












3096



_exit:




92,054✔





3097



  cfgUnLock(pCfg);




92,054✔





3098



  TAOS_RETURN(code);




92,054✔





3099



}










3100












3101



static int32_t taosCfgDynamicOptionsForClient(SConfig *pCfg, const char *name) {




503,120✔





3102



  int32_t code = TSDB_CODE_SUCCESS;




503,120✔





3103



  int32_t lino = 0;




503,120✔





3104












3105



  if (strcasecmp("charset", name) == 0 || strcasecmp("timezone", name) == 0) {




503,120✔





3106



    TAOS_RETURN(TSDB_CODE_SUCCESS);




476✔





3107



  }










3108












3109



  cfgLock(pCfg);




502,644✔





3110












3111



  SConfigItem *pItem = cfgGetItem(pCfg, name);




502,644✔





3112



  if ((pItem == NULL) || pItem->dynScope == CFG_DYN_SERVER) {




502,644✔





3113



    uError("failed to config:%s, not support", name);




×







3114



    code = TSDB_CODE_INVALID_CFG;




×







3115



    goto _out;




×







3116



  }










3117












3118



  bool matched = false;




502,644✔





3119












3120



  int32_t len = strlen(name);




502,644✔





3121



  char    lowcaseName[CFG_NAME_MAX_LEN + 1] = {0};




502,644✔





3122



  (void)strntolower(lowcaseName, name, TMIN(CFG_NAME_MAX_LEN, len));




502,644✔





3123












3124



  switch (lowcaseName[0]) {




502,644✔





3125



    case 'd': {




16✔





3126



      if (strcasecmp("debugFlag", name) == 0) {




16✔





3127



        code = taosSetAllDebugFlag(pCfg, pItem->i32);




16✔





3128



        matched = true;




16✔





3129



      }










3130



      break;




16✔





3131



    }










3132



    case 'e': {




170✔





3133



      if (strcasecmp("enableCoreFile", name) == 0) {




170✔





3134



        tsEnableCoreFile = pItem->bval;




×







3135



        taosSetCoreDump(tsEnableCoreFile);




×







3136



        uInfo("%s set to %d", name, tsEnableCoreFile);




×







3137



        matched = true;




×







3138



      }










3139



      break;




170✔





3140



    }










3141



    case 'f': {




32✔





3142



      if (strcasecmp("fqdn", name) == 0) {




32✔





3143



        SConfigItem *pFqdnItem = cfgGetItem(pCfg, "fqdn");




16✔





3144



        SConfigItem *pServerPortItem = cfgGetItem(pCfg, "serverPort");




16✔





3145



        SConfigItem *pFirstEpItem = cfgGetItem(pCfg, "firstEp");




16✔





3146



        if (pFqdnItem == NULL || pServerPortItem == NULL || pFirstEpItem == NULL) {




16✔





3147



          uError("failed to get fqdn or serverPort or firstEp from cfg");




×







3148



          code = TSDB_CODE_CFG_NOT_FOUND;




×







3149



          goto _out;




×







3150



        }










3151












3152



        tstrncpy(tsLocalFqdn, pFqdnItem->str, TSDB_FQDN_LEN);




16✔





3153



        tsServerPort = (uint16_t)pServerPortItem->i32;




16✔





3154



        (void)snprintf(tsLocalEp, sizeof(tsLocalEp), "%s:%u", tsLocalFqdn, tsServerPort);




16✔





3155












3156



        char defaultFirstEp[TSDB_EP_LEN] = {0};




16✔





3157



        (void)snprintf(defaultFirstEp, TSDB_EP_LEN, "%s:%u", tsLocalFqdn, tsServerPort);




16✔





3158












3159



        SEp firstEp = {0};




16✔





3160



        TAOS_CHECK_GOTO(




16✔





3161



            taosGetFqdnPortFromEp(strlen(pFirstEpItem->str) == 0 ? defaultFirstEp : pFirstEpItem->str, &firstEp), &lino,










3162



            _out);










3163



        (void)snprintf(tsFirst, sizeof(tsFirst), "%s:%u", firstEp.fqdn, firstEp.port);




16✔





3164












3165



        TAOS_CHECK_GOTO(cfgSetItem(pCfg, "firstEp", tsFirst, pFirstEpItem->stype, false), &lino, _out);




16✔





3166



        uInfo("localEp set to '%s', tsFirst set to '%s'", tsLocalEp, tsFirst);




16✔





3167



        matched = true;




16✔





3168



      } else if (strcasecmp("firstEp", name) == 0) {




16✔





3169



        SConfigItem *pFqdnItem = cfgGetItem(pCfg, "fqdn");




16✔





3170



        SConfigItem *pServerPortItem = cfgGetItem(pCfg, "serverPort");




16✔





3171



        SConfigItem *pFirstEpItem = cfgGetItem(pCfg, "firstEp");




16✔





3172



        if (pFqdnItem == NULL || pServerPortItem == NULL || pFirstEpItem == NULL) {




16✔





3173



          uError("failed to get fqdn or serverPort or firstEp from cfg");




×







3174



          code = TSDB_CODE_CFG_NOT_FOUND;




×







3175



          goto _out;




×







3176



        }










3177












3178



        tstrncpy(tsLocalFqdn, pFqdnItem->str, TSDB_FQDN_LEN);




16✔





3179



        tsServerPort = (uint16_t)pServerPortItem->i32;




16✔





3180



        (void)snprintf(tsLocalEp, sizeof(tsLocalEp), "%s:%u", tsLocalFqdn, tsServerPort);




16✔





3181












3182



        char defaultFirstEp[TSDB_EP_LEN] = {0};




16✔





3183



        (void)snprintf(defaultFirstEp, TSDB_EP_LEN, "%s:%u", tsLocalFqdn, tsServerPort);




16✔





3184












3185



        SEp firstEp = {0};




16✔





3186



        TAOS_CHECK_GOTO(




16✔





3187



            taosGetFqdnPortFromEp(strlen(pFirstEpItem->str) == 0 ? defaultFirstEp : pFirstEpItem->str, &firstEp), &lino,










3188



            _out);










3189



        (void)snprintf(tsFirst, sizeof(tsFirst), "%s:%u", firstEp.fqdn, firstEp.port);




16✔





3190












3191



        TAOS_CHECK_GOTO(cfgSetItem(pCfg, "firstEp", tsFirst, pFirstEpItem->stype, false), &lino, _out);




16✔





3192



        uInfo("localEp set to '%s', tsFirst set to '%s'", tsLocalEp, tsFirst);




16✔





3193



        matched = true;




16✔





3194



      }










3195



      break;




32✔





3196



    }










3197



    case 'l': {




383✔





3198



      if (strcasecmp("locale", name) == 0) {




383✔





3199



        SConfigItem *pLocaleItem = cfgGetItem(pCfg, "locale");




×







3200



        if (pLocaleItem == NULL) {




×







3201



          uError("failed to get locale from cfg");




×







3202



          code = TSDB_CODE_CFG_NOT_FOUND;




×







3203



          goto _out;




×







3204



        }










3205












3206



        const char *locale = pLocaleItem->str;




×







3207



        TAOS_CHECK_GOTO(taosSetSystemLocale(locale), &lino, _out);




×







3208



        uInfo("locale set to '%s'", locale);




×







3209



        matched = true;




×







3210



      }










3211



      break;




383✔





3212



    }










3213



    case 'm': {




3,915✔





3214



      if (strcasecmp("metaCacheMaxSize", name) == 0) {




3,915✔





3215



        atomic_store_32(&tsMetaCacheMaxSize, pItem->i32);




16✔





3216



        uInfo("%s set to %d", name, atomic_load_32(&tsMetaCacheMaxSize));




16✔





3217



        matched = true;




16✔





3218



      } else if (strcasecmp("minimalTmpDirGB", name) == 0) {




3,899✔





3219



        tsTempSpace.reserved = (int64_t)(((double)pItem->fval) * 1024 * 1024 * 1024);




204✔





3220



        uInfo("%s set to %" PRId64, name, tsTempSpace.reserved);




204✔





3221



        matched = true;




204✔





3222



      } else if (strcasecmp("minimalLogDirGB", name) == 0) {




3,695✔





3223



        tsLogSpace.reserved = (int64_t)(((double)pItem->fval) * 1024 * 1024 * 1024);




16✔





3224



        uInfo("%s set to %" PRId64, name, tsLogSpace.reserved);




16✔





3225



        matched = true;




16✔





3226



      } else if (strcasecmp("maxSQLLength", name) == 0) {




3,679✔





3227



        tsMaxSQLLength = pItem->i32;




1,477✔





3228



        uInfo("%s set to %d", name, tsMaxSQLLength);




1,477✔





3229



        matched = true;




1,477✔





3230



      }










3231



      break;




3,915✔





3232



    }










3233



    case 's': {




5,772✔





3234



      if (strcasecmp("secondEp", name) == 0) {




5,772✔





3235



        SEp secondEp = {0};




16✔





3236



        TAOS_CHECK_GOTO(taosGetFqdnPortFromEp(strlen(pItem->str) == 0 ? tsFirst : pItem->str, &secondEp), &lino, _out);




16✔





3237



        (void)snprintf(tsSecond, sizeof(tsSecond), "%s:%u", secondEp.fqdn, secondEp.port);




16✔





3238



        TAOS_CHECK_GOTO(cfgSetItem(pCfg, "secondEp", tsSecond, pItem->stype, false), &lino, _out);




16✔





3239



        uInfo("%s set to %s", name, tsSecond);




16✔





3240



        matched = true;




16✔





3241



      } else if (strcasecmp("smlChildTableName", name) == 0) {




5,756✔





3242



        TAOS_CHECK_GOTO(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_TABLE_NAME_LEN), &lino, _out);




16✔





3243



        uInfo("%s set from %s to %s", name, tsSmlChildTableName, pItem->str);




16✔





3244



        tstrncpy(tsSmlChildTableName, pItem->str, TSDB_TABLE_NAME_LEN);




16✔





3245



        matched = true;




16✔





3246



      } else if (strcasecmp("smlAutoChildTableNameDelimiter", name) == 0) {




5,740✔





3247



        TAOS_CHECK_GOTO(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_TABLE_NAME_LEN), &lino, _out);




16✔





3248



        uInfo("%s set from %s to %s", name, tsSmlAutoChildTableNameDelimiter, pItem->str);




16✔





3249



        tstrncpy(tsSmlAutoChildTableNameDelimiter, pItem->str, TSDB_TABLE_NAME_LEN);




16✔





3250



        matched = true;




16✔





3251



      } else if (strcasecmp("smlTagName", name) == 0) {




5,724✔





3252



        TAOS_CHECK_GOTO(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_COL_NAME_LEN), &lino, _out);




16✔





3253



        uInfo("%s set from %s to %s", name, tsSmlTagName, pItem->str);




16✔





3254



        tstrncpy(tsSmlTagName, pItem->str, TSDB_COL_NAME_LEN);




16✔





3255



        matched = true;




16✔





3256



      } else if (strcasecmp("smlTsDefaultName", name) == 0) {




5,708✔





3257



        TAOS_CHECK_GOTO(taosCheckCfgStrValueLen(pItem->name, pItem->str, TSDB_COL_NAME_LEN), &lino, _out);




16✔





3258



        uInfo("%s set from %s to %s", name, tsSmlTsDefaultName, pItem->str);




16✔





3259



        tstrncpy(tsSmlTsDefaultName, pItem->str, TSDB_COL_NAME_LEN);




16✔





3260



        matched = true;




16✔





3261



      } else if (strcasecmp("sqlSecurity", name) == 0) {




5,692✔





3262



        tsSqlSecurityEnabled = pItem->bval;




×







3263



        uInfo("%s set to %d", name, tsSqlSecurityEnabled);




×







3264



        matched = true;




×







3265



      } else if (strcasecmp("sqlSecurityWhitelistMode", name) == 0) {




5,692✔





3266



        tsSqlSecurityWhitelistMode = pItem->i32;




1,022✔





3267



        uInfo("%s set to %d", name, tsSqlSecurityWhitelistMode);




1,022✔





3268



        matched = true;




1,022✔





3269



      } else if (strcasecmp("sqlSecurityStringCheck", name) == 0) {




4,670✔





3270



        tsSqlSecurityStringCheck = pItem->bval;




×







3271



        uInfo("%s set to %d", name, tsSqlSecurityStringCheck);




×







3272



        matched = true;




×







3273



      } else if (strcasecmp("sqlSecurityASTCheck", name) == 0) {




4,670✔





3274



        tsSqlSecurityASTCheck = pItem->bval;




×







3275



        uInfo("%s set to %d", name, tsSqlSecurityASTCheck);




×







3276



        matched = true;




×







3277



      } else if (strcasecmp("sqlSecurityRuleFile", name) == 0) {




4,670✔





3278



        TAOS_CHECK_GOTO(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX), &lino, _out);




×







3279



        uInfo("%s set from %s to %s", name, tsSqlSecurityRuleFile, pItem->str);




×







3280



        tstrncpy(tsSqlSecurityRuleFile, pItem->str, PATH_MAX);




×







3281



        matched = true;




×







3282



      } else if (strcasecmp("serverPort", name) == 0) {




4,670✔





3283



        SConfigItem *pFqdnItem = cfgGetItem(pCfg, "fqdn");




16✔





3284



        SConfigItem *pServerPortItem = cfgGetItem(pCfg, "serverPort");




16✔





3285



        SConfigItem *pFirstEpItem = cfgGetItem(pCfg, "firstEp");




16✔





3286



        if (pFqdnItem == NULL || pServerPortItem == NULL || pFirstEpItem == NULL) {




16✔





3287



          uError("failed to get fqdn or serverPort or firstEp from cfg");




×







3288



          code = TSDB_CODE_CFG_NOT_FOUND;




×







3289



          goto _out;




×







3290



        }










3291












3292



        TAOS_CHECK_GOTO(taosCheckCfgStrValueLen(pFqdnItem->name, pFqdnItem->str, TSDB_FQDN_LEN), &lino, _out);




16✔





3293



        tstrncpy(tsLocalFqdn, pFqdnItem->str, TSDB_FQDN_LEN);




16✔





3294



        tsServerPort = (uint16_t)pServerPortItem->i32;




16✔





3295



        (void)snprintf(tsLocalEp, sizeof(tsLocalEp), "%s:%u", tsLocalFqdn, tsServerPort);




16✔





3296












3297



        char defaultFirstEp[TSDB_EP_LEN] = {0};




16✔





3298



        (void)snprintf(defaultFirstEp, TSDB_EP_LEN, "%s:%u", tsLocalFqdn, tsServerPort);




16✔





3299












3300



        SEp firstEp = {0};




16✔





3301



        TAOS_CHECK_GOTO(




16✔





3302



            taosGetFqdnPortFromEp(strlen(pFirstEpItem->str) == 0 ? defaultFirstEp : pFirstEpItem->str, &firstEp), &lino,










3303



            _out);










3304



        (void)snprintf(tsFirst, sizeof(tsFirst), "%s:%u", firstEp.fqdn, firstEp.port);




16✔





3305












3306



        TAOS_CHECK_GOTO(cfgSetItem(pCfg, "firstEp", tsFirst, pFirstEpItem->stype, false), &lino, _out);




16✔





3307



        uInfo("localEp set to '%s', tsFirst set to '%s'", tsLocalEp, tsFirst);




16✔





3308



        matched = true;




16✔





3309



      }










3310



      break;




5,772✔





3311



    }










3312



    case 't': {




170✔





3313



      if (strcasecmp("tempDir", name) == 0) {




170✔





3314



        TAOS_CHECK_GOTO(taosCheckCfgStrValueLen(pItem->name, pItem->str, PATH_MAX), &lino, _out);




×







3315



        uInfo("%s set from %s to %s", name, tsTempDir, pItem->str);




×







3316



        tstrncpy(tsTempDir, pItem->str, PATH_MAX);




×







3317



        TAOS_CHECK_GOTO(taosExpandDir(tsTempDir, tsTempDir, PATH_MAX), &lino, _out);




×







3318



        if (taosMulMkDir(tsTempDir) != 0) {




×







3319



          code = TAOS_SYSTEM_ERROR(ERRNO);




×







3320



          uError("failed to create tempDir:%s since %s", tsTempDir, tstrerror(code));




×







3321



          goto _out;




×







3322



        }










3323



        matched = true;




×







3324



      }










3325



      break;




170✔





3326



    }










3327



    case 'w': {




1,168✔





3328



      if (strcasecmp("whitelistLearning", name) == 0) {




1,168✔





3329



        tsWhitelistLearning = pItem->bval;




1,022✔





3330



        uInfo("%s set to %d", name, tsWhitelistLearning);




1,022✔





3331



        matched = true;




1,022✔





3332



      } else if (strcasecmp("whitelistLearningPeriod", name) == 0) {




146✔





3333



        tsWhitelistLearningPeriod = pItem->i32;




×







3334



        uInfo("%s set to %d", name, tsWhitelistLearningPeriod);




×







3335



        matched = true;




×







3336



      } else if (strcasecmp("whitelistLearningThreshold", name) == 0) {




146✔





3337



        tsWhitelistLearningThreshold = pItem->i32;




146✔





3338



        uInfo("%s set to %d", name, tsWhitelistLearningThreshold);




146✔





3339



        matched = true;




146✔





3340



      }










3341



      break;




1,168✔





3342



    }










3343



    default:




491,018✔





3344



      code = TSDB_CODE_CFG_NOT_FOUND;




491,018✔





3345



      break;




491,018✔





3346



  }










3347












3348



  if (matched) goto _out;




502,644✔





3349












3350



  {  //  'bool/int32_t/int64_t/float/double' variables with general modification function










3351



    static OptionNameAndVar debugOptions[] = {










3352



        {"cDebugFlag", &cDebugFlag},     {"dDebugFlag", &dDebugFlag},     {"fsDebugFlag", &fsDebugFlag},










3353



        {"idxDebugFlag", &idxDebugFlag}, {"jniDebugFlag", &jniDebugFlag}, {"qDebugFlag", &qDebugFlag},










3354



        {"rpcDebugFlag", &rpcDebugFlag}, {"smaDebugFlag", &smaDebugFlag}, {"tmrDebugFlag", &tmrDebugFlag},










3355



        {"uDebugFlag", &uDebugFlag},     {"simDebugFlag", &simDebugFlag},










3356



    };










3357












3358



    static OptionNameAndVar options[] = {{"asyncLog", &tsAsyncLog},










3359



                                         {"compressMsgSize", &tsCompressMsgSize},










3360



                                         {"countAlwaysReturnValue", &tsCountAlwaysReturnValue},










3361



                                         {"crashReporting", &tsEnableCrashReport},










3362



                                         {"enableQueryHb", &tsEnableQueryHb},










3363



                                         {"keepColumnName", &tsKeepColumnName},










3364



                                         {"logKeepDays", &tsLogKeepDays},










3365



                                         {"maxInsertBatchRows", &tsMaxInsertBatchRows},










3366



                                         {"minSlidingTime", &tsMinSlidingTime},










3367



                                         {"minIntervalTime", &tsMinIntervalTime},










3368



                                         {"numOfLogLines", &tsNumOfLogLines},










3369



                                         {"querySmaOptimize", &tsQuerySmaOptimize},










3370



                                         {"queryPolicy", &tsQueryPolicy},










3371



                                         {"queryTableNotExistAsEmpty", &tsQueryTbNotExistAsEmpty},










3372



                                         {"queryPlannerTrace", &tsQueryPlannerTrace},










3373



                                         {"queryNodeChunkSize", &tsQueryNodeChunkSize},










3374



                                         {"queryUseNodeAllocator", &tsQueryUseNodeAllocator},










3375



                                         {"smlDot2Underline", &tsSmlDot2Underline},










3376



                                         {"useAdapter", &tsUseAdapter},










3377



                                         {"multiResultFunctionStarReturnTags", &tsMultiResultFunctionStarReturnTags},










3378



                                         {"maxTsmaCalcDelay", &tsMaxTsmaCalcDelay},










3379



                                         {"tsmaDataDeleteMark", &tsmaDataDeleteMark},










3380



                                         {"numOfRpcSessions", &tsNumOfRpcSessions},










3381



                                         {"bypassFlag", &tsBypassFlag},










3382



                                         {"safetyCheckLevel", &tsSafetyCheckLevel},










3383



                                         {"compareAsStrInGreatest", &tsCompareAsStrInGreatest},










3384



                                         {"showFullCreateTableColumn", &tsShowFullCreateTableColumn}};










3385












3386



    if ((code = taosCfgSetOption(debugOptions, tListLen(debugOptions), pItem, true)) != TSDB_CODE_SUCCESS) {




498,597✔





3387



      code = taosCfgSetOption(options, tListLen(options), pItem, false);




498,597✔





3388



    }










3389



  }










3390












3391



_out:




502,256✔





3392



  if (TSDB_CODE_SUCCESS != code) {




502,644✔





3393



    uError("failed to set option:%s, lino:%d, since:%s", name, lino, tstrerror(code));




×







3394



  }










3395












3396



  cfgUnLock(pCfg);




502,644✔





3397



  TAOS_RETURN(code);




502,644✔





3398



}










3399












3400



int32_t taosCfgDynamicOptions(SConfig *pCfg, const char *name, bool forServer) {




595,668✔





3401



  if (forServer) {




595,668✔





3402



    return taosCfgDynamicOptionsForServer(pCfg, name);




92,548✔





3403



  } else {










3404



    return taosCfgDynamicOptionsForClient(pCfg, name);




503,120✔





3405



  }










3406



}










3407












3408



int32_t taosSetDebugFlag(int32_t *pFlagPtr, const char *flagName, int32_t flagVal) {




3,431,449✔





3409



  SConfigItem *pItem = NULL;




3,431,449✔





3410



  TAOS_CHECK_GET_CFG_ITEM(tsCfg, pItem, flagName);




3,431,449✔





3411



  pItem->i32 = flagVal;




1,520,405✔





3412



  if (pFlagPtr != NULL) {




1,520,405✔





3413



    *pFlagPtr = flagVal;




1,520,405✔





3414



  }










3415



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,520,405✔





3416



}










3417












3418



static int taosLogVarComp(void const *lp, void const *rp) {




11,029,728✔





3419



  SLogVar *lpVar = (SLogVar *)lp;




11,029,728✔





3420



  SLogVar *rpVar = (SLogVar *)rp;




11,029,728✔





3421



  return taosStrcasecmp(lpVar->name, rpVar->name);




11,029,728✔





3422



}










3423












3424



static void taosCheckAndSetDebugFlag(int32_t *pFlagPtr, char *name, int32_t flag, SArray *noNeedToSetVars) {




4,738,344✔





3425



  if (noNeedToSetVars != NULL && taosArraySearch(noNeedToSetVars, name, taosLogVarComp, TD_EQ) != NULL) {




4,738,344✔





3426



    return;




1,318,520✔





3427



  }










3428



  int32_t code = 0;




3,419,824✔





3429



  if ((code = taosSetDebugFlag(pFlagPtr, name, flag)) != 0) {




3,419,824✔





3430



    if (code != TSDB_CODE_CFG_NOT_FOUND) {




1,911,044✔





3431



      uError("failed to set flag %s to %d, since:%s", name, flag, tstrerror(code));




×







3432



    } else {










3433



      uTrace("failed to set flag %s to %d, since:%s", name, flag, tstrerror(code));




1,911,044✔





3434



    }










3435



  }










3436



  return;




3,419,824✔





3437



}










3438












3439



int32_t taosSetGlobalDebugFlag(int32_t flag) { return taosSetAllDebugFlag(tsCfg, flag); }




×







3440












3441



// NOTE: set all command does not change the tmrDebugFlag










3442



static int32_t taosSetAllDebugFlag(SConfig *pCfg, int32_t flag) {




5,734,240✔





3443



  if (flag < 0) TAOS_RETURN(TSDB_CODE_INVALID_PARA);




5,734,240✔





3444



  if (flag == 0) TAOS_RETURN(TSDB_CODE_SUCCESS);  // just ignore




5,734,240✔





3445












3446



  SArray      *noNeedToSetVars = NULL;




182,244✔





3447



  SConfigItem *pItem = NULL;




182,244✔





3448



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "debugFlag");




182,244✔





3449












3450



  pItem->i32 = flag;




182,244✔





3451



  noNeedToSetVars = pItem->array;




182,244✔





3452












3453



  taosCheckAndSetDebugFlag(&simDebugFlag, "simDebugFlag", flag, noNeedToSetVars);




182,244✔





3454



  taosCheckAndSetDebugFlag(&uDebugFlag, "uDebugFlag", flag, noNeedToSetVars);




182,244✔





3455



  taosCheckAndSetDebugFlag(&rpcDebugFlag, "rpcDebugFlag", flag, noNeedToSetVars);




182,244✔





3456



  taosCheckAndSetDebugFlag(&qDebugFlag, "qDebugFlag", flag, noNeedToSetVars);




182,244✔





3457












3458



  taosCheckAndSetDebugFlag(&jniDebugFlag, "jniDebugFlag", flag, noNeedToSetVars);




182,244✔





3459



  taosCheckAndSetDebugFlag(&cDebugFlag, "cDebugFlag", flag, noNeedToSetVars);




182,244✔





3460












3461



  taosCheckAndSetDebugFlag(&dDebugFlag, "dDebugFlag", flag, noNeedToSetVars);




182,244✔





3462



  taosCheckAndSetDebugFlag(&vDebugFlag, "vDebugFlag", flag, noNeedToSetVars);




182,244✔





3463



  taosCheckAndSetDebugFlag(&mDebugFlag, "mDebugFlag", flag, noNeedToSetVars);




182,244✔





3464



  taosCheckAndSetDebugFlag(&wDebugFlag, "wDebugFlag", flag, noNeedToSetVars);




182,244✔





3465



  taosCheckAndSetDebugFlag(&azDebugFlag, "azDebugFlag", flag, noNeedToSetVars);




182,244✔





3466



  taosCheckAndSetDebugFlag(&tssDebugFlag, "tssDebugFlag", flag, noNeedToSetVars);




182,244✔





3467



  taosCheckAndSetDebugFlag(&sDebugFlag, "sDebugFlag", flag, noNeedToSetVars);




182,244✔





3468



  taosCheckAndSetDebugFlag(&tsdbDebugFlag, "tsdbDebugFlag", flag, noNeedToSetVars);




182,244✔





3469



  taosCheckAndSetDebugFlag(&tqDebugFlag, "tqDebugFlag", flag, noNeedToSetVars);




182,244✔





3470



  taosCheckAndSetDebugFlag(&fsDebugFlag, "fsDebugFlag", flag, noNeedToSetVars);




182,244✔





3471



  taosCheckAndSetDebugFlag(&udfDebugFlag, "udfDebugFlag", flag, noNeedToSetVars);




182,244✔





3472



  taosCheckAndSetDebugFlag(&smaDebugFlag, "smaDebugFlag", flag, noNeedToSetVars);




182,244✔





3473



  taosCheckAndSetDebugFlag(&idxDebugFlag, "idxDebugFlag", flag, noNeedToSetVars);




182,244✔





3474



  taosCheckAndSetDebugFlag(&tdbDebugFlag, "tdbDebugFlag", flag, noNeedToSetVars);




182,244✔





3475



  taosCheckAndSetDebugFlag(&metaDebugFlag, "metaDebugFlag", flag, noNeedToSetVars);




182,244✔





3476



  taosCheckAndSetDebugFlag(&stDebugFlag, "stDebugFlag", flag, noNeedToSetVars);




182,244✔





3477



  taosCheckAndSetDebugFlag(&sndDebugFlag, "sndDebugFlag", flag, noNeedToSetVars);




182,244✔





3478



  taosCheckAndSetDebugFlag(&bseDebugFlag, "bseDebugFlag", flag, noNeedToSetVars);




182,244✔





3479



  taosCheckAndSetDebugFlag(&bndDebugFlag, "bndDebugFlag", flag, noNeedToSetVars);




182,244✔





3480



  taosCheckAndSetDebugFlag(&xndDebugFlag, "xndDebugFlag", flag, noNeedToSetVars);




182,244✔





3481












3482



  taosArrayClear(noNeedToSetVars);  // reset array




182,244✔





3483












3484



  uInfo("all debug flag are set to %d", flag);




182,244✔





3485



  TAOS_RETURN(TSDB_CODE_SUCCESS);




182,244✔





3486



}










3487












3488



int32_t taosGranted(int8_t type) {




305,071,208✔





3489



  switch (type) {




305,071,208✔





3490



    case TSDB_GRANT_ALL: {




304,774,682✔





3491



      if (atomic_load_32(&tsGrant) & GRANT_FLAG_ALL) {




304,774,682✔





3492



        return 0;




304,757,854✔





3493



      }











UNCOV

3494



      int32_t grantVal = atomic_load_32(&tsGrant);




×







3495



      if (grantVal & GRANT_FLAG_EX_MULTI_TIER) {




×







3496



        return TSDB_CODE_GRANT_MULTI_STORAGE_EXPIRED;




×







3497



      } else if (grantVal & GRANT_FLAG_EX_STORAGE) {




×







3498



        return TSDB_CODE_GRANT_STORAGE_LIMITED;




×







3499



      }










3500



      return TSDB_CODE_GRANT_EXPIRED;




×







3501



    }










3502



    case TSDB_GRANT_AUDIT: {




474✔





3503



      return (atomic_load_32(&tsGrant) & GRANT_FLAG_AUDIT) ? 0 : TSDB_CODE_GRANT_AUDIT_EXPIRED;




474✔





3504



    }










3505



    case TSDB_GRANT_VIEW:




322,252✔





3506



      return (atomic_load_32(&tsGrant) & GRANT_FLAG_VIEW) ? 0 : TSDB_CODE_GRANT_VIEW_EXPIRED;




322,252✔





3507



    default:




×







3508



      uWarn("undefined grant type:%" PRIi8, type);




×







3509



      break;




×







3510



  }










3511



  return 0;




×







3512



}










3513












3514



int32_t globalConfigSerialize(int32_t version, SArray *array, char **serialized) {




528,855✔





3515



  char   buf[30];




525,704✔





3516



  cJSON *json = cJSON_CreateObject();




528,855✔





3517



  if (json == NULL) goto _exit;




528,855✔





3518



  if (cJSON_AddNumberToObject(json, "file_version", GLOBAL_CONFIG_FILE_VERSION) == NULL) goto _exit;




528,855✔





3519



  if (cJSON_AddNumberToObject(json, "version", version) == NULL) goto _exit;




528,855✔





3520



  int sz = taosArrayGetSize(array);




528,855✔





3521












3522



  cJSON *cField = cJSON_CreateObject();




528,855✔





3523



  if (cField == NULL) goto _exit;




528,855✔





3524












3525



  if (!cJSON_AddItemToObject(json, "configs", cField)) goto _exit;




528,855✔





3526












3527



  // cjson only support int32_t or double










3528



  // string are used to prohibit the loss of precision










3529



  for (int i = 0; i < sz; i++) {




61,535,111✔





3530



    SConfigItem *item = (SConfigItem *)taosArrayGet(array, i);




61,006,256✔





3531



    switch (item->dtype) {




61,006,256✔





3532



      {










3533



        case CFG_DTYPE_NONE:




×







3534



          break;




×







3535



        case CFG_DTYPE_BOOL:




15,251,564✔





3536



          if (cJSON_AddBoolToObject(cField, item->name, item->bval) == NULL) goto _exit;




15,251,564✔





3537



          break;




15,251,564✔





3538



        case CFG_DTYPE_INT32:




31,554,960✔





3539



          if (cJSON_AddNumberToObject(cField, item->name, item->i32) == NULL) goto _exit;




31,554,960✔





3540



          break;




31,554,960✔





3541



        case CFG_DTYPE_INT64:




3,155,496✔





3542



          (void)snprintf(buf, sizeof(buf), "%" PRId64, item->i64);




3,155,496✔





3543



          if (cJSON_AddStringToObject(cField, item->name, buf) == NULL) goto _exit;




3,155,496✔





3544



          break;




3,155,496✔





3545



        case CFG_DTYPE_FLOAT:




1,051,832✔





3546



        case CFG_DTYPE_DOUBLE:










3547



          (void)snprintf(buf, sizeof(buf), "%f", item->fval);




1,051,832✔





3548



          if (cJSON_AddStringToObject(cField, item->name, buf) == NULL) goto _exit;




1,051,832✔





3549



          break;




1,051,832✔





3550



        case CFG_DTYPE_STRING:




9,992,404✔





3551



        case CFG_DTYPE_DIR:










3552



        case CFG_DTYPE_LOCALE:










3553



        case CFG_DTYPE_CHARSET:










3554



        case CFG_DTYPE_TIMEZONE:










3555



          if (cJSON_AddStringToObject(cField, item->name, item->str) == NULL) goto _exit;




9,992,404✔





3556



          break;




9,992,404✔





3557



      }










3558



    }










3559



  }










3560



  char *pSerialized = tjsonToString(json);




528,855✔





3561



_exit:




528,855✔





3562



  if (terrno != TSDB_CODE_SUCCESS) {




528,855✔





3563



    uError("failed to serialize global config since %s", tstrerror(terrno));




1,364✔





3564



  }










3565



  cJSON_Delete(json);




528,855✔





3566



  *serialized = pSerialized;




528,855✔





3567



  return terrno;




528,855✔





3568



}










3569












3570



int32_t localConfigSerialize(SArray *array, char **serialized) {




732,076✔





3571



  char   buf[30];




731,746✔





3572



  cJSON *json = cJSON_CreateObject();




732,076✔





3573



  if (json == NULL) goto _exit;




732,076✔





3574












3575



  int sz = taosArrayGetSize(array);




732,076✔





3576












3577



  cJSON *cField = cJSON_CreateObject();




732,076✔





3578



  if (cField == NULL) goto _exit;




732,076✔





3579



  if (cJSON_AddNumberToObject(json, "file_version", LOCAL_CONFIG_FILE_VERSION) == NULL) goto _exit;




732,076✔





3580



  if (!cJSON_AddItemToObject(json, "configs", cField)) goto _exit;




732,076✔





3581












3582



  // cjson only support int32_t or double










3583



  // string are used to prohibit the loss of precision










3584



  for (int i = 0; i < sz; i++) {




117,864,236✔





3585



    SConfigItem *item = (SConfigItem *)taosArrayGet(array, i);




117,132,160✔





3586



    if (strcasecmp(item->name, "dataDir") == 0) {




117,132,160✔





3587



      int32_t sz = taosArrayGetSize(item->array);




732,076✔





3588



      cJSON  *dataDirs = cJSON_CreateArray();




732,076✔





3589



      if (!cJSON_AddItemToObject(cField, item->name, dataDirs)) {




732,076✔





3590



        uError("failed to serialize global config since %s", tstrerror(terrno));




×







3591



        goto _exit;




×







3592



      }










3593



      for (int j = 0; j < sz; j++) {




1,530,260✔





3594



        SDiskCfg *disk = (SDiskCfg *)taosArrayGet(item->array, j);




798,184✔





3595



        cJSON    *dataDir = cJSON_CreateObject();




798,184✔





3596



        if (dataDir == NULL) goto _exit;




798,184✔





3597



        if (!cJSON_AddItemToArray(dataDirs, dataDir)) {




798,184✔





3598



          uError("failed to serialize global config since %s", tstrerror(terrno));




×







3599



          goto _exit;




×







3600



        }










3601



        if (cJSON_AddStringToObject(dataDir, "dir", disk->dir) == NULL) goto _exit;




798,184✔





3602



        if (cJSON_AddNumberToObject(dataDir, "level", disk->level) == NULL) goto _exit;




798,184✔





3603



        if (disk->diskId == 0) {




798,184✔





3604



          if (taosGetFileDiskID(disk->dir, &disk->diskId) != 0) {




722,052✔





3605



            uError("failed to get disk id for %s", disk->dir);




×







3606



            goto _exit;




×







3607



          }










3608



        }










3609



        (void)snprintf(buf, sizeof(buf), "%" PRId64, disk->diskId);




798,184✔





3610



        if (cJSON_AddStringToObject(dataDir, "disk_id", buf) == NULL) goto _exit;




798,184✔





3611



        if (cJSON_AddNumberToObject(dataDir, "primary", disk->primary) == NULL) goto _exit;




798,184✔





3612



        if (cJSON_AddNumberToObject(dataDir, "disable", disk->disable) == NULL) goto _exit;




798,184✔





3613



      }










3614



      continue;




732,076✔





3615



    }










3616



    switch (item->dtype) {




116,400,084✔





3617



      {










3618



        case CFG_DTYPE_NONE:




×







3619



          break;




×







3620



        case CFG_DTYPE_BOOL:




23,426,432✔





3621



          if (cJSON_AddBoolToObject(cField, item->name, item->bval) == NULL) goto _exit;




23,426,432✔





3622



          break;




23,426,432✔





3623



        case CFG_DTYPE_INT32:




65,154,764✔





3624



          if (cJSON_AddNumberToObject(cField, item->name, item->i32) == NULL) goto _exit;




65,154,764✔





3625



          break;




65,154,764✔





3626



        case CFG_DTYPE_INT64:




5,856,608✔





3627



          (void)snprintf(buf, sizeof(buf), "%" PRId64, item->i64);




5,856,608✔





3628



          if (cJSON_AddStringToObject(cField, item->name, buf) == NULL) goto _exit;




5,856,608✔





3629



          break;




5,856,608✔





3630



        case CFG_DTYPE_FLOAT:




2,928,304✔





3631



        case CFG_DTYPE_DOUBLE:










3632



          (void)snprintf(buf, sizeof(buf), "%f", item->fval);




2,928,304✔





3633



          if (cJSON_AddStringToObject(cField, item->name, buf) == NULL) goto _exit;




2,928,304✔





3634



          break;




2,928,304✔





3635



        case CFG_DTYPE_STRING:




19,033,976✔





3636



        case CFG_DTYPE_DIR:










3637



        case CFG_DTYPE_LOCALE:










3638



        case CFG_DTYPE_CHARSET:










3639



        case CFG_DTYPE_TIMEZONE:










3640



          if (cJSON_AddStringToObject(cField, item->name, item->str) == NULL) goto _exit;




19,033,976✔





3641



          break;




19,033,976✔





3642



      }










3643



    }










3644



  }










3645



  char *pSerialized = tjsonToString(json);




732,076✔





3646



_exit:




732,076✔





3647



  if (terrno != TSDB_CODE_SUCCESS) {




732,076✔





3648



    uError("failed to serialize local config since %s", tstrerror(terrno));




×







3649



  }










3650



  cJSON_Delete(json);




732,076✔





3651



  *serialized = pSerialized;




732,076✔





3652



  return terrno;




732,076✔





3653



}










3654












3655



int32_t stypeConfigSerialize(SArray *array, char **serialized) {




732,076✔





3656



  char   buf[30];










3657



  cJSON *json = cJSON_CreateObject();




732,076✔





3658



  if (json == NULL) goto _exit;




732,076✔





3659












3660



  int sz = taosArrayGetSize(array);




732,076✔





3661












3662



  cJSON *cField = cJSON_CreateObject();




732,076✔





3663



  if (cField == NULL) goto _exit;




732,076✔





3664



  if (cJSON_AddNumberToObject(json, "file_version", LOCAL_CONFIG_FILE_VERSION) == NULL) goto _exit;




732,076✔





3665



  if (!cJSON_AddItemToObject(json, "config_stypes", cField)) goto _exit;




732,076✔





3666












3667



  // cjson only support int32_t or double










3668



  // string are used to prohibit the loss of precision










3669



  for (int i = 0; i < sz; i++) {




117,864,236✔





3670



    SConfigItem *item = (SConfigItem *)taosArrayGet(array, i);




117,132,160✔





3671



    if (cJSON_AddNumberToObject(cField, item->name, item->stype) == NULL) goto _exit;




117,132,160✔





3672



  }










3673



  char *pSerialized = tjsonToString(json);




732,076✔





3674



_exit:




732,076✔





3675



  if (terrno != TSDB_CODE_SUCCESS) {




732,076✔





3676



    uError("failed to serialize local config since %s", tstrerror(terrno));




×







3677



  }










3678



  cJSON_Delete(json);




732,076✔





3679



  *serialized = pSerialized;




732,076✔





3680



  return terrno;




732,076✔





3681



}










3682












3683



int32_t taosPersistGlobalConfig(SArray *array, const char *path, int32_t version) {




528,855✔





3684



  int32_t   code = 0;




528,855✔





3685



  int32_t   lino = 0;




528,855✔





3686



  char     *serialized = NULL;




528,855✔





3687



  char      filepath[CONFIG_FILE_LEN] = {0};




528,855✔





3688



  char      filename[CONFIG_FILE_LEN] = {0};




528,855✔





3689



  snprintf(filepath, sizeof(filepath), "%s%sconfig", path, TD_DIRSEP);




528,855✔





3690



  snprintf(filename, sizeof(filename), "%s%sconfig%sglobal.json", path, TD_DIRSEP, TD_DIRSEP);




528,855✔





3691












3692



  TAOS_CHECK_GOTO(taosMkDir(filepath), &lino, _exit);




528,855✔





3693












3694



  TAOS_CHECK_GOTO(globalConfigSerialize(version, array, &serialized), &lino, _exit);




528,855✔





3695












3696



  // Use taosWriteCfgFile for encryption support (automatically encrypts if tsCfgKey is set)










3697



  code = taosWriteCfgFile(filename, serialized, strlen(serialized));




527,491✔





3698



  if (code != TSDB_CODE_SUCCESS) {




527,491✔





3699



    lino = __LINE__;




×







3700



    uError("failed to write config file:%s since %s", filename, tstrerror(code));




×







3701



    goto _exit;




×







3702



  }










3703












3704



_exit:




527,491✔





3705



  if (code != TSDB_CODE_SUCCESS) {




528,855✔





3706



    uError("failed to persist global config at line:%d, since %s", lino, tstrerror(code));




1,364✔





3707



  }










3708



  taosMemoryFree(serialized);




528,855✔





3709



  return code;




528,855✔





3710



}










3711












3712



int32_t taosPersistLocalConfig(const char *path) {




732,076✔





3713



  int32_t   code = 0;




732,076✔





3714



  int32_t   lino = 0;




732,076✔





3715



  char     *serializedCfg = NULL;




732,076✔





3716



  char     *serializedStype = NULL;




732,076✔





3717



  char      filepath[CONFIG_FILE_LEN] = {0};




732,076✔





3718



  char      filename[CONFIG_FILE_LEN] = {0};




732,076✔





3719



  char      stypeFilename[CONFIG_FILE_LEN] = {0};




732,076✔





3720



  snprintf(filepath, sizeof(filepath), "%s%sconfig", path, TD_DIRSEP);




732,076✔





3721



  snprintf(filename, sizeof(filename), "%s%sconfig%slocal.json", path, TD_DIRSEP, TD_DIRSEP);




732,076✔





3722



  snprintf(stypeFilename, sizeof(stypeFilename), "%s%sconfig%sstype.json", path, TD_DIRSEP, TD_DIRSEP);




732,076✔





3723












3724



  // TODO(beryl) need to check if the file is existed










3725



  TAOS_CHECK_GOTO(taosMkDir(filepath), &lino, _exit);




732,076✔





3726












3727



  // Serialize local config










3728



  TAOS_CHECK_GOTO(localConfigSerialize(taosGetLocalCfg(tsCfg), &serializedCfg), &lino, _exit);




732,076✔





3729












3730



  // Use taosWriteCfgFile for encryption support (automatically encrypts if tsCfgKey is set)










3731



  code = taosWriteCfgFile(filename, serializedCfg, strlen(serializedCfg));




732,076✔





3732



  if (code != TSDB_CODE_SUCCESS) {




732,076✔





3733



    lino = __LINE__;




×







3734



    uError("failed to write config file:%s since %s", filename, tstrerror(code));




×







3735



    goto _exit;




×







3736



  }










3737












3738



  // Serialize stype config










3739



  TAOS_CHECK_GOTO(stypeConfigSerialize(taosGetLocalCfg(tsCfg), &serializedStype), &lino, _exit);




732,076✔





3740












3741



  // Use taosWriteCfgFile for encryption support (automatically encrypts if tsCfgKey is set)










3742



  code = taosWriteCfgFile(stypeFilename, serializedStype, strlen(serializedStype));




732,076✔





3743



  if (code != TSDB_CODE_SUCCESS) {




732,076✔





3744



    lino = __LINE__;




×







3745



    uError("failed to write config file:%s since %s", stypeFilename, tstrerror(code));




×







3746



    goto _exit;




×







3747



  }










3748












3749



_exit:




732,076✔





3750



  if (code != TSDB_CODE_SUCCESS) {




732,076✔





3751



    uError("failed to persist local config at line:%d, since %s", lino, tstrerror(code));




×







3752



  }










3753



  taosMemoryFree(serializedCfg);




732,076✔





3754



  taosMemoryFree(serializedStype);




732,076✔





3755



  return code;




732,076✔





3756



}










3757












3758



int32_t tSerializeSConfigArray(SEncoder *pEncoder, SArray *array) {




2,659,106✔





3759



  int32_t code = 0;




2,659,106✔





3760



  int32_t lino = 0;




2,659,106✔





3761



  int32_t sz = taosArrayGetSize(array);




2,659,106✔





3762



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, sz));




2,659,106✔





3763



  for (int i = 0; i < sz; i++) {




275,536,114✔





3764



    SConfigItem *item = (SConfigItem *)taosArrayGet(array, i);




272,877,008✔





3765



    TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, item->name));




545,754,016✔





3766



    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, item->dtype));




545,754,016✔





3767



    switch (item->dtype) {




272,877,008✔





3768



      {










3769



        case CFG_DTYPE_NONE:




×







3770



          break;




×







3771



        case CFG_DTYPE_BOOL:




68,219,252✔





3772



          TAOS_CHECK_EXIT(tEncodeBool(pEncoder, item->bval));




68,219,252✔





3773



          break;




68,219,252✔





3774



        case CFG_DTYPE_INT32:




141,143,280✔





3775



          TAOS_CHECK_EXIT(tEncodeI32(pEncoder, item->i32));




282,286,560✔





3776



          break;




141,143,280✔





3777



        case CFG_DTYPE_INT64:




14,114,328✔





3778



          TAOS_CHECK_EXIT(tEncodeI64(pEncoder, item->i64));




28,228,656✔





3779



          break;




14,114,328✔





3780



        case CFG_DTYPE_FLOAT:




4,704,776✔





3781



        case CFG_DTYPE_DOUBLE:










3782



          TAOS_CHECK_EXIT(tEncodeFloat(pEncoder, item->fval));




9,409,552✔





3783



          break;




4,704,776✔





3784



        case CFG_DTYPE_STRING:




44,695,372✔





3785



        case CFG_DTYPE_DIR:










3786



        case CFG_DTYPE_LOCALE:










3787



        case CFG_DTYPE_CHARSET:










3788



        case CFG_DTYPE_TIMEZONE:










3789



          TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, item->str));




89,390,744✔





3790



          break;




44,695,372✔





3791



      }










3792



    }










3793



  }










3794



_exit:




2,659,106✔





3795



  return code;




2,659,106✔





3796



}










3797












3798



int32_t tDeserializeSConfigArray(SDecoder *pDecoder, SArray *array) {




1,322,747✔





3799



  int32_t code = 0;




1,322,747✔





3800



  int32_t lino = 0;




1,322,747✔





3801



  int32_t sz = 0;




1,322,747✔





3802



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &sz));




1,322,747✔





3803



  for (int i = 0; i < sz; i++) {




137,042,747✔





3804



    SConfigItem item = {0};




135,720,000✔





3805



    TAOS_CHECK_EXIT(tDecodeCStr(pDecoder, &item.name));




135,720,000✔





3806



    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, (int32_t *)&item.dtype));




135,720,000✔





3807



    switch (item.dtype) {




135,720,000✔





3808



      {










3809



        case CFG_DTYPE_NONE:




×







3810



          break;




×







3811



        case CFG_DTYPE_BOOL:




33,930,000✔





3812



          TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &item.bval));




33,930,000✔





3813



          break;




33,930,000✔





3814



        case CFG_DTYPE_INT32:




70,200,000✔





3815



          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &item.i32));




70,200,000✔





3816



          break;




70,200,000✔





3817



        case CFG_DTYPE_INT64:




7,020,000✔





3818



          TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &item.i64));




7,020,000✔





3819



          break;




7,020,000✔





3820



        case CFG_DTYPE_FLOAT:




2,340,000✔





3821



        case CFG_DTYPE_DOUBLE:










3822



          TAOS_CHECK_EXIT(tDecodeFloat(pDecoder, &item.fval));




2,340,000✔





3823



          break;




2,340,000✔





3824



        case CFG_DTYPE_STRING:




22,230,000✔





3825



        case CFG_DTYPE_DIR:










3826



        case CFG_DTYPE_LOCALE:










3827



        case CFG_DTYPE_CHARSET:










3828



        case CFG_DTYPE_TIMEZONE:










3829



          TAOS_CHECK_EXIT(tDecodeCStr(pDecoder, &item.str));




22,230,000✔





3830



          break;




22,230,000✔





3831



      }










3832



    }










3833



    if (taosArrayPush(array, &item) == NULL) {




135,720,000✔





3834



      code = terrno;




×







3835



      goto _exit;




×







3836



    }










3837



  }










3838



_exit:




1,322,747✔





3839



  if (code != TSDB_CODE_SUCCESS) {




1,322,747✔





3840



    uError("failed to deserialize SConfigItem at line:%d, since %s", lino, tstrerror(code));




×







3841



  }










3842



  return code;




1,322,747✔





3843



}










3844












3845



bool isConifgItemLazyMode(SConfigItem *item) {




92,973✔





3846



  if (item->dynScope == CFG_DYN_CLIENT_LAZY || item->dynScope == CFG_DYN_SERVER_LAZY ||




92,973✔





3847



      item->dynScope == CFG_DYN_BOTH_LAZY) {




92,390✔





3848



    return true;




667✔





3849



  }










3850



  return false;




92,306✔





3851



}










3852












3853



int32_t taosCheckCfgStrValueLen(const char *name, const char *value, int32_t len) {




76,353,242✔





3854



  if (strlen(value) > len) {




76,353,242✔





3855



    uError("invalid config:%s, value:%s, length should be less than %d", name, value, len);




×







3856



    TAOS_RETURN(TSDB_CODE_INVALID_CFG_VALUE);




×







3857



  }










3858



  TAOS_RETURN(TSDB_CODE_SUCCESS);




76,353,242✔





3859



}
























    

  • 

    •