taosdata / TDengine / #5034

coverage: 73.058%. Remained the same
#5034

push

travis-ci

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

merge: from main to 3.0 branch[manual-only]

1336 of 1975 new or added lines in 48 files covered. (67.65%)

14149 existing lines in 164 files now uncovered.

275896 of 377640 relevant lines covered (73.06%)

132944440.29 hits per line

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

86.71
/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 tsTLSCaPath[PATH_MAX] = {0};










72



char tsTLSSvrCertPath[PATH_MAX] = {0};










73



char tsTLSSvrKeyPath[PATH_MAX] = {0};










74












75



char tsTLSCliCertPath[PATH_MAX] = {0};










76



char tsTLSCliKeyPath[PATH_MAX] = {0};










77












78



int8_t tsEnableTLS = 0;










79



int8_t tsEnableSasl = 0;










80



// common










81



int32_t tsMaxShellConns = 50000;










82



int32_t tsShellActivityTimer = 3;  // second










83












84



// memory pool










85



int8_t tsMemPoolFullFunc = 0;










86



#ifndef TD_ASTRA










87



int8_t tsQueryUseMemoryPool = 1;










88



#else










89



int8_t  tsQueryUseMemoryPool = 0;










90



#endif










91



int32_t tsQueryBufferPoolSize = 0;       // MB










92



int32_t tsSingleQueryMaxMemorySize = 0;  // MB










93



int32_t tsMinReservedMemorySize = 0;     // MB










94



int64_t tsCurrentAvailMemorySize = 0;










95



int8_t  tsNeedTrim = 0;










96












97



// queue & threads










98



int32_t tsQueryMinConcurrentTaskNum = 1;










99



int32_t tsQueryMaxConcurrentTaskNum = 0;










100



int32_t tsQueryConcurrentTaskNum = 0;










101



int32_t tsQueryNoFetchTimeoutSec = 3600 * 5;










102












103



int32_t tsNumOfRpcThreads = 1;










104



int32_t tsNumOfRpcSessions = 30000;










105



#ifdef WINDOWS










106



int32_t tsShareConnLimit = 1;










107



#else










108



int32_t tsShareConnLimit = 10;










109



#endif










110












111



int32_t tsReadTimeout = 900;










112



int32_t tsTimeToGetAvailableConn = 500000;










113



int8_t  tsEnableIpv6 = 0;










114












115



#ifdef TD_ENTERPRISE










116



bool    tsAuthServer = 0;










117



bool    tsAuthReq = 0;










118



int32_t tsAuthReqInterval = 2592000;










119



int32_t tsAuthReqHBInterval = 5;










120



char    tsAuthReqUrl[TSDB_FQDN_LEN] = {0};










121



#endif










122












123



int32_t tsNumOfQueryThreads = 0;










124



int32_t tsNumOfCommitThreads = 2;










125



int32_t tsNumOfTaskQueueThreads = 16;










126



int32_t tsNumOfMnodeQueryThreads = 16;










127



int32_t tsNumOfMnodeFetchThreads = 1;










128



int32_t tsNumOfMnodeReadThreads = 1;










129



int32_t tsNumOfVnodeQueryThreads = 16;










130



int32_t tsNumOfVnodeFetchThreads = 4;










131



int32_t tsNumOfVnodeRsmaThreads = 2;










132



int32_t tsNumOfQnodeQueryThreads = 16;










133



int32_t tsNumOfQnodeFetchThreads = 1;










134



int32_t tsNumOfSnodeStreamThreads = 4;










135



int32_t tsNumOfSnodeWriteThreads = 1;










136



int32_t tsPQSortMemThreshold = 16;    // M










137



int32_t tsRetentionSpeedLimitMB = 0;  // unlimited










138



int32_t tsNumOfMnodeStreamMgmtThreads = 2;










139



int32_t tsNumOfStreamMgmtThreads = 2;










140



int32_t tsNumOfVnodeStreamReaderThreads = 16;










141



int32_t tsNumOfStreamTriggerThreads = 4;










142



int32_t tsNumOfStreamRunnerThreads = 4;










143












144



int32_t tsNumOfCompactThreads = 2;










145



int32_t tsNumOfRetentionThreads = 1;










146



int32_t tsSecureEraseMode = 0;










147












148



// sync raft










149



int32_t tsElectInterval = 4000;










150



int32_t tsHeartbeatInterval = 1000;










151



int32_t tsVnodeElectIntervalMs = 4000;










152



int32_t tsVnodeHeartbeatIntervalMs = 1000;










153



int32_t tsMnodeElectIntervalMs = 3000;










154



int32_t tsMnodeHeartbeatIntervalMs = 500;










155



int32_t tsHeartbeatTimeout = 20 * 1000;










156



int32_t tsSnapReplMaxWaitN = 128;










157



int64_t tsLogBufferMemoryAllowed = 0;  // bytes










158



int64_t tsSyncApplyQueueSize = 512;










159



int32_t tsRoutineReportInterval = 300;










160



bool    tsSyncLogHeartbeat = false;










161



int32_t tsSyncTimeout = 0;










162



int64_t tsSyncAssignedCheckAppliedGap = 20;










163












164



// mnode










165



int64_t tsMndSdbWriteDelta = 200;










166



int64_t tsMndLogRetention = 2000;










167



bool    tsMndSkipGrant = false;










168



bool    tsEnableWhiteList = false;  // ip white list cfg










169



bool    tsForceKillTrans = false;










170



int8_t  tsSodEnforceMode = 0;










171












172



// arbitrator










173



int32_t tsArbHeartBeatIntervalSec = 2;










174



int32_t tsArbCheckSyncIntervalSec = 3;










175



int32_t tsArbSetAssignedTimeoutSec = 14;










176



int32_t tsArbHeartBeatIntervalMs = 2000;










177



int32_t tsArbCheckSyncIntervalMs = 3000;










178



int32_t tsArbSetAssignedTimeoutMs = 14000;










179












180



// dnode










181



int64_t tsDndStart = 0;










182



int64_t tsDndStartOsUptime = 0;










183



int64_t tsDndUpTime = 0;










184












185



// dnode misc










186



uint32_t tsEncryptionKeyChksum = 0;










187



int8_t   tsEncryptionKeyStat = ENCRYPT_KEY_STAT_UNSET;










188












189



// taosk encryption keys (multi-layer encryption)










190



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










191



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










192



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










193



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










194



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










195



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










196



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










197



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










198



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










199



int32_t  tsCfgAlgorithm = 0;            // Algorithm type for CFG_KEY










200



int32_t  tsMetaAlgorithm = 0;           // Algorithm type for META_KEY










201



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










202



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










203



int64_t  tsEncryptKeyCreateTime = 0;    // Key creation timestamp










204



int64_t  tsSvrKeyUpdateTime = 0;        // SVR_KEY last update timestamp










205



int64_t  tsDbKeyUpdateTime = 0;         // DB_KEY last update timestamp










206



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










207



char     tsKeyExpirationStrategy[ENCRYPT_KEY_EXPIRE_STRATEGY_LEN + 1] =










208



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










209



uint32_t tsGrant = 1;










210












211



#if defined(TD_FLEX_DEPLOY)










212



int8_t   tsFlexDeploy = 1;










213



#else










214



int8_t   tsFlexDeploy = 0;










215



#endif










216












217



bool tsCompareAsStrInGreatest = true;










218












219



// monitor










220



#ifdef USE_MONITOR










221



bool tsEnableMonitor = true;










222



#else










223



bool    tsEnableMonitor = false;










224



#endif










225



int32_t  tsMonitorInterval = 30;










226



char     tsMonitorFqdn[TSDB_FQDN_LEN] = {0};










227



uint16_t tsMonitorPort = 6043;










228



int32_t  tsMonitorMaxLogs = 100;










229



bool     tsMonitorComp = false;










230



bool     tsMonitorLogProtocol = false;










231



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










232



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










233



int32_t  tsMetricsInterval = 30;  // second










234



#ifdef USE_MONITOR










235



bool tsMonitorForceV2 = true;










236



#else










237



bool    tsMonitorForceV2 = false;










238



#endif










239












240



// audit










241



#ifdef USE_AUDIT










242



bool    tsEnableAudit = true;










243



bool    tsEnableAuditCreateTable = true;










244



bool    tsEnableAuditDelete = true;










245



bool    tsEnableAuditSelect = true;










246



bool    tsEnableAuditInsert = true;










247



int32_t tsAuditInterval = 5000;










248



int32_t tsAuditLevel = AUDIT_LEVEL_DATABASE;










249



bool    tsAuditHttps = false;










250



bool    tsAuditUseToken = true;










251



bool    tsAuditSaveInSelf = false;










252



#else










253



bool    tsEnableAudit = false;










254



bool    tsEnableAuditCreateTable = false;










255



bool    tsEnableAuditDelete = false;










256



bool    tsEnableAuditSelect = false;










257



bool    tsEnableAuditInsert = false;










258



int32_t tsAuditInterval = 200000;










259



int32_t tsAuditLevel = AUDIT_LEVEL_NONE;










260



bool    tsAuditHttps = false;










261



bool    tsAuditUseToken = true;










262



bool    tsAuditSaveInSelf = false;










263



#endif










264












265



// telem










266



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










267



bool tsEnableTelem = false;










268



#else










269



bool    tsEnableTelem = true;










270



#endif










271



int32_t  tsTelemInterval = 86400;










272



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










273



uint16_t tsTelemPort = 80;










274



char    *tsTelemUri = "/report";










275












276



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










277



bool tsEnableCrashReport = false;










278



#else










279



bool    tsEnableCrashReport = true;










280



#endif










281



char   *tsClientCrashReportUri = "/ccrashreport";










282



char   *tsSvrCrashReportUri = "/dcrashreport";










283



int32_t tsSafetyCheckLevel = TSDB_SAFETY_CHECK_LEVELL_NORMAL;










284












285



// schemaless










286



bool tsSmlDot2Underline = true;










287



char tsSmlTsDefaultName[TSDB_COL_NAME_LEN] = "_ts";










288



char tsSmlTagName[TSDB_COL_NAME_LEN] = "_tag_null";










289



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










290



char tsSmlAutoChildTableNameDelimiter[TSDB_TABLE_NAME_LEN] = "";










291



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










292



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










293



// bool    tsSmlDataFormat = false;










294



// int32_t tsSmlBatchSize = 10000;










295












296



// checkpoint backup










297



char    tsSnodeAddress[TSDB_FQDN_LEN] = {0};










298



int32_t tsRsyncPort = 873;










299



#ifdef WINDOWS










300



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










301



#else










302



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










303



#endif










304












305



// tmq










306



int32_t tmqMaxTopicNum = 20;










307



char    tmqWriteRefDB[TSDB_DB_NAME_LEN] = {0};










308



bool    tmqWriteCheckRef = false;










309












310



// query










311



int32_t tsQueryPolicy = 1;










312



bool    tsQueryTbNotExistAsEmpty = false;










313



int32_t tsQueryRspPolicy = 0;










314



int64_t tsQueryMaxConcurrentTables = 200;  // unit is TSDB_TABLE_NUM_UNIT










315



bool    tsEnableQueryHb = true;










316



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










317



bool    tsSqlSecurityEnabled = false;










318



int32_t tsSqlSecurityWhitelistMode = 0;










319



bool    tsSqlSecurityStringCheck = true;










320



bool    tsSqlSecurityASTCheck = true;










321



#ifdef WINDOWS










322



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










323



#else










324



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










325



#endif










326



bool    tsWhitelistLearning = false;










327



int32_t tsWhitelistLearningPeriod = 7;










328



int32_t tsWhitelistLearningThreshold = 10;










329



int32_t tsQuerySmaOptimize = 0;










330



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










331



bool    tsQueryPlannerTrace = false;










332



int32_t tsQueryNodeChunkSize = 32 * 1024;










333



bool    tsQueryUseNodeAllocator = true;










334



bool    tsKeepColumnName = false;










335



int32_t tsRedirectPeriod = 10;










336



int32_t tsRedirectFactor = 2;










337



int32_t tsRedirectMaxPeriod = 1000;










338



int32_t tsMaxRetryWaitTime = 20000;










339



bool    tsUseAdapter = false;










340



int32_t tsMetaCacheMaxSize = -1;                   // MB










341



int32_t tsSlowLogThreshold = 10;                   // seconds










342



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










343



int32_t tsSlowLogScope = SLOW_LOG_TYPE_QUERY;










344



char   *tsSlowLogScopeString = "query";










345



int32_t tsSlowLogMaxLen = 4096;










346



int32_t tsTimeSeriesThreshold = 50;










347



bool    tsMultiResultFunctionStarReturnTags = false;










348












349



/*










350



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










351



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










352



 *










353



 * 0: all data are compressed










354



 * -1: all data are not compressed










355



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










356



 */










357



int32_t tsCompressMsgSize = -1;










358












359



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










360



int32_t tsCountAlwaysReturnValue = 1;










361












362



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










363



int32_t tsMinSlidingTime = 1;










364












365



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










366



int32_t tsMinIntervalTime = 1;










367












368



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










369



int32_t tsMaxInsertBatchRows = 1000000;










370












371



// maximum length of a SQL statement










372



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










373












374



float   tsSelectivityRatio = 1.0;










375



int32_t tsTagFilterResCacheSize = 1024 * 10;










376



char    tsTagFilterCache = 0;










377



char    tsStableTagFilterCache = 0;










378



int64_t tsMetaEntryCacheSize = TSDB_DEFAULT_MECACHE_SIZE;










379



char    tsMetaEntryCache = 0;










380












381



int32_t tsBypassFlag = 0;










382












383












384



int32_t  tsDiskCfgNum = 0;










385



SDiskCfg tsDiskCfg[TFS_MAX_DISKS] = {0};










386



int64_t  tsMinDiskFreeSize = TFS_MIN_DISK_FREE_SIZE;










387












388



/*










389



 * minimum scale for whole system, millisecond by default










390



 * for TSDB_TIME_PRECISION_MILLI: 60000L










391



 *     TSDB_TIME_PRECISION_MICRO: 60000000L










392



 *     TSDB_TIME_PRECISION_NANO:  60000000000L










393



 */










394



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










395



/*










396



 * millisecond by default










397



 * for TSDB_TIME_PRECISION_MILLI: 3600000L










398



 *     TSDB_TIME_PRECISION_MICRO: 3600000000L










399



 *     TSDB_TIME_PRECISION_NANO:  3600000000000L










400



 */










401



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










402












403



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










404












405



// lossy compress 7










406



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










407



                                           // set empty can close lossy compress.










408



// below option can take effect when tsLossyColumns not empty










409



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










410



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










411



uint32_t tsMaxRange = 500;                      // max quantization intervals










412



uint32_t tsCurRange = 100;                      // current quantization intervals










413



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










414



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










415












416



// udf










417



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










418



bool tsStartUdfd = false;










419



#else










420



bool    tsStartUdfd = true;










421



#endif










422












423



// wal










424



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










425



bool    tsWalForceRepair = 0;










426



bool    tsWalDeleteOnCorruption = false;










427












428



// ttl










429



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










430



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










431



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










432



                                      */










433



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










434












435



// internal










436



bool    tsDiskIDCheckEnabled = false;










437



int32_t tsTransPullupInterval = 2;










438



int32_t tsCompactPullupInterval = 10;










439



int32_t tsScanPullupInterval = 10;










440



int32_t tsInstancePullupInterval = 5;










441



int32_t tsMqRebalanceInterval = 2;










442



int32_t tsTtlUnit = 86400;










443



int32_t tsTtlPushIntervalSec = 10;










444



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










445



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










446



int32_t tsGrantHBInterval = 60;










447



int32_t tsUptimeInterval = 300;    // seconds










448



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










449



char    tsUdfdLdLibPath[512] = "";










450



bool    tsDisableStream = false;










451



int32_t tsStreamBufferSize = 0;       // MB










452



int64_t tsStreamBufferSizeBytes = 0;  // bytes










453



bool    tsStreamPerfLogEnabled = false;










454



bool    tsFilterScalarMode = false;










455












456



bool tsUpdateCacheBatch = true;










457












458



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










459



char    tsSsAccessString[1024] = "";










460



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










461



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










462



                                   // negative value, which is a bug.










463



int32_t tsSsBlockCacheSize = 16;   // number of blocks










464



int32_t tsSsPageCacheSize = 4096;  // number of pages










465



int32_t tsSsUploadDelaySec = 60;










466



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










467












468



bool tsExperimental = true;










469












470



int32_t tsMaxTsmaNum = 10;










471



int32_t tsMaxTsmaCalcDelay = 600;










472



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










473



void   *pTimezoneNameMap = NULL;










474












475



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










476



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










477



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










478












479



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










480












481



int64_t tsTimestampDeltaLimit = 900;  // s










482



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










483












484



int32_t sessionPerUser = -1;










485



int32_t sessionConnTime = -1;










486



int32_t sessionConnIdleTime = -1;










487



int32_t sessionMaxConcurrency = -1;










488



int32_t sessionMaxCallVnodeNum = -1;










489












490



bool    tsSessionControl = 1;










491



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










492












493



void taosSetSkipKeyCheckMode(void) { tsSkipKeyCheckMode = true; }




716,862✔





494












495



#define TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, pName) \










496



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










497



    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);           \










498



  }










499












500



#ifndef _STORAGE










501



int32_t taosSetTfsCfg(SConfig *pCfg) {










502



  SConfigItem *pItem = NULL;










503



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "dataDir");










504



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










505












506



  int32_t size = taosArrayGetSize(pItem->array);










507



  tsDiskCfgNum = 1;










508



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










509



  tsDiskCfg[0].level = 0;










510



  tsDiskCfg[0].primary = 1;










511



  tsDiskCfg[0].disable = 0;










512



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










513



  if (taosMulMkDir(tsDataDir) != 0) {










514



    int32_t code = TAOS_SYSTEM_ERROR(ERRNO);










515



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










516



    TAOS_RETURN(code);










517



  }










518



  TAOS_RETURN(TSDB_CODE_SUCCESS);










519



}










520



#else










521



int32_t taosSetTfsCfg(SConfig *pCfg);










522



#endif










523












524



#ifndef _STORAGE










525



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










526



#else










527



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










528



#endif










529












530



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




3,708✔





531



  return cfgUpdateTfsItemDisable(pCfg, value, pTfs);




3,708✔





532



}










533












534



struct SConfig *taosGetCfg() { return tsCfg; }




367,310✔





535












536



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




5,994,042✔





537



                           char *apolloUrl) {










538



  int32_t code = 0;




5,994,042✔





539



  char    cfgDir[PATH_MAX] = {0};




5,994,042✔





540



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




5,994,042✔





541












542



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




5,994,042✔





543



  int32_t pos = strlen(cfgDir);




5,994,042✔





544



  if (pos > 0) {




5,994,042✔





545



    pos -= 1;




5,993,915✔





546



  }










547



  char  lastC = cfgDir[pos];




5,994,042✔





548



  char *tdDirsep = TD_DIRSEP;




5,994,042✔





549



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




5,994,042✔





550



    tdDirsep = "";




1,985,641✔





551



  }










552



  if (taosIsDir(cfgDir)) {




5,994,042✔





553



#ifdef CUS_PROMPT










554



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




5,275,351✔





555



                   "%s"










556



                   "%s"










557



                   "%s.cfg",










558



                   cfgDir, tdDirsep, CUS_PROMPT);










559



#else










560



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










561



                   "%s"










562



                   "%s"










563



                   "taos.cfg",










564



                   cfgDir, tdDirsep);










565



#endif










566



  } else {










567



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




718,691✔





568



  }










569












570



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




5,994,042✔





571



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




1,390,186✔





572



  }










573












574



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




5,994,042✔





575



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




16✔





576



    TAOS_RETURN(code);




16✔





577



  }










578












579



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




5,994,026✔






UNCOV

580



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




×







581



    TAOS_RETURN(code);




×







582



  }










583












584



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




5,994,026✔





585



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




16✔





586



    TAOS_RETURN(code);




16✔





587



  }










588












589



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




5,994,010✔






UNCOV

590



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




×








UNCOV

591



    TAOS_RETURN(code);




×







592



  }










593












594



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




5,994,010✔






UNCOV

595



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




×








UNCOV

596



    TAOS_RETURN(code);




×







597



  }










598












599



  TAOS_RETURN(TSDB_CODE_SUCCESS);




5,994,010✔





600



}










601












602



int32_t taosAddClientLogCfg(SConfig *pCfg) {




5,994,042✔





603



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




5,994,042✔





604



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




5,994,042✔





605



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




5,994,042✔





606



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




5,994,042✔





607



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










608



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




5,994,042✔





609



                                CFG_DYN_ENT_BOTH, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










610



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




5,994,042✔





611



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




5,994,042✔





612



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










613



  TAOS_CHECK_RETURN(




5,994,042✔





614



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










615



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




5,994,042✔





616



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










617



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




5,994,042✔





618



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










619



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




5,994,042✔





620



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










621



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




5,994,042✔





622



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










623



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




5,994,042✔





624



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










625



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




5,994,042✔





626



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










627



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




5,994,042✔





628



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










629



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




5,994,042✔





630



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










631



  TAOS_RETURN(TSDB_CODE_SUCCESS);




5,994,042✔





632



}










633












634



static int32_t taosAddServerLogCfg(SConfig *pCfg) {




2,812,300✔





635



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




2,812,300✔





636



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










637



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




2,812,300✔





638



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










639



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




2,812,300✔





640



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










641



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




2,812,300✔





642



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










643



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




2,812,300✔





644



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










645



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




2,812,300✔





646



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










647



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




2,812,300✔





648



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










649



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




2,812,300✔





650



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










651



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




2,812,300✔





652



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










653



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




2,812,300✔





654



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










655



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




2,812,300✔





656



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










657



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




2,812,300✔





658



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










659



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




2,812,300✔





660



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










661



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




2,812,300✔





662



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










663



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




2,812,300✔





664



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










665



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




2,812,300✔





666



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










667



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




2,812,300✔





668



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










669



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




2,812,300✔





670



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










671



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




2,812,300✔





672



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










673



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




2,812,300✔





674



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










675



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




2,812,300✔





676



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










677



  TAOS_RETURN(TSDB_CODE_SUCCESS);




2,812,300✔





678



}










679












680



static int32_t taosAddClientCfg(SConfig *pCfg) {




2,997,041✔





681



  char    defaultFqdn[TSDB_FQDN_LEN] = {0};




2,997,041✔





682



  int32_t defaultServerPort = 6030;




2,997,041✔





683



  int32_t defaultMqttPort = 6083;




2,997,041✔





684



  int64_t cost = 0;




2,997,041✔





685



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




2,997,041✔






UNCOV

686



    tstrncpy(defaultFqdn, "localhost", TSDB_FQDN_LEN);




×







687



  }










688



  if (cost >= 1000) {




2,997,041✔






UNCOV

689



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




×







690



  }










691












692



  TAOS_CHECK_RETURN(




2,997,041✔





693



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










694



  TAOS_CHECK_RETURN(




2,997,041✔





695



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










696



  TAOS_CHECK_RETURN(




2,997,041✔





697



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










698



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




2,997,041✔





699



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










700



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




2,997,041✔





701



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










702



  TAOS_CHECK_RETURN(




2,997,041✔





703



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










704



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




2,997,041✔





705



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










706



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




2,997,041✔





707



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










708



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




2,997,041✔





709



                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










710



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




2,997,041✔





711



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










712



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




2,997,041✔





713



                               CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










714



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




2,997,041✔





715



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










716



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




2,997,041✔





717



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










718



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




2,997,041✔





719



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










720



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




2,997,041✔





721



                               CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










722



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




2,997,041✔





723



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










724



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




2,997,041✔





725



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










726



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




2,997,041✔





727



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










728



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




2,997,041✔





729



                                 CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










730



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




2,997,041✔





731



                                 CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










732



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




2,997,041✔





733



                                 CFG_PRIV_SYSTEM));










734



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




2,997,041✔





735



                                 CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










736



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




2,997,041✔





737



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










738












739



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




2,997,041✔





740



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










741



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




2,997,041✔





742



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










743



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




2,997,041✔





744



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM) != 0);










745



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




2,997,041✔





746



                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










747



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




2,997,041✔





748



                               CFG_PRIV_SYSTEM));










749



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




2,997,041✔





750



                               CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










751



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




2,997,041✔





752



                                CFG_SCOPE_CLIENT, CFG_DYN_NONE, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










753



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




2,997,041✔





754



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










755



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




2,997,041✔





756



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_DEBUG));










757



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




2,997,041✔





758



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_DEBUG));










759



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




2,997,041✔





760



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_DEBUG));










761



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




2,997,041✔





762



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










763



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




2,997,041✔





764



                                CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










765



  tsNumOfRpcThreads = tsNumOfCores / 2;




2,997,041✔





766



  tsNumOfRpcThreads = TRANGE(tsNumOfRpcThreads, 2, TSDB_MAX_RPC_THREADS);




2,997,041✔





767



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




2,997,041✔





768



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










769












770



  tsNumOfRpcSessions = TRANGE(tsNumOfRpcSessions, 100, 100000);




2,997,041✔





771



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




2,997,041✔





772



                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










773



  tsShareConnLimit = TRANGE(tsShareConnLimit, 1, 512);




2,997,041✔





774



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




2,997,041✔





775



                                CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










776












777



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




2,997,041✔





778



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




2,997,041✔





779



                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










780



  tsTimeToGetAvailableConn = TRANGE(tsTimeToGetAvailableConn, 20, 10000000);




2,997,041✔





781



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




2,997,041✔





782



                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










783



  tsNumOfTaskQueueThreads = tsNumOfCores * 2;




2,997,041✔





784



  tsNumOfTaskQueueThreads = TMAX(tsNumOfTaskQueueThreads, 16);




2,997,041✔





785












786



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




2,997,041✔





787



                                CFG_DYN_CLIENT_LAZY, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










788



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




2,997,041✔





789



                               CFG_CATEGORY_GLOBAL, CFG_PRIV_DEBUG));










790



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




2,997,041✔





791



                               CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










792



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




2,997,041✔





793



                                CFG_DYN_BOTH, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










794



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




2,997,041✔





795



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










796



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




2,997,041✔





797



                                CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










798












799



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




2,997,041✔





800



                               CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










801












802



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




2,997,041✔





803



                               CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










804












805



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




2,997,041✔





806



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










807



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




2,997,041✔





808



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










809



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




2,997,041✔





810



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










811












812



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




2,997,041✔





813



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










814












815



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




2,997,041✔





816



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










817












818



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




2,997,041✔





819



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










820












821



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




2,997,041✔





822



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










823












824



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




2,997,041✔





825



                                 CFG_PRIV_SYSTEM));










826












827



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




2,997,041✔





828



                               CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));










829



  // sql fire wall configuration










830



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




2,997,041✔





831



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










832



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




2,997,041✔





833



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










834



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




2,997,041✔





835



                               CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










836



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




2,997,041✔





837



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










838



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




2,997,041✔





839



                                 CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










840



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




2,997,041✔





841



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










842



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




2,997,041✔





843



                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










844



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




2,997,041✔





845



                                CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










846



  TAOS_RETURN(TSDB_CODE_SUCCESS);




2,997,041✔





847



}










848












849



static int32_t taosAddSystemCfg(SConfig *pCfg) {




2,997,041✔





850



  SysNameInfo info = taosGetSysNameInfo();




2,997,041✔





851












852



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




2,997,041✔





853



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




2,997,041✔





854



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




2,997,041✔





855



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




2,997,041✔





856



                               CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));










857



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




2,997,041✔





858



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










859












860



  TAOS_CHECK_RETURN(




2,997,041✔





861



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










862



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




2,997,041✔





863



                               CFG_PRIV_SYSTEM));










864



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




2,997,041✔





865



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










866



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




2,997,041✔





867



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










868



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




2,997,041✔





869



                               CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










870



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




2,997,041✔





871



                                TSDB_MAX_MECACHE_SIZE, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER, CFG_CATEGORY_LOCAL,










872



                                CFG_PRIV_SYSTEM));










873












874



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




2,997,041✔





875



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










876



#if !defined(_ALPINE)










877



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




2,997,041✔





878



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










879



#endif










880



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




2,997,041✔





881



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










882



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




2,997,041✔





883



                                CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










884



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




2,997,041✔





885



                                 CFG_PRIV_SYSTEM));










886



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




2,997,041✔





887



                                 CFG_PRIV_SYSTEM));










888



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




2,997,041✔





889



                                 CFG_PRIV_SYSTEM));










890



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




2,997,041✔





891



                                 CFG_PRIV_SYSTEM));










892



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




2,997,041✔





893



                                 CFG_PRIV_SYSTEM));










894












895



  TAOS_CHECK_RETURN(




2,997,041✔





896



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










897



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




2,997,041✔





898



                                 CFG_CATEGORY_LOCAL, CFG_PRIV_SYSTEM));










899



  TAOS_CHECK_RETURN(




2,997,041✔





900



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










901



  TAOS_CHECK_RETURN(




2,997,041✔





902



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










903












904



  TAOS_CHECK_RETURN(




2,997,041✔





905



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










906












907



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




2,997,041✔





908



                                 CFG_PRIV_SECURITY));










909



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




2,997,041✔





910



                                 CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));










911



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




2,997,041✔





912



                                 CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));










913



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




2,997,041✔





914



                                 CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));










915



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




2,997,041✔





916



                                 CFG_CATEGORY_GLOBAL, CFG_PRIV_SECURITY));










917












918



  TAOS_CHECK_RETURN(




2,997,041✔





919



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










920












921



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




2,997,041✔





922



                               CFG_PRIV_SECURITY));










923



  TAOS_RETURN(TSDB_CODE_SUCCESS);




2,997,041✔





924



}










925












926



static int32_t taosAddServerCfg(SConfig *pCfg) {




1,406,134✔





927



  tsNumOfCommitThreads = tsNumOfCores / 2;




1,406,134✔





928



  tsNumOfCommitThreads = TRANGE(tsNumOfCommitThreads, 2, 4);




1,406,134✔





929












930



  tsNumOfSupportVnodes = tsNumOfCores * 2 + 5;




1,406,134✔





931



  tsNumOfSupportVnodes = TMAX(tsNumOfSupportVnodes, 2);




1,406,134✔





932












933



  tsNumOfMnodeReadThreads = tsNumOfCores / 8;




1,406,134✔





934



  tsNumOfMnodeReadThreads = TRANGE(tsNumOfMnodeReadThreads, 1, 4);




1,406,134✔





935












936



  tsNumOfVnodeQueryThreads = tsNumOfCores * 2;




1,406,134✔





937



  tsNumOfVnodeQueryThreads = TMAX(tsNumOfVnodeQueryThreads, 16);




1,406,134✔





938












939



  tsNumOfVnodeFetchThreads = tsNumOfCores / 4;




1,406,134✔





940



  tsNumOfVnodeFetchThreads = TMAX(tsNumOfVnodeFetchThreads, 4);




1,406,134✔





941












942



  tsNumOfVnodeRsmaThreads = tsNumOfCores / 4;




1,406,134✔





943



  tsNumOfVnodeRsmaThreads = TMAX(tsNumOfVnodeRsmaThreads, 4);




1,406,134✔





944












945



  tsNumOfQnodeQueryThreads = tsNumOfCores * 2;




1,406,134✔





946



  tsNumOfQnodeQueryThreads = TMAX(tsNumOfQnodeQueryThreads, 16);




1,406,134✔





947












948



  tsNumOfMnodeStreamMgmtThreads = tsNumOfCores / 4;




1,406,134✔





949



  tsNumOfMnodeStreamMgmtThreads = TRANGE(tsNumOfMnodeStreamMgmtThreads, 2, 5);




1,406,134✔





950












951



  tsNumOfStreamMgmtThreads = tsNumOfCores / 8;




1,406,134✔





952



  tsNumOfStreamMgmtThreads = TRANGE(tsNumOfStreamMgmtThreads, 2, 5);




1,406,134✔





953












954



  tsNumOfVnodeStreamReaderThreads = tsNumOfCores / 2;




1,406,134✔





955



  tsNumOfVnodeStreamReaderThreads = TMAX(tsNumOfVnodeStreamReaderThreads, 2);




1,406,134✔





956












957



  tsNumOfStreamTriggerThreads = tsNumOfCores;




1,406,134✔





958



  tsNumOfStreamTriggerThreads = TMAX(tsNumOfStreamTriggerThreads, 4);




1,406,134✔





959












960



  tsNumOfStreamRunnerThreads = tsNumOfCores;




1,406,134✔





961



  tsNumOfStreamRunnerThreads = TMAX(tsNumOfStreamRunnerThreads, 4);




1,406,134✔





962












963



  tsQueueMemoryAllowed = tsTotalMemoryKB * 1024 * RPC_MEMORY_USAGE_RATIO * QUEUE_MEMORY_USAGE_RATIO;




1,406,134✔





964



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




1,406,134✔





965



                                TSDB_MAX_MSG_SIZE * QUEUE_MEMORY_USAGE_RATIO * 10000LL);










966












967



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




1,406,134✔





968



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




1,406,134✔





969



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










970












971



  tsLogBufferMemoryAllowed = tsTotalMemoryKB * 1024 * 0.1;




1,406,134✔





972



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




1,406,134✔





973












974



  tsStreamBufferSize = tsTotalMemoryKB / 1024 * 0.3;




1,406,134✔





975



  tsStreamBufferSizeBytes = tsStreamBufferSize * 1048576L;




1,406,134✔





976












977



  // clang-format off










978



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




1,406,134✔





979



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




1,406,134✔





980



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




1,406,134✔





981












982



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




1,406,134✔





983



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




1,406,134✔





984



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




1,406,134✔





985



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




1,406,134✔





986



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




1,406,134✔





987



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




1,406,134✔





988












989



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




1,406,134✔





990



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




1,406,134✔





991



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




1,406,134✔





992



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




1,406,134✔





993



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




1,406,134✔





994



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




1,406,134✔





995



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




1,406,134✔





996



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




1,406,134✔





997












998



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




1,406,134✔





999



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




1,406,134✔





1000



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




1,406,134✔





1001



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




1,406,134✔





1002



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




1,406,134✔





1003



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




1,406,134✔





1004



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




1,406,134✔





1005



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




1,406,134✔





1006



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










1007



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




1,406,134✔





1008



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




1,406,134✔





1009












1010



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




1,406,134✔





1011



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




1,406,134✔





1012



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




1,406,134✔





1013












1014



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




1,406,134✔





1015



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




1,406,134✔





1016












1017












1018



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




1,406,134✔





1019



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




1,406,134✔





1020



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




1,406,134✔





1021



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




1,406,134✔





1022



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




1,406,134✔





1023



  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,406,134✔





1024



  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,406,134✔





1025



  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,406,134✔





1026



  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,406,134✔





1027



  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,406,134✔





1028



  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,406,134✔





1029



  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,406,134✔





1030



  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,406,134✔





1031



  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,406,134✔





1032



  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,406,134✔





1033



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




1,406,134✔





1034



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




1,406,134✔





1035



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




1,406,134✔





1036



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




1,406,134✔





1037












1038



  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,406,134✔





1039



  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "syncAssignedCheckAppliedGap", tsSyncAssignedCheckAppliedGap, 0, 10000, CFG_SCOPE_SERVER, CFG_DYN_SERVER,CFG_CATEGORY_GLOBAL, CFG_PRIV_SYSTEM));




1,406,134✔





1040












1041



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




1,406,134✔





1042



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




1,406,134✔





1043



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




1,406,134✔





1044



  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,406,134✔





1045



  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,406,134✔





1046



  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,406,134✔





1047












1048



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




1,406,134✔





1049



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




1,406,134✔





1050



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




1,406,134✔





1051












1052



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




1,406,134✔





1053



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




1,406,134✔





1054












1055



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




1,406,134✔





1056



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




1,406,134✔





1057



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




1,406,134✔





1058



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




1,406,134✔





1059












1060



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




1,406,134✔





1061



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




1,406,134✔





1062



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




1,406,134✔





1063



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




1,406,134✔





1064



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




1,406,134✔





1065



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




1,406,134✔





1066












1067



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




1,406,134✔





1068



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




1,406,134✔





1069



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




1,406,134✔





1070



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




1,406,134✔





1071



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




1,406,134✔





1072



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




1,406,134✔





1073



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




1,406,134✔





1074



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




1,406,134✔





1075



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




1,406,134✔





1076



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




1,406,134✔





1077



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




1,406,134✔





1078



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




1,406,134✔





1079



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




1,406,134✔





1080



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




1,406,134✔





1081












1082



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




1,406,134✔





1083



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




1,406,134✔





1084



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




1,406,134✔





1085












1086



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




1,406,134✔





1087












1088



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




1,406,134✔





1089



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




1,406,134✔





1090



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




1,406,134✔





1091



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




1,406,134✔





1092



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




1,406,134✔





1093












1094



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




1,406,134✔





1095



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




1,406,134✔





1096



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




1,406,134✔





1097



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




1,406,134✔





1098



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




1,406,134✔





1099



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




1,406,134✔





1100



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




1,406,134✔





1101



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




1,406,134✔





1102



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




1,406,134✔





1103



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




1,406,134✔





1104



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




1,406,134✔





1105












1106



  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,406,134✔





1107



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




1,406,134✔





1108












1109



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




1,406,134✔





1110



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




1,406,134✔





1111



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




1,406,134✔





1112



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




1,406,134✔





1113



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




1,406,134✔





1114



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




1,406,134✔





1115



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




1,406,134✔





1116



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




1,406,134✔





1117



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




1,406,134✔





1118



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




1,406,134✔





1119



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




1,406,134✔





1120



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




1,406,134✔





1121



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




1,406,134✔





1122



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




1,406,134✔





1123



  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,406,134✔





1124



  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,406,134✔





1125












1126












1127



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




1,406,134✔





1128



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




1,406,134✔





1129



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




1,406,134✔





1130



  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,406,134✔





1131



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




1,406,134✔





1132



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




1,406,134✔





1133












1134



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




1,406,134✔





1135



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




1,406,134✔





1136



  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,406,134✔





1137



#ifdef TD_ENTERPRISE










1138



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




1,406,134✔





1139



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




1,406,134✔





1140



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




1,406,134✔





1141



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




1,406,134✔





1142



#endif










1143



  // clang-format on










1144












1145



  // GRANT_CFG_ADD;










1146



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,406,134✔





1147



}










1148












1149



static int32_t taosUpdateServerCfg(SConfig *pCfg) {




1,933,620✔





1150



  SConfigItem *pItem;










1151



  ECfgSrcType  stype;










1152



  int32_t      numOfCores;










1153



  int64_t      totalMemoryKB;










1154












1155



  pItem = cfgGetItem(pCfg, "numOfCores");




1,933,620✔





1156



  if (pItem == NULL) {




1,933,620✔






UNCOV

1157



    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);




×







1158



  } else {










1159



    stype = pItem->stype;




1,933,620✔





1160



    numOfCores = pItem->fval;




1,933,620✔





1161



  }










1162












1163



  pItem = cfgGetItem(pCfg, "supportVnodes");




1,933,620✔





1164



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




1,933,620✔





1165



    tsNumOfSupportVnodes = numOfCores * 2 + 5;




86✔





1166



    tsNumOfSupportVnodes = TMAX(tsNumOfSupportVnodes, 2);




86✔





1167



    pItem->i32 = tsNumOfSupportVnodes;




86✔





1168



    pItem->stype = stype;




86✔





1169



  }










1170












1171



  pItem = cfgGetItem(pCfg, "numOfRpcThreads");




1,933,620✔





1172



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




1,933,620✔





1173



    tsNumOfRpcThreads = TRANGE(tsNumOfRpcThreads, 1, TSDB_MAX_RPC_THREADS);




1,932,582✔





1174



    pItem->i32 = tsNumOfRpcThreads;




1,932,582✔





1175



    pItem->stype = stype;




1,932,582✔





1176



  }










1177












1178



  pItem = cfgGetItem(pCfg, "numOfRpcSessions");




1,933,620✔





1179



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




1,933,620✔





1180



    tsNumOfRpcSessions = TRANGE(tsNumOfRpcSessions, 100, 10000);




1,932,582✔





1181



    pItem->i32 = tsNumOfRpcSessions;




1,932,582✔





1182



    pItem->stype = stype;




1,932,582✔





1183



  }










1184












1185



  pItem = cfgGetItem(pCfg, "shareConnLimit");




1,933,620✔





1186



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




1,933,620✔





1187



    tsShareConnLimit = TRANGE(tsShareConnLimit, 1, 512);




1,933,101✔





1188



    pItem->i32 = tsShareConnLimit;




1,933,101✔





1189



    pItem->stype = stype;




1,933,101✔





1190



  }










1191












1192



  pItem = cfgGetItem(pCfg, "readTimeout");




1,933,620✔





1193



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




1,933,620✔





1194



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




1,933,101✔





1195



    pItem->i32 = tsReadTimeout;




1,933,101✔





1196



    pItem->stype = stype;




1,933,101✔





1197



  }










1198












1199



  pItem = cfgGetItem(pCfg, "timeToGetAvailableConn");




1,933,620✔





1200



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




1,933,620✔





1201



    tsTimeToGetAvailableConn = TRANGE(tsTimeToGetAvailableConn, 20, 1000000);




1,933,101✔





1202



    pItem->i32 = tsTimeToGetAvailableConn;




1,933,101✔





1203



    pItem->stype = stype;




1,933,101✔





1204



  }










1205












1206



  pItem = cfgGetItem(pCfg, "numOfCommitThreads");




1,933,620✔





1207



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




1,933,620✔





1208



    tsNumOfCommitThreads = numOfCores / 2;




1,933,101✔





1209



    tsNumOfCommitThreads = TRANGE(tsNumOfCommitThreads, 2, 4);




1,933,101✔





1210



    pItem->i32 = tsNumOfCommitThreads;




1,933,101✔





1211



    pItem->stype = stype;




1,933,101✔





1212



  }










1213












1214



  pItem = cfgGetItem(pCfg, "numOfCompactThreads");




1,933,620✔





1215



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




1,933,620✔





1216



    pItem->i32 = tsNumOfCompactThreads;




1,933,101✔





1217



    pItem->stype = stype;




1,933,101✔





1218



  }










1219












1220



  pItem = cfgGetItem(pCfg, "numOfMnodeReadThreads");




1,933,620✔





1221



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




1,933,620✔





1222



    tsNumOfMnodeReadThreads = numOfCores / 8;




1,933,101✔





1223



    tsNumOfMnodeReadThreads = TRANGE(tsNumOfMnodeReadThreads, 1, 4);




1,933,101✔





1224



    pItem->i32 = tsNumOfMnodeReadThreads;




1,933,101✔





1225



    pItem->stype = stype;




1,933,101✔





1226



  }










1227












1228



  pItem = cfgGetItem(pCfg, "numOfVnodeQueryThreads");




1,933,620✔





1229



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




1,933,620✔





1230



    tsNumOfVnodeQueryThreads = numOfCores * 2;




1,931,790✔





1231



    tsNumOfVnodeQueryThreads = TMAX(tsNumOfVnodeQueryThreads, 16);




1,931,790✔





1232



    pItem->i32 = tsNumOfVnodeQueryThreads;




1,931,790✔





1233



    pItem->stype = stype;




1,931,790✔





1234



  }










1235












1236



  pItem = cfgGetItem(pCfg, "numOfVnodeFetchThreads");




1,933,620✔





1237



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




1,933,620✔





1238



    tsNumOfVnodeFetchThreads = numOfCores / 4;




1,933,101✔





1239



    tsNumOfVnodeFetchThreads = TMAX(tsNumOfVnodeFetchThreads, 4);




1,933,101✔





1240



    pItem->i32 = tsNumOfVnodeFetchThreads;




1,933,101✔





1241



    pItem->stype = stype;




1,933,101✔





1242



  }










1243












1244



  pItem = cfgGetItem(pCfg, "numOfVnodeRsmaThreads");




1,933,620✔





1245



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




1,933,620✔





1246



    tsNumOfVnodeRsmaThreads = numOfCores;




1,933,101✔





1247



    tsNumOfVnodeRsmaThreads = TMAX(tsNumOfVnodeRsmaThreads, 4);




1,933,101✔





1248



    pItem->i32 = tsNumOfVnodeRsmaThreads;




1,933,101✔





1249



    pItem->stype = stype;




1,933,101✔





1250



  }










1251












1252



  pItem = cfgGetItem(pCfg, "numOfQnodeQueryThreads");




1,933,620✔





1253



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




1,933,620✔





1254



    tsNumOfQnodeQueryThreads = numOfCores * 2;




1,933,101✔





1255



    tsNumOfQnodeQueryThreads = TMAX(tsNumOfQnodeQueryThreads, 16);




1,933,101✔





1256



    pItem->i32 = tsNumOfQnodeQueryThreads;




1,933,101✔





1257



    pItem->stype = stype;




1,933,101✔





1258



  }










1259












1260



  pItem = cfgGetItem(pCfg, "totalMemoryKB");




1,933,620✔





1261



  if (pItem == NULL) {




1,933,620✔






UNCOV

1262



    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);




×







1263



  } else {










1264



    stype = pItem->stype;




1,933,620✔





1265



    totalMemoryKB = pItem->i64;




1,933,620✔





1266



  }










1267












1268



  pItem = cfgGetItem(pCfg, "rpcQueueMemoryAllowed");




1,933,620✔





1269



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




1,933,620✔





1270



    tsQueueMemoryAllowed = totalMemoryKB * 1024 * 0.1;




1,931,483✔





1271



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




1,931,483✔





1272



    pItem->i64 = tsQueueMemoryAllowed;




1,931,483✔





1273



    pItem->stype = stype;




1,931,483✔





1274



  }










1275












1276



  pItem = cfgGetItem(tsCfg, "syncLogBufferMemoryAllowed");




1,933,620✔





1277



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




1,933,620✔





1278



    tsLogBufferMemoryAllowed = totalMemoryKB * 1024 * 0.1;




1,932,518✔





1279



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




1,932,518✔





1280



    pItem->i64 = tsLogBufferMemoryAllowed;




1,932,518✔





1281



    pItem->stype = stype;




1,932,518✔





1282



  }










1283












1284



  pItem = cfgGetItem(tsCfg, "syncApplyQueueSize");




1,933,620✔





1285



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




1,933,620✔





1286



    pItem->i64 = tsSyncApplyQueueSize;




1,933,604✔





1287



    pItem->stype = stype;




1,933,604✔





1288



  }










1289












1290



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,933,620✔





1291



}










1292












1293



static int32_t taosSetLogOutput(SConfig *pCfg) {




5,997,575✔





1294



  if (tsLogOutput) {




5,997,575✔





1295



    char *pLog = tsLogOutput;




2,807✔





1296



    char *pEnd = NULL;




2,807✔





1297



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




2,807✔





1298



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




357✔





1299



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




293✔





1300



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




293✔





1301



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




119✔





1302



          tstrncpy(tsLogDir, pLog, pathLen);




119✔





1303



        } else {










1304



          int32_t len = strlen(tsLogDir);




174✔





1305



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




174✔





1306



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




174✔





1307



            tsLogDir[len++] = TD_DIRSEP_CHAR;




119✔





1308



          }










1309



          int32_t remain = PATH_MAX - len - 1;




174✔





1310



          if (remain < pathLen) TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);




174✔





1311



          tstrncpy(tsLogDir + len, pLog, pathLen);




174✔





1312



        }










1313



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




293✔





1314



      }










1315



    } else {










1316



      tstrncpy(tsLogDir, pLog, PATH_MAX);




2,450✔





1317



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




2,450✔





1318



    }










1319



  }










1320



  return 0;




5,997,575✔





1321



}










1322












1323



static int32_t taosSetClientLogCfg(SConfig *pCfg) {




5,997,575✔





1324



  SConfigItem *pItem = NULL;




5,997,575✔





1325












1326



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "logDir");




5,997,575✔





1327



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




5,997,575✔





1328



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




5,997,575✔





1329



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




5,997,575✔





1330



  TAOS_CHECK_RETURN(taosSetLogOutput(pCfg));




5,997,575✔





1331












1332



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minimalLogDirGB");




5,997,575✔





1333



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




5,997,575✔





1334












1335



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfLogLines");




5,997,575✔





1336



  tsNumOfLogLines = pItem->i32;




5,997,575✔





1337












1338



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "asyncLog");




5,997,575✔





1339



  tsAsyncLog = pItem->bval;




5,997,575✔





1340












1341



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "logKeepDays");




5,997,575✔





1342



  tsLogKeepDays = pItem->i32;




5,997,575✔





1343












1344



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tmrDebugFlag");




5,997,575✔





1345



  tmrDebugFlag = pItem->i32;




5,997,575✔





1346












1347



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "uDebugFlag");




5,997,575✔





1348



  uDebugFlag = pItem->i32;




5,997,575✔





1349












1350



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "jniDebugFlag");




5,997,575✔





1351



  jniDebugFlag = pItem->i32;




5,997,575✔





1352












1353



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "rpcDebugFlag");




5,997,575✔





1354



  rpcDebugFlag = pItem->i32;




5,997,575✔





1355












1356



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "qDebugFlag");




5,997,575✔





1357



  qDebugFlag = pItem->i32;




5,997,575✔





1358












1359



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "cDebugFlag");




5,997,575✔





1360



  cDebugFlag = pItem->i32;




5,997,575✔





1361












1362



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "simDebugFlag");




5,997,575✔





1363



  simDebugFlag = pItem->i32;




5,997,575✔





1364












1365



  TAOS_RETURN(TSDB_CODE_SUCCESS);




5,997,575✔





1366



}










1367












1368



static int32_t taosSetServerLogCfg(SConfig *pCfg) {




1,406,134✔





1369



  SConfigItem *pItem = NULL;




1,406,134✔





1370



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "dDebugFlag");




1,406,134✔





1371



  dDebugFlag = pItem->i32;




1,406,134✔





1372












1373



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "vDebugFlag");




1,406,134✔





1374



  vDebugFlag = pItem->i32;




1,406,134✔





1375












1376



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mDebugFlag");




1,406,134✔





1377



  mDebugFlag = pItem->i32;




1,406,134✔





1378












1379



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "wDebugFlag");




1,406,134✔





1380



  wDebugFlag = pItem->i32;




1,406,134✔





1381












1382



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "azDebugFlag");




1,406,134✔





1383



  azDebugFlag = pItem->i32;




1,406,134✔





1384












1385



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tssDebugFlag");




1,406,134✔





1386



  tssDebugFlag = pItem->i32;




1,406,134✔





1387












1388



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sDebugFlag");




1,406,134✔





1389



  sDebugFlag = pItem->i32;




1,406,134✔





1390












1391



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tsdbDebugFlag");




1,406,134✔





1392



  tsdbDebugFlag = pItem->i32;




1,406,134✔





1393












1394



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tqDebugFlag");




1,406,134✔





1395



  tqDebugFlag = pItem->i32;




1,406,134✔





1396












1397



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "fsDebugFlag");




1,406,134✔





1398



  fsDebugFlag = pItem->i32;




1,406,134✔





1399












1400



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udfDebugFlag");




1,406,134✔





1401



  udfDebugFlag = pItem->i32;




1,406,134✔





1402












1403



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smaDebugFlag");




1,406,134✔





1404



  smaDebugFlag = pItem->i32;




1,406,134✔





1405












1406



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "idxDebugFlag");




1,406,134✔





1407



  idxDebugFlag = pItem->i32;




1,406,134✔





1408












1409



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tdbDebugFlag");




1,406,134✔





1410



  tdbDebugFlag = pItem->i32;




1,406,134✔





1411












1412



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metaDebugFlag");




1,406,134✔





1413



  metaDebugFlag = pItem->i32;




1,406,134✔





1414












1415



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "stDebugFlag");




1,406,134✔





1416



  stDebugFlag = pItem->i32;




1,406,134✔





1417












1418



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sndDebugFlag");




1,406,134✔





1419



  sndDebugFlag = pItem->i32;




1,406,134✔





1420












1421



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "bseDebugFlag");




1,406,134✔





1422



  bseDebugFlag = pItem->i32;




1,406,134✔





1423



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "bndDebugFlag");




1,406,134✔





1424



  bndDebugFlag = pItem->i32;




1,406,134✔





1425












1426



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "xndDebugFlag");




1,406,134✔





1427



  xndDebugFlag = pItem->i32;




1,406,134✔





1428












1429



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,406,134✔





1430



}










1431












1432



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




1,933,620✔





1433



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




1,933,620✔






UNCOV

1434



    *pScope = SLOW_LOG_TYPE_QUERY;




×








UNCOV

1435



    TAOS_RETURN(TSDB_CODE_SUCCESS);




×







1436



  }










1437












1438



  int32_t slowScope = 0;




1,933,620✔





1439












1440



  char *scope = NULL;




1,933,620✔





1441



  char *tmp = NULL;




1,933,620✔





1442



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




3,867,240✔





1443



    taosMemoryFreeClear(tmp);




1,933,620✔





1444



    tmp = taosStrdup(scope);




1,933,620✔





1445



    if (tmp == NULL) {




1,933,620✔






UNCOV

1446



      TAOS_RETURN(terrno);




×







1447



    }










1448



    (void)strtrim(tmp);




1,933,620✔





1449



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




1,933,620✔






UNCOV

1450



      slowScope |= SLOW_LOG_TYPE_ALL;




×








UNCOV

1451



      continue;




×







1452



    }










1453












1454



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




1,933,620✔





1455



      slowScope |= SLOW_LOG_TYPE_QUERY;




1,910,251✔





1456



      continue;




1,910,251✔





1457



    }










1458












1459



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




23,369✔





1460



      slowScope |= SLOW_LOG_TYPE_INSERT;




2,371✔





1461



      continue;




2,371✔





1462



    }










1463












1464



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




20,998✔





1465



      slowScope |= SLOW_LOG_TYPE_OTHERS;




3,608✔





1466



      continue;




3,608✔





1467



    }










1468












1469



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




17,390✔





1470



      slowScope |= SLOW_LOG_TYPE_NULL;




17,390✔





1471



      continue;




17,390✔





1472



    }










1473













UNCOV

1474



    taosMemoryFreeClear(tmp);




×








UNCOV

1475



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




×








UNCOV

1476



    TAOS_RETURN(TSDB_CODE_INVALID_CFG_VALUE);




×







1477



  }










1478












1479



  *pScope = slowScope;




1,933,620✔





1480



  taosMemoryFreeClear(tmp);




1,933,620✔





1481



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,933,620✔





1482



}










1483












1484



// for common configs










1485



static int32_t taosSetClientCfg(SConfig *pCfg) {




3,529,670✔





1486



  SConfigItem *pItem = NULL;




3,529,670✔





1487












1488



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "fqdn");




3,529,670✔





1489



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




3,528,092✔





1490



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




3,528,092✔





1491












1492



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "serverPort");




3,528,092✔





1493



  tsServerPort = (uint16_t)pItem->i32;




3,528,092✔





1494



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




3,528,092✔





1495












1496



  char defaultFirstEp[TSDB_EP_LEN] = {0};




3,528,092✔





1497



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




3,528,092✔





1498












1499



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mqttPort");




3,528,092✔





1500



  tsMqttPort = (uint16_t)pItem->i32;




3,528,092✔





1501



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableIpv6");




3,528,092✔





1502



  tsEnableIpv6 = pItem->bval;




3,528,092✔





1503












1504



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "firstEp");




3,528,092✔





1505



  SEp firstEp = {0};




3,528,092✔





1506



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




3,528,092✔





1507



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




3,528,092✔





1508



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




3,528,092✔





1509












1510



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "secondEp");




3,528,092✔





1511



  SEp secondEp = {0};




3,528,092✔





1512



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




3,528,092✔





1513



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




3,528,092✔





1514



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




3,528,092✔





1515












1516



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tempDir");




3,528,092✔





1517



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




3,528,092✔





1518



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




3,528,092✔





1519



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




3,528,092✔





1520












1521



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minimalTmpDirGB");




3,528,092✔





1522



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




3,528,092✔





1523



  if (taosMulMkDir(tsTempDir) != 0) {




3,528,092✔






UNCOV

1524



    int32_t code = TAOS_SYSTEM_ERROR(ERRNO);




×








UNCOV

1525



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




×








UNCOV

1526



    TAOS_RETURN(code);




×







1527



  }










1528












1529



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlAutoChildTableNameDelimiter");




3,528,092✔





1530



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




3,528,092✔





1531



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




3,528,092✔





1532












1533



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlChildTableName");




3,528,092✔





1534



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




3,528,092✔





1535



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




3,528,092✔





1536












1537



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlTagName");




3,528,092✔





1538



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




3,528,092✔





1539



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




3,528,092✔





1540












1541



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlTsDefaultName");




3,528,092✔





1542



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




3,528,092✔





1543



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




3,528,092✔





1544












1545



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlDot2Underline");




3,528,092✔





1546



  tsSmlDot2Underline = pItem->bval;




3,528,092✔





1547












1548



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxInsertBatchRows");




3,528,092✔





1549



  tsMaxInsertBatchRows = pItem->i32;




3,528,092✔





1550












1551



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "shellActivityTimer");




3,528,092✔





1552



  tsShellActivityTimer = pItem->i32;




3,528,092✔





1553












1554



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "compressMsgSize");




3,528,092✔





1555



  tsCompressMsgSize = pItem->i32;




3,528,092✔





1556












1557



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfTaskQueueThreads");




3,528,092✔





1558



  tsNumOfTaskQueueThreads = pItem->i32;




3,528,092✔





1559












1560



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryPolicy");




3,528,092✔





1561



  tsQueryPolicy = pItem->i32;




3,528,092✔





1562












1563



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryTableNotExistAsEmpty");




3,528,092✔





1564



  tsQueryTbNotExistAsEmpty = pItem->bval;




3,528,092✔





1565












1566



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableQueryHb");




3,528,092✔





1567



  tsEnableQueryHb = pItem->bval;




3,528,092✔





1568












1569



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableScience");




3,528,092✔





1570



  tsEnableScience = pItem->bval;




3,528,092✔





1571












1572



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "querySmaOptimize");




3,528,092✔





1573



  tsQuerySmaOptimize = pItem->i32;




3,528,092✔





1574












1575



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tmqWriteRefDB");




3,528,092✔





1576



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




3,528,092✔





1577



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




3,528,092✔





1578












1579



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tmqWriteCheckRef");




3,528,092✔





1580



  tmqWriteCheckRef = pItem->bval;




3,528,092✔





1581












1582



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sqlSecurity");




3,528,092✔





1583



  tsSqlSecurityEnabled = pItem->bval;




3,528,092✔





1584



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sqlSecurityWhitelistMode");




3,528,092✔





1585



  tsSqlSecurityWhitelistMode = pItem->i32;




3,528,092✔





1586



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sqlSecurityStringCheck");




3,528,092✔





1587



  tsSqlSecurityStringCheck = pItem->bval;




3,528,092✔





1588



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sqlSecurityASTCheck");




3,528,092✔





1589



  tsSqlSecurityASTCheck = pItem->bval;




3,528,092✔





1590



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sqlSecurityRuleFile");




3,528,092✔





1591



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




3,528,092✔





1592



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




3,528,092✔





1593



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "whitelistLearning");




3,528,092✔





1594



  tsWhitelistLearning = pItem->bval;




3,528,092✔





1595



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "whitelistLearningPeriod");




3,528,092✔





1596



  tsWhitelistLearningPeriod = pItem->i32;




3,528,092✔





1597



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "whitelistLearningThreshold");




3,528,092✔





1598



  tsWhitelistLearningThreshold = pItem->i32;




3,528,092✔





1599












1600



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryPlannerTrace");




3,528,092✔





1601



  tsQueryPlannerTrace = pItem->bval;




3,528,092✔





1602












1603



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryNodeChunkSize");




3,528,092✔





1604



  tsQueryNodeChunkSize = pItem->i32;




3,528,092✔





1605












1606



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryUseNodeAllocator");




3,528,092✔





1607



  tsQueryUseNodeAllocator = pItem->bval;




3,528,092✔





1608












1609



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "keepColumnName");




3,528,092✔





1610



  tsKeepColumnName = pItem->bval;




3,528,092✔





1611












1612



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "useAdapter");




3,528,092✔





1613



  tsUseAdapter = pItem->bval;




3,528,092✔





1614












1615



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "crashReporting");




3,528,092✔





1616



  tsEnableCrashReport = pItem->bval;




3,528,092✔





1617












1618



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryMaxConcurrentTables");




3,528,092✔





1619



  tsQueryMaxConcurrentTables = pItem->i64;




3,528,092✔





1620












1621



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metaCacheMaxSize");




3,528,092✔





1622



  tsMetaCacheMaxSize = pItem->i32;




3,528,092✔





1623












1624



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "randErrorChance");




3,528,092✔





1625



  tsRandErrChance = pItem->i32;




3,528,092✔





1626












1627



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "randErrorDivisor");




3,528,092✔





1628



  tsRandErrDivisor = pItem->i64;




3,528,092✔





1629












1630



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "randErrorScope");




3,528,092✔





1631



  tsRandErrScope = pItem->i64;




3,528,092✔





1632












1633



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "countAlwaysReturnValue");




3,528,092✔





1634



  tsCountAlwaysReturnValue = pItem->i32;




3,528,092✔





1635












1636



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxRetryWaitTime");




3,528,092✔





1637



  tsMaxRetryWaitTime = pItem->i32;




3,528,092✔





1638












1639



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcThreads");




3,528,092✔





1640



  tsNumOfRpcThreads = pItem->i32;




3,528,092✔





1641












1642



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcSessions");




3,528,092✔





1643



  tsNumOfRpcSessions = pItem->i32;




3,528,092✔





1644












1645



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "shareConnLimit");




3,528,092✔





1646



  tsShareConnLimit = pItem->i32;




3,528,092✔





1647












1648



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "readTimeout");




3,528,092✔





1649



  tsReadTimeout = pItem->i32;




3,528,092✔





1650












1651



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timeToGetAvailableConn");




3,528,092✔





1652



  tsTimeToGetAvailableConn = pItem->i32;




3,528,092✔





1653












1654



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "experimental");




3,528,092✔





1655



  tsExperimental = pItem->bval;




3,528,092✔





1656












1657



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "multiResultFunctionStarReturnTags");




3,528,092✔





1658



  tsMultiResultFunctionStarReturnTags = pItem->bval;




3,528,092✔





1659












1660



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxTsmaCalcDelay");




3,528,092✔





1661



  tsMaxTsmaCalcDelay = pItem->i32;




3,528,092✔





1662












1663



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tsmaDataDeleteMark");




3,528,092✔





1664



  tsmaDataDeleteMark = pItem->i32;




3,528,092✔





1665












1666



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "safetyCheckLevel");




3,528,092✔





1667



  tsSafetyCheckLevel = pItem->i32;




3,528,092✔





1668












1669



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "bypassFlag");




3,528,092✔





1670



  tsBypassFlag = pItem->i32;




3,528,092✔





1671












1672



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "compareAsStrInGreatest");




3,528,092✔





1673



  tsCompareAsStrInGreatest = pItem->bval;




3,528,092✔





1674












1675



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "showFullCreateTableColumn");




3,528,092✔





1676



  tsShowFullCreateTableColumn = pItem->bval;




3,528,092✔





1677












1678



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCliKeyPath");




3,528,092✔





1679



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




3,528,092✔





1680



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




3,528,092✔





1681












1682



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCliCertPath");




3,528,092✔





1683



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




3,528,092✔





1684



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




3,528,092✔





1685












1686



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCaPath");




3,528,092✔





1687



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




3,528,092✔





1688



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




3,528,092✔





1689












1690



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableTLS");




3,528,092✔





1691



  tsEnableTLS = pItem->bval;




3,528,092✔





1692












1693



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableSasl");




3,528,092✔





1694



  tsEnableSasl = pItem->bval;




3,528,092✔





1695



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxSQLLength");




3,528,092✔





1696



  tsMaxSQLLength = pItem->i32;




3,528,092✔





1697












1698



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sessionControl");




3,528,092✔





1699



  tsSessionControl = pItem->bval;




3,528,092✔





1700












1701



  TAOS_RETURN(TSDB_CODE_SUCCESS);




3,528,092✔





1702



}










1703












1704



static int32_t taosSetSystemCfg(SConfig *pCfg) {




3,528,092✔





1705



  SConfigItem *pItem = NULL;




3,528,092✔





1706












1707



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableCoreFile");




3,528,092✔





1708



  tsEnableCoreFile = pItem->bval;




3,528,092✔





1709



  taosSetCoreDump(tsEnableCoreFile);




3,528,092✔





1710












1711



  // todo










1712



  tsVersion = 30000000;




3,528,092✔





1713












1714



  TAOS_RETURN(TSDB_CODE_SUCCESS);




3,528,092✔





1715



}










1716












1717



// for server configs










1718



static int32_t taosSetServerCfg(SConfig *pCfg) {




1,933,620✔





1719



  SConfigItem *pItem = NULL;




1,933,620✔





1720












1721



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minimalDataDirGB");




1,933,620✔





1722



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




1,933,620✔





1723












1724



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "supportVnodes");




1,933,620✔





1725



  tsNumOfSupportVnodes = pItem->i32;




1,933,620✔





1726












1727



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxShellConns");




1,933,620✔





1728



  tsMaxShellConns = pItem->i32;




1,933,620✔





1729












1730



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "statusInterval");




1,933,620✔





1731



  tsStatusInterval = pItem->i32;




1,933,620✔





1732



  tsStatusIntervalMs = pItem->i32 * 1000;




1,933,620✔





1733












1734



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "statusIntervalMs");




1,933,620✔





1735



  tsStatusIntervalMs = pItem->i32;




1,933,620✔





1736












1737



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "statusSRTimeoutMs");




1,933,620✔





1738



  tsStatusSRTimeoutMs = pItem->i32;




1,933,620✔





1739












1740



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "statusTimeoutMs");




1,933,620✔





1741



  tsStatusTimeoutMs = pItem->i32;




1,933,620✔





1742












1743



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableMetrics");




1,933,620✔





1744



  tsEnableMetrics = pItem->bval;




1,933,620✔





1745












1746



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metricsLevel");




1,933,620✔





1747



  tsMetricsLevel = pItem->i32;




1,933,620✔





1748












1749



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metricsInterval");




1,933,620✔





1750



  tsMetricsInterval = pItem->i32;




1,933,620✔





1751












1752



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minSlidingTime");




1,933,620✔





1753



  tsMinSlidingTime = pItem->i32;




1,933,620✔





1754












1755



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minIntervalTime");




1,933,620✔





1756



  tsMinIntervalTime = pItem->i32;




1,933,620✔





1757












1758



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "encryptAlgorithm");




1,933,620✔





1759



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




1,933,620✔





1760



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




1,933,620✔





1761












1762



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "encryptExtDir");




1,933,620✔





1763



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




1,933,620✔





1764












1765



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "encryptScope");




1,933,620✔





1766



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




1,933,620✔





1767



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




1,933,620✔





1768












1769



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableStrongPassword");




1,933,620✔





1770



  tsEnableStrongPassword = pItem->i32;




1,933,620✔





1771












1772



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableAdvancedSecurity");




1,933,620✔





1773



  tsEnableAdvancedSecurity = pItem->i32;




1,933,620✔





1774












1775



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableGrantLegacySyntax");




1,933,620✔





1776



  tsEnableGrantLegacySyntax = pItem->i32;




1,933,620✔





1777












1778



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcThreads");




1,933,620✔





1779



  tsNumOfRpcThreads = pItem->i32;




1,933,620✔





1780












1781



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcSessions");




1,933,620✔





1782



  tsNumOfRpcSessions = pItem->i32;




1,933,620✔





1783












1784



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "shareConnLimit");




1,933,620✔





1785



  tsShareConnLimit = pItem->i32;




1,933,620✔





1786












1787



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "readTimeout");




1,933,620✔





1788



  tsReadTimeout = pItem->i32;




1,933,620✔





1789












1790



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timeToGetAvailableConn");




1,933,620✔





1791



  tsTimeToGetAvailableConn = pItem->i32;




1,933,620✔





1792












1793



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfCommitThreads");




1,933,620✔





1794



  tsNumOfCommitThreads = pItem->i32;




1,933,620✔





1795












1796



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfCompactThreads");




1,933,620✔





1797



  tsNumOfCompactThreads = pItem->i32;




1,933,620✔





1798












1799



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "secureEraseMode");




1,933,620✔





1800



  tsSecureEraseMode = pItem->i32;




1,933,620✔





1801












1802



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableIpv6");




1,933,620✔





1803



  tsEnableIpv6 = pItem->bval;




1,933,620✔





1804












1805



#ifdef TD_ENTERPRISE










1806



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "authServer");




1,933,620✔





1807



  tsAuthServer = pItem->bval;




1,933,620✔





1808












1809



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "authReq");




1,933,620✔





1810



  tsAuthReq = pItem->bval;




1,933,620✔





1811












1812



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "authReqInterval");




1,933,620✔





1813



  tsAuthReqInterval = pItem->i32;




1,933,620✔





1814












1815



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "authReqUrl");




1,933,620✔





1816



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




1,933,620✔





1817



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




1,933,620✔





1818



#endif










1819












1820



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "retentionSpeedLimitMB");




1,933,620✔





1821



  tsRetentionSpeedLimitMB = pItem->i32;




1,933,620✔





1822












1823



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfMnodeReadThreads");




1,933,620✔





1824



  tsNumOfMnodeReadThreads = pItem->i32;




1,933,620✔





1825












1826



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfVnodeQueryThreads");




1,933,620✔





1827



  tsNumOfVnodeQueryThreads = pItem->i32;




1,933,620✔





1828












1829



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfVnodeFetchThreads");




1,933,620✔





1830



  tsNumOfVnodeFetchThreads = pItem->i32;




1,933,620✔





1831












1832



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfVnodeRsmaThreads");




1,933,620✔





1833



  tsNumOfVnodeRsmaThreads = pItem->i32;




1,933,620✔





1834












1835



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfQnodeQueryThreads");




1,933,620✔





1836



  tsNumOfQnodeQueryThreads = pItem->i32;




1,933,620✔





1837












1838



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "rpcQueueMemoryAllowed");




1,933,620✔





1839



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




1,933,620✔





1840



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




1,933,620✔





1841












1842



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "simdEnable");




1,933,620✔





1843



  tsSIMDEnable = (bool)pItem->bval;




1,933,620✔





1844












1845



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "AVX512Enable");




1,933,620✔





1846



  tsAVX512Enable = (bool)pItem->bval;




1,933,620✔





1847












1848



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tagFilterCache");




1,933,620✔





1849



  tsTagFilterCache = (bool)pItem->bval;




1,933,620✔





1850












1851



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "stableTagFilterCache");




1,933,620✔





1852



  tsStableTagFilterCache = pItem->bval;




1,933,620✔





1853



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metaEntryCache");




1,933,620✔





1854



  tsMetaEntryCache = (bool)pItem->bval;




1,933,620✔





1855



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metaEntryCacheSize");




1,933,620✔





1856



  tsMetaEntryCacheSize = pItem->i64;




1,933,620✔





1857












1858



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogExceptDb");




1,933,620✔





1859



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




1,933,620✔





1860



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




1,933,620✔





1861












1862



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogThreshold");




1,933,620✔





1863



  tsSlowLogThreshold = pItem->i32;




1,933,620✔





1864












1865



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogMaxLen");




1,933,620✔





1866



  tsSlowLogMaxLen = pItem->i32;




1,933,620✔





1867












1868



  int32_t scope = 0;




1,933,620✔





1869



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogScope");




1,933,620✔





1870



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




1,933,620✔





1871



  tsSlowLogScope = scope;




1,933,620✔





1872












1873



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryRspPolicy");




1,933,620✔





1874



  tsQueryRspPolicy = pItem->i32;




1,933,620✔





1875



#ifdef USE_MONITOR










1876



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitor");




1,933,620✔





1877



  tsEnableMonitor = pItem->bval;




1,933,620✔





1878












1879



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorInterval");




1,933,620✔





1880



  tsMonitorInterval = pItem->i32;




1,933,620✔





1881












1882



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorFqdn");




1,933,620✔





1883



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




1,933,620✔





1884



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




1,933,620✔





1885












1886



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorPort");




1,933,620✔





1887



  tsMonitorPort = (uint16_t)pItem->i32;




1,933,620✔





1888












1889



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorMaxLogs");




1,933,620✔





1890



  tsMonitorMaxLogs = pItem->i32;




1,933,620✔





1891












1892



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorComp");




1,933,620✔





1893



  tsMonitorComp = pItem->bval;




1,933,620✔





1894












1895



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorLogProtocol");




1,933,620✔





1896



  tsMonitorLogProtocol = pItem->bval;




1,933,620✔





1897












1898



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorForceV2");




1,933,620✔





1899



  tsMonitorForceV2 = pItem->i32;




1,933,620✔





1900



#endif










1901



#ifdef USE_AUDIT










1902



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "audit");




1,933,620✔





1903



  tsEnableAudit = pItem->bval;




1,933,620✔





1904












1905



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditCreateTable");




1,933,620✔





1906



  tsEnableAuditCreateTable = pItem->bval;




1,933,620✔





1907












1908



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableAuditDelete");




1,933,620✔





1909



  tsEnableAuditDelete = pItem->bval;




1,933,620✔





1910












1911



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableAuditSelect");




1,933,620✔





1912



  tsEnableAuditSelect = pItem->bval;




1,933,620✔





1913












1914



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableAuditInsert");




1,933,620✔





1915



  tsEnableAuditInsert = pItem->bval;




1,933,620✔





1916












1917



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditLevel");




1,933,620✔





1918



  tsAuditLevel = pItem->i32;




1,933,620✔





1919












1920



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditHttps");




1,933,620✔





1921



  tsAuditHttps = pItem->bval;




1,933,620✔





1922












1923



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditUseToken");




1,933,620✔





1924



  tsAuditUseToken = pItem->bval;




1,933,620✔





1925












1926



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditSaveInSelf");




1,933,620✔





1927



  tsAuditSaveInSelf = pItem->bval;




1,933,620✔





1928












1929



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditInterval");




1,933,620✔





1930



  tsAuditInterval = pItem->i32;




1,933,620✔





1931



#endif










1932



#ifdef USE_REPORT










1933



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryReporting");




1,933,620✔





1934



  tsEnableTelem = pItem->bval;




1,933,620✔





1935












1936



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "crashReporting");




1,933,620✔





1937



  tsEnableCrashReport = pItem->bval;




1,933,620✔





1938












1939



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryInterval");




1,933,620✔





1940



  tsTelemInterval = pItem->i32;




1,933,620✔





1941












1942



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryServer");




1,933,620✔





1943



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




1,933,620✔





1944



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




1,933,620✔





1945



#endif










1946












1947



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlChangeOnWrite");




1,933,620✔





1948



  tsTtlChangeOnWrite = pItem->bval;




1,933,620✔





1949












1950



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlFlushThreshold");




1,933,620✔





1951



  tsTtlFlushThreshold = pItem->i32;




1,933,620✔





1952












1953



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "rsyncPort");




1,933,620✔





1954



  tsRsyncPort = pItem->i32;




1,933,620✔





1955












1956



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "snodeAddress");




1,933,620✔





1957



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




1,933,620✔





1958



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




1,933,620✔





1959












1960



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "checkpointBackupDir");




1,933,620✔





1961



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




1,933,620✔





1962



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




1,933,620✔





1963












1964



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryPort");




1,933,620✔





1965



  tsTelemPort = (uint16_t)pItem->i32;




1,933,620✔





1966












1967



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tmqMaxTopicNum");




1,933,620✔





1968



  tmqMaxTopicNum = pItem->i32;




1,933,620✔





1969












1970



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxTsmaNum");




1,933,620✔





1971



  tsMaxTsmaNum = pItem->i32;




1,933,620✔





1972












1973



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "diskIDCheckEnabled");




1,933,620✔





1974



  tsDiskIDCheckEnabled = pItem->bval;




1,933,620✔





1975












1976



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "transPullupInterval");




1,933,620✔





1977



  tsTransPullupInterval = pItem->i32;




1,933,620✔





1978












1979



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "compactPullupInterval");




1,933,620✔





1980



  tsCompactPullupInterval = pItem->i32;




1,933,620✔





1981












1982



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mqRebalanceInterval");




1,933,620✔





1983



  tsMqRebalanceInterval = pItem->i32;




1,933,620✔





1984












1985



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlUnit");




1,933,620✔





1986



  tsTtlUnit = pItem->i32;




1,933,620✔





1987












1988



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlPushInterval");




1,933,620✔





1989



  tsTtlPushIntervalSec = pItem->i32;




1,933,620✔





1990












1991



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlBatchDropNum");




1,933,620✔





1992



  tsTtlBatchDropNum = pItem->i32;




1,933,620✔





1993












1994



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "trimVDbIntervalSec");




1,933,620✔





1995



  tsTrimVDbIntervalSec = pItem->i32;




1,933,620✔





1996












1997



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryTrimIntervalSec");




1,933,620✔





1998



  tsQueryTrimIntervalSec = pItem->i32;




1,933,620✔





1999












2000



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "querySsMigrateIntervalSec");




1,933,620✔





2001



  tsQuerySsMigrateIntervalSec = pItem->i32;




1,933,620✔





2002












2003



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "uptimeInterval");




1,933,620✔





2004



  tsUptimeInterval = pItem->i32;




1,933,620✔





2005












2006



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryRsmaTolerance");




1,933,620✔





2007



  tsQueryRsmaTolerance = pItem->i32;




1,933,620✔





2008












2009



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timeseriesThreshold");




1,933,620✔





2010



  tsTimeSeriesThreshold = pItem->i32;




1,933,620✔





2011












2012



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "walForceRepair");




1,933,620✔





2013



  tsWalForceRepair = pItem->bval;




1,933,620✔





2014












2015



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "walFsyncDataSizeLimit");




1,933,620✔





2016



  tsWalFsyncDataSizeLimit = pItem->i64;




1,933,620✔





2017












2018



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncElectInterval");




1,933,620✔





2019



  tsElectInterval = pItem->i32;




1,933,620✔





2020












2021



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncHeartbeatInterval");




1,933,620✔





2022



  tsHeartbeatInterval = pItem->i32;




1,933,620✔





2023












2024



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncVnodeElectIntervalMs");




1,933,620✔





2025



  tsVnodeElectIntervalMs = pItem->i32;




1,933,620✔





2026












2027



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncVnodeHeartbeatIntervalMs");




1,933,620✔





2028



  tsVnodeHeartbeatIntervalMs = pItem->i32;




1,933,620✔





2029












2030



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncMnodeElectIntervalMs");




1,933,620✔





2031



  tsMnodeElectIntervalMs = pItem->i32;




1,933,620✔





2032












2033



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncMnodeHeartbeatIntervalMs");




1,933,620✔





2034



  tsMnodeHeartbeatIntervalMs = pItem->i32;




1,933,620✔





2035












2036



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncHeartbeatTimeout");




1,933,620✔





2037



  tsHeartbeatTimeout = pItem->i32;




1,933,620✔





2038












2039



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncSnapReplMaxWaitN");




1,933,620✔





2040



  tsSnapReplMaxWaitN = pItem->i32;




1,933,620✔





2041












2042



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncLogBufferMemoryAllowed");




1,933,620✔





2043



  tsLogBufferMemoryAllowed = pItem->i64;




1,933,620✔





2044












2045



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncApplyQueueSize");




1,933,620✔





2046



  tsSyncApplyQueueSize = pItem->i64;




1,933,620✔





2047












2048



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncRoutineReportInterval");




1,933,620✔





2049



  tsRoutineReportInterval = pItem->i32;




1,933,620✔





2050












2051



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncLogHeartbeat");




1,933,620✔





2052



  tsSyncLogHeartbeat = pItem->bval;




1,933,620✔





2053












2054



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbHeartBeatIntervalSec");




1,933,620✔





2055



  tsArbHeartBeatIntervalMs = pItem->i32 * 1000;




1,933,620✔





2056












2057



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbCheckSyncIntervalSec");




1,933,620✔





2058



  tsArbCheckSyncIntervalMs = pItem->i32 * 1000;




1,933,620✔





2059












2060



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbSetAssignedTimeoutSec");




1,933,620✔





2061



  tsArbSetAssignedTimeoutMs = pItem->i32 * 1000;




1,933,620✔





2062












2063



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbHeartBeatIntervalMs");




1,933,620✔





2064



  tsArbHeartBeatIntervalMs = pItem->i32;




1,933,620✔





2065












2066



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbCheckSyncIntervalMs");




1,933,620✔





2067



  tsArbCheckSyncIntervalMs = pItem->i32;




1,933,620✔





2068












2069



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbSetAssignedTimeoutMs");




1,933,620✔





2070



  tsArbSetAssignedTimeoutMs = pItem->i32;




1,933,620✔





2071












2072



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncTimeout");




1,933,620✔





2073



  tsSyncTimeout = pItem->i32;




1,933,620✔





2074












2075



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncAssignedCheckAppliedGap");




1,933,620✔





2076



  tsSyncAssignedCheckAppliedGap = pItem->i64;




1,933,620✔





2077












2078



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mndSdbWriteDelta");




1,933,620✔





2079



  tsMndSdbWriteDelta = pItem->i64;




1,933,620✔





2080












2081



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mndLogRetention");




1,933,620✔





2082



  tsMndLogRetention = pItem->i64;




1,933,620✔





2083












2084



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "skipGrant");




1,933,620✔





2085



  tsMndSkipGrant = pItem->bval;




1,933,620✔





2086












2087



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableWhiteList");




1,933,620✔





2088



  tsEnableWhiteList = pItem->bval;




1,933,620✔





2089












2090



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "forceKillTrans");




1,933,620✔





2091



  tsForceKillTrans = pItem->bval;




1,933,620✔





2092



#ifdef USE_UDF










2093



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udf");




1,933,620✔





2094



  tsStartUdfd = pItem->bval;




1,933,620✔





2095












2096



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udfdResFuncs");




1,933,620✔





2097



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




1,933,620✔





2098



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




1,933,620✔





2099












2100



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udfdLdLibPath");




1,933,620✔





2101



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




1,933,620✔





2102



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




1,933,620✔





2103



#endif










2104



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "fPrecision");




1,933,620✔





2105



  tsFPrecision = pItem->fval;




1,933,620✔





2106












2107



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "dPrecision");




1,933,620✔





2108



  tsDPrecision = pItem->fval;




1,933,620✔





2109












2110



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxRange");




1,933,620✔





2111



  tsMaxRange = pItem->i32;




1,933,620✔





2112












2113



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "curRange");




1,933,620✔





2114



  tsCurRange = pItem->i32;




1,933,620✔





2115












2116



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ifAdtFse");




1,933,620✔





2117



  tsIfAdtFse = pItem->bval;




1,933,620✔





2118












2119



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "compressor");




1,933,620✔





2120



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




1,933,620✔





2121



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




1,933,620✔





2122












2123



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "disableStream");




1,933,620✔





2124



  tsDisableStream = pItem->bval;




1,933,620✔





2125












2126



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamBufferSize");




1,933,620✔





2127



  tsStreamBufferSize = pItem->i32;




1,933,620✔





2128



  tsStreamBufferSizeBytes = tsStreamBufferSize * 1048576L;




1,933,620✔





2129












2130



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfMnodeStreamMgmtThreads");




1,933,620✔





2131



  tsNumOfMnodeStreamMgmtThreads = pItem->i32;




1,933,620✔





2132












2133



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfStreamMgmtThreads");




1,933,620✔





2134



  tsNumOfStreamMgmtThreads = pItem->i32;




1,933,620✔





2135












2136



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfVnodeStreamReaderThreads");




1,933,620✔





2137



  tsNumOfVnodeStreamReaderThreads = pItem->i32;




1,933,620✔





2138












2139



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfStreamTriggerThreads");




1,933,620✔





2140



  tsNumOfStreamTriggerThreads = pItem->i32;




1,933,620✔





2141












2142



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfStreamRunnerThreads");




1,933,620✔





2143



  tsNumOfStreamRunnerThreads = pItem->i32;




1,933,620✔





2144












2145



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "filterScalarMode");




1,933,620✔





2146



  tsFilterScalarMode = pItem->bval;




1,933,620✔





2147












2148



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "pqSortMemThreshold");




1,933,620✔





2149



  tsPQSortMemThreshold = pItem->i32;




1,933,620✔





2150












2151



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minDiskFreeSize");




1,933,620✔





2152



  tsMinDiskFreeSize = pItem->i64;




1,933,620✔





2153












2154



#ifdef USE_SHARED_STORAGE










2155



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ssEnabled");




1,933,620✔





2156



  tsSsEnabled = pItem->i32;




1,933,620✔





2157












2158



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ssAccessString");




1,933,620✔





2159



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




1,933,620✔





2160



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




1,933,620✔





2161












2162



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ssAutoMigrateIntervalSec");




1,933,620✔





2163



  tsSsAutoMigrateIntervalSec = pItem->i32;




1,933,620✔





2164












2165



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ssPageCacheSize");




1,933,620✔





2166



  tsSsPageCacheSize = pItem->i32;




1,933,620✔





2167












2168



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ssUploadDelaySec");




1,933,620✔





2169



  tsSsUploadDelaySec = pItem->i32;




1,933,620✔





2170



#endif










2171












2172



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "experimental");




1,933,620✔





2173



  tsExperimental = pItem->bval;




1,933,620✔





2174












2175



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryUseMemoryPool");




1,933,620✔





2176



  tsQueryUseMemoryPool = pItem->bval;




1,933,620✔





2177












2178



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "memPoolFullFunc");




1,933,620✔





2179



  tsMemPoolFullFunc = pItem->bval;




1,933,620✔





2180












2181



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "singleQueryMaxMemorySize");




1,933,620✔





2182



  tsSingleQueryMaxMemorySize = pItem->i32;




1,933,620✔





2183












2184



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










2185



  // tsQueryBufferPoolSize = pItem->i32;










2186












2187



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minReservedMemorySize");




1,933,620✔





2188



  tsMinReservedMemorySize = pItem->i32;




1,933,620✔





2189












2190



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamNotifyMessageSize");




1,933,620✔





2191



  tsStreamNotifyMessageSize = pItem->i32;




1,933,620✔





2192












2193



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamNotifyFrameSize");




1,933,620✔





2194



  tsStreamNotifyFrameSize = pItem->i32;




1,933,620✔





2195












2196



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamBatchRequestWaitMs");




1,933,620✔





2197



  tsStreamBatchRequestWaitMs = pItem->i32;




1,933,620✔





2198












2199



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCliKeyPath");




1,933,620✔





2200



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




1,933,620✔





2201



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




1,933,620✔





2202












2203



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCliCertPath");




1,933,620✔





2204



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




1,933,620✔





2205



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




1,933,620✔





2206












2207



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsCaPath");




1,933,620✔





2208



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




1,933,620✔





2209



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




1,933,620✔





2210












2211



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsSvrKeyPath");




1,933,620✔





2212



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




1,933,620✔





2213



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




1,933,620✔





2214












2215



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tlsSvrCertPath");




1,933,620✔





2216



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




1,933,620✔





2217



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




1,933,620✔





2218












2219



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableTLS");




1,933,620✔





2220



  tsEnableTLS = pItem->bval;




1,933,620✔





2221












2222



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableSasl");




1,933,620✔





2223



  tsEnableSasl = pItem->bval;




1,933,620✔





2224



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "rpcRecvLogThreshold");




1,933,620✔





2225



  tsRpcRecvLogThreshold = pItem->i32;




1,933,620✔





2226












2227



  // GRANT_CFG_GET;










2228












2229



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "walDeleteOnCorruption");




1,933,620✔





2230



  tsWalDeleteOnCorruption = pItem->bval;




1,933,620✔





2231












2232



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,933,620✔





2233



}










2234












2235



#ifndef TD_ENTERPRISE










2236



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










2237



#else










2238



int32_t taosSetReleaseCfg(SConfig *pCfg);










2239



#endif










2240












2241



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










2242












2243



static int8_t tsLogCreated = 0;










2244












2245



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




3,000,566✔





2246



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










2247



  int32_t  code = TSDB_CODE_SUCCESS;




3,000,566✔





2248



  int32_t  lino = 0;




3,000,566✔





2249



  int32_t  mode = tsc ? LOG_MODE_TAOSC : LOG_MODE_TAOSD;




3,000,566✔





2250



  SConfig *pCfg = NULL;




3,000,566✔





2251












2252



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




3,000,566✔





2253












2254



  if (tsCfg == NULL) {




2,997,001✔





2255



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




2,997,001✔





2256



  }










2257












2258



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




2,997,001✔





2259












2260



#ifdef TAOSD_INTEGRATED










2261



  mode |= LOG_MODE_TAOSD;










2262



  tsLogEmbedded = 1;










2263



#else










2264



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




2,997,001✔





2265



#endif










2266



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




2,997,001✔





2267



  if (mode & LOG_MODE_TAOSD) {




2,997,001✔





2268



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




1,406,166✔





2269



  }










2270












2271



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




2,997,001✔





2272



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




32✔





2273



    goto _exit;




32✔





2274



  }










2275












2276



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




2,996,969✔





2277



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




×







2278



    goto _exit;




×







2279



  }










2280












2281



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




2,996,969✔





2282



  if (mode & LOG_MODE_TAOSD) {




2,996,969✔





2283



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




1,406,134✔





2284



  }










2285












2286



  SConfigItem *pDebugItem = NULL;




2,996,969✔





2287



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pDebugItem, "debugFlag");




2,996,969✔





2288



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




2,996,969✔





2289












2290



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




2,996,969✔





2291



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




55✔





2292



    goto _exit;




55✔





2293



  }










2294












2295



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




2,996,914✔






UNCOV

2296



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




×







2297



    goto _exit;




×







2298



  }










2299












2300



_exit:




2,996,969✔





2301



  if (TSDB_CODE_SUCCESS != code) {




2,997,001✔





2302



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




87✔





2303



  }










2304












2305



  cfgCleanup(pCfg);




2,997,001✔





2306



  TAOS_RETURN(code);




2,997,001✔





2307



}










2308













UNCOV

2309



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




×







2310



                           SArray *pArgs) {











UNCOV

2311



  int32_t code = TSDB_CODE_SUCCESS;




×







2312



  int32_t lino = -1;




×







2313



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




×







2314



  if (code != 0) {




×








UNCOV

2315



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




×







2316



  }










2317













UNCOV

2318



  SConfig *pCfg = NULL;




×








UNCOV

2319



  TAOS_CHECK_RETURN(cfgInit(&pCfg));




×








UNCOV

2320



  TAOS_CHECK_EXIT(




×







2321



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










2322



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




×







2323



                              CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));











UNCOV

2324



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




×







2325



                              CFG_CATEGORY_LOCAL, CFG_PRIV_DEBUG));











UNCOV

2326



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




×







2327



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




×







2328



    goto _exit;




×







2329



  }










2330













UNCOV

2331



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




×







2332



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




×







2333



    goto _exit;




×







2334



  }










2335













UNCOV

2336



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




×







2337













UNCOV

2338



  SConfigItem *pItem = NULL;




×








UNCOV

2339



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




×








UNCOV

2340



    code = TSDB_CODE_CFG_NOT_FOUND;




×








UNCOV

2341



    goto _exit;




×







2342



  }










2343













UNCOV

2344



  dDebugFlag = pItem->i32;




×







2345













UNCOV

2346



_exit:




×








UNCOV

2347



  cfgCleanup(pCfg);




×








UNCOV

2348



  TAOS_RETURN(code);




×







2349



}










2350












2351



static int32_t taosCheckGlobalCfg() {




3,000,606✔





2352



  SIpAddr addr = {0};




3,000,606✔





2353



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




3,000,606✔





2354



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




3,000,606✔





2355



  if (code) {




3,000,606✔






UNCOV

2356



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




×








UNCOV

2357



    TAOS_RETURN(TSDB_CODE_RPC_FQDN_ERROR);




×







2358



  }










2359












2360



  if (tsServerPort <= 0) {




3,000,606✔






UNCOV

2361



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




×








UNCOV

2362



    TAOS_RETURN(TSDB_CODE_RPC_FQDN_ERROR);




×







2363



  }










2364












2365



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




3,000,606✔






UNCOV

2366



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




×








UNCOV

2367



    TAOS_RETURN(TSDB_CODE_RPC_FQDN_ERROR);




×







2368



  }










2369












2370



  TAOS_RETURN(TSDB_CODE_SUCCESS);




3,000,606✔





2371



}










2372












2373



static int32_t cfgInitWrapper(SConfig **pCfg) {




2,997,041✔





2374



  if (*pCfg == NULL) {




2,997,041✔





2375



    TAOS_CHECK_RETURN(cfgInit(pCfg));




2,997,041✔





2376



  }










2377



  TAOS_RETURN(TSDB_CODE_SUCCESS);




2,997,041✔





2378



}










2379












2380



int32_t setAllConfigs(SConfig *pCfg) {




529,064✔





2381



  int32_t code = 0;




529,064✔





2382



  int32_t lino = -1;




529,064✔





2383



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




529,064✔





2384



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




527,486✔





2385



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




527,486✔





2386



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




527,486✔





2387



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




527,486✔





2388



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




527,486✔





2389



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




527,486✔





2390



_exit:




527,486✔





2391



  TAOS_RETURN(code);




529,064✔





2392



}










2393












2394



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




659,856✔





2395



  int32_t code = TSDB_CODE_SUCCESS;




659,856✔





2396












2397



  cJSON *pRoot = cJSON_Parse(buf);




659,856✔





2398



  if (pRoot == NULL) {




659,856✔





2399



    return TSDB_CODE_OUT_OF_MEMORY;




×







2400



  }










2401



  if (isGlobal) {




659,856✔





2402



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




329,928✔





2403



    if (pItem == NULL) {




329,928✔





2404



      code = TSDB_CODE_OUT_OF_MEMORY;




×







2405



      goto _exit;




×







2406



    }










2407



    tsdmConfigVersion = pItem->valueint;




329,928✔





2408



  }










2409












2410



  int32_t sz = taosArrayGetSize(array);




659,856✔





2411



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




659,856✔





2412



  if (configs == NULL) {




659,856✔






UNCOV

2413



    code = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2414



    goto _exit;




×







2415



  }










2416



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




91,060,128✔





2417



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




90,400,272✔





2418



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




90,400,272✔





2419



    if (pJson == NULL) {




90,400,272✔






UNCOV

2420



      continue;




×







2421



    }










2422



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




90,400,272✔





2423



      if (!tsDiskIDCheckEnabled) {




329,928✔





2424



        continue;




329,928✔





2425



      }











UNCOV

2426



      int    sz = cJSON_GetArraySize(pJson);




×








UNCOV

2427



      cJSON *filed = NULL;




×







2428



      // check disk id for each dir











UNCOV

2429



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




×








UNCOV

2430



        cJSON *diskCfgJson = cJSON_GetArrayItem(pJson, j);




×








UNCOV

2431



        if (diskCfgJson == NULL) {




×







2432



          code = TSDB_CODE_OUT_OF_MEMORY;




×







2433



          goto _exit;




×







2434



        }










2435













UNCOV

2436



        filed = cJSON_GetObjectItem(diskCfgJson, "dir");




×








UNCOV

2437



        if (filed == NULL) {




×








UNCOV

2438



          code = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2439



          goto _exit;




×







2440



        }










2441













UNCOV

2442



        char *dir = cJSON_GetStringValue(filed);




×








UNCOV

2443



        filed = cJSON_GetObjectItem(diskCfgJson, "disk_id");




×








UNCOV

2444



        if (filed == NULL) {




×








UNCOV

2445



          code = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2446



          goto _exit;




×







2447



        }










2448













UNCOV

2449



        int64_t actDiskID = 0;




×








UNCOV

2450



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




×








UNCOV

2451



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




×








UNCOV

2452



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




×








UNCOV

2453



          goto _exit;




×







2454



        }










2455



        if (actDiskID != expDiskID) {




×







2456



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




×







2457



                 expDiskID);











UNCOV

2458



          code = TSDB_CODE_INVALID_DISK_ID;




×








UNCOV

2459



          goto _exit;




×







2460



        }










2461



      }











UNCOV

2462



      continue;




×







2463



    }










2464



    switch (pItem->dtype) {




90,070,344✔





2465



      {











UNCOV

2466



        case CFG_DTYPE_NONE:




×








UNCOV

2467



          break;




×







2468



        case CFG_DTYPE_BOOL:




20,125,608✔





2469



          pItem->bval = cJSON_IsTrue(pJson);




20,125,608✔





2470



          break;




20,125,608✔





2471



        case CFG_DTYPE_INT32:




48,499,416✔





2472



          pItem->i32 = pJson->valueint;




48,499,416✔





2473



          break;




48,499,416✔





2474



        case CFG_DTYPE_INT64:




4,948,920✔





2475



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




4,948,920✔





2476



          break;




4,948,920✔





2477



        case CFG_DTYPE_FLOAT:




1,979,568✔





2478



        case CFG_DTYPE_DOUBLE:










2479



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




1,979,568✔





2480



          break;




1,979,568✔





2481



        case CFG_DTYPE_STRING:




14,516,832✔





2482



        case CFG_DTYPE_DIR:










2483



        case CFG_DTYPE_LOCALE:










2484



        case CFG_DTYPE_CHARSET:










2485



        case CFG_DTYPE_TIMEZONE:










2486



          taosMemoryFree(pItem->str);




14,516,832✔





2487



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




14,516,832✔





2488



          if (pItem->str == NULL) {




14,516,832✔






UNCOV

2489



            code = terrno;




×








UNCOV

2490



            goto _exit;




×







2491



          }










2492



          break;




14,516,832✔





2493



      }










2494



    }










2495



  }










2496



_exit:




659,856✔





2497



  if (code != TSDB_CODE_SUCCESS) {




659,856✔






UNCOV

2498



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




×







2499



  }










2500



  cJSON_Delete(pRoot);




659,856✔





2501



  return code;




659,856✔





2502



}










2503












2504



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




329,928✔





2505



  int32_t code = TSDB_CODE_SUCCESS;




329,928✔





2506



  cJSON  *pRoot = cJSON_Parse(buf);




329,928✔





2507



  if (pRoot == NULL) {




329,928✔






UNCOV

2508



    return TSDB_CODE_OUT_OF_MEMORY;




×







2509



  }










2510



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




329,928✔





2511



  if (stypes == NULL) {




329,928✔






UNCOV

2512



    code = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2513



    goto _exit;




×







2514



  }










2515



  int32_t sz = taosArrayGetSize(array);




329,928✔





2516



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




52,788,480✔





2517



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




52,458,552✔





2518



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




52,458,552✔





2519



    if (pJson == NULL) {




52,458,552✔






UNCOV

2520



      continue;




×







2521



    }










2522



    pItem->stype = pJson->valueint;




52,458,552✔





2523



  }










2524



  cJSON_Delete(pRoot);




329,928✔





2525



_exit:




329,928✔





2526



  return code;




329,928✔





2527



}










2528












2529



int32_t readStypeConfigFile(const char *path) {




1,406,134✔





2530



  int32_t   code = 0;




1,406,134✔





2531



  char      filename[CONFIG_FILE_LEN] = {0};




1,406,134✔





2532



  SArray   *array = NULL;




1,406,134✔





2533



  char     *buf = NULL;




1,406,134✔





2534



  int32_t   dataLen = 0;




1,406,134✔





2535












2536



  array = taosGetLocalCfg(tsCfg);




1,406,134✔





2537



  if (array == NULL) {




1,406,134✔






UNCOV

2538



    code = TSDB_CODE_OUT_OF_MEMORY;




×








UNCOV

2539



    goto _exit;




×







2540



  }










2541












2542



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




1,406,134✔





2543



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




1,406,134✔





2544



  if (!taosCheckExistFile(filename)) {




1,406,134✔





2545



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




1,076,206✔





2546



    goto _exit;




1,076,206✔





2547



  }










2548












2549



  // Use taosReadCfgFile for automatic decryption support










2550



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




329,928✔





2551



  if (code != TSDB_CODE_SUCCESS) {




329,928✔






UNCOV

2552



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




×








UNCOV

2553



    goto _exit;




×







2554



  }










2555












2556



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




329,928✔






UNCOV

2557



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




×








UNCOV

2558



    goto _exit;




×







2559



  }










2560












2561



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










2562



  code = stypeConfigDeserialize(array, buf);




329,928✔





2563



  if (code != TSDB_CODE_SUCCESS) {




329,928✔






UNCOV

2564



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




×








UNCOV

2565



    goto _exit;




×







2566



  }










2567












2568



_exit:




1,399,644✔





2569



  if (code != TSDB_CODE_SUCCESS) {




1,406,134✔






UNCOV

2570



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




×







2571



  }










2572



  taosMemoryFree(buf);




1,406,134✔





2573



  TAOS_RETURN(code);




1,406,134✔





2574



}










2575












2576



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




2,812,268✔





2577



  int32_t code = 0;




2,812,268✔





2578



  char    filename[CONFIG_FILE_LEN] = {0};




2,812,268✔





2579



  SArray *array = NULL;




2,812,268✔





2580



  char   *buf = NULL;




2,812,268✔





2581



  int32_t dataLen = 0;




2,812,268✔





2582












2583



  if (isGlobal) {




2,812,268✔





2584



    array = taosGetGlobalCfg(tsCfg);




1,406,134✔





2585



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




1,406,134✔





2586



  } else {










2587



    array = taosGetLocalCfg(tsCfg);




1,406,134✔





2588



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




1,406,134✔





2589



  }










2590



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




2,812,268✔





2591












2592



  if (!taosCheckExistFile(filename)) {




2,812,268✔





2593



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




2,152,412✔





2594



    TAOS_RETURN(TSDB_CODE_SUCCESS);




2,152,412✔





2595



  }










2596












2597



  // Use taosReadCfgFile for automatic decryption support










2598



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




659,856✔





2599



  if (code != TSDB_CODE_SUCCESS) {




659,856✔





2600



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




×







2601



    goto _exit;




×







2602



  }










2603












2604



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




659,856✔





2605



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




×







2606



    TAOS_RETURN(TSDB_CODE_SUCCESS);




×







2607



  }










2608












2609



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










2610



  code = cfgDeserialize(array, buf, isGlobal);




659,856✔





2611



  if (code != TSDB_CODE_SUCCESS) {




659,856✔






UNCOV

2612



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




×








UNCOV

2613



    goto _exit;




×







2614



  }










2615












2616



_exit:




659,856✔





2617



  if (code != TSDB_CODE_SUCCESS) {




659,856✔






UNCOV

2618



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




×







2619



  }










2620



  taosMemoryFree(buf);




659,856✔





2621



  TAOS_RETURN(code);




659,856✔





2622



}










2623












2624



int32_t tryLoadCfgFromDataDir(SConfig *pCfg) {




1,406,134✔





2625



  int32_t code = 0;




1,406,134✔





2626



  code = readCfgFile(tsDataDir, true);




1,406,134✔





2627



  if (code != TSDB_CODE_SUCCESS) {




1,406,134✔






UNCOV

2628



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




×








UNCOV

2629



    TAOS_RETURN(code);




×







2630



  }










2631



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




1,406,134✔





2632



    code = readCfgFile(tsDataDir, false);




1,406,134✔





2633



    if (code != TSDB_CODE_SUCCESS) {




1,406,134✔





2634



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




×







2635



      TAOS_RETURN(code);




×







2636



    }










2637



    code = readStypeConfigFile(tsDataDir);




1,406,134✔





2638



    if (code != TSDB_CODE_SUCCESS) {




1,406,134✔





2639



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




×







2640



      TAOS_RETURN(code);




×







2641



  }










2642



  TAOS_RETURN(code);




1,406,134✔





2643



}










2644



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




3,000,606✔





2645



                       bool tsc) {










2646



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




3,000,606✔





2647












2648



  int32_t code = TSDB_CODE_SUCCESS;




2,997,041✔





2649



  int32_t lino = -1;




2,997,041✔





2650












2651



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




2,997,041✔





2652












2653



  if (tsc) {




2,997,041✔





2654



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




1,590,907✔





2655



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




1,590,907✔





2656



  } else {










2657



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




1,406,134✔





2658



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




1,406,134✔





2659



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




1,406,134✔





2660



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




1,406,134✔





2661



  }










2662












2663



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




2,997,041✔





2664












2665



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




2,997,041✔






UNCOV

2666



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




×








UNCOV

2667



    cfgCleanup(tsCfg);




×








UNCOV

2668



    tsCfg = NULL;




×








UNCOV

2669



    TAOS_RETURN(code);




×







2670



  }










2671












2672



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




2,997,041✔






UNCOV

2673



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




×








UNCOV

2674



    cfgCleanup(tsCfg);




×








UNCOV

2675



    tsCfg = NULL;




×








UNCOV

2676



    TAOS_RETURN(code);




×







2677



  }










2678



  if (!tsc) {




2,997,041✔





2679



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




1,406,134✔





2680



  }










2681












2682



_exit:




2,997,041✔





2683



  if (code != TSDB_CODE_SUCCESS) {




2,997,041✔






UNCOV

2684



    cfgCleanup(tsCfg);




×








UNCOV

2685



    tsCfg = NULL;




×








UNCOV

2686



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




×







2687



  }










2688



  TAOS_RETURN(code);




2,997,041✔





2689



}










2690












2691



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




3,000,606✔





2692



                     bool tsc) {










2693



  int32_t code = TSDB_CODE_SUCCESS;




3,000,606✔





2694



  int32_t lino = -1;




3,000,606✔





2695



  if (!tsc) {




3,000,606✔





2696



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




1,406,134✔





2697



  }










2698












2699



  if (tsc) {




3,000,606✔





2700



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




1,594,472✔





2701



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




1,594,472✔





2702



  } else {










2703



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




1,406,134✔





2704



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




1,406,134✔





2705



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




1,406,134✔





2706



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




1,406,134✔





2707



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




1,406,134✔





2708



  }










2709












2710



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




3,000,606✔





2711



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




3,000,606✔





2712












2713



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




3,000,606✔





2714



  if (NULL == pItem) {




3,000,606✔






UNCOV

2715



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




×








UNCOV

2716



    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);




×







2717



  }










2718



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




3,000,606✔





2719












2720



  cfgDumpCfg(tsCfg, tsc, false);




3,000,606✔





2721



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




3,000,606✔





2722












2723



  code = initTimezoneInfo();




3,000,606✔





2724



  if (code != TSDB_CODE_SUCCESS) {




3,000,606✔






UNCOV

2725



    return code;




×







2726



  }










2727



_exit:




3,000,606✔





2728



  if (code != TSDB_CODE_SUCCESS) {




3,000,606✔






UNCOV

2729



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




×







2730



  }










2731



  TAOS_RETURN(code);




3,000,606✔





2732



}










2733












2734



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




1,601,354✔





2735



                    bool tsc) {










2736



  int32_t code = TSDB_CODE_SUCCESS;




1,601,354✔





2737



  int32_t lino = -1;




1,601,354✔





2738












2739



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




1,601,354✔





2740



  if (!tsc) {




1,601,354✔





2741



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




6,882✔





2742



  }










2743



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




1,601,354✔





2744



_exit:




1,601,354✔





2745



  if (TSDB_CODE_SUCCESS != code) {




1,601,354✔






UNCOV

2746



    cfgCleanup(tsCfg);




×








UNCOV

2747



    tsCfg = NULL;




×








UNCOV

2748



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




×







2749



  }










2750












2751



  TAOS_RETURN(code);




1,601,354✔





2752



}










2753












2754



void taosCleanupCfg() {




3,001,454✔





2755



  if (tsCfg) {




3,001,454✔





2756



    cfgCleanup(tsCfg);




2,998,422✔





2757



    tsCfg = NULL;




2,998,422✔





2758



    cleanupTimezoneInfo();




2,998,422✔





2759



  }










2760



}




3,001,454✔





2761












2762



typedef struct {










2763



  const char *optionName;










2764



  void       *optionVar;










2765



} OptionNameAndVar;










2766












2767



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




1,314,716✔





2768



  int32_t code = TSDB_CODE_CFG_NOT_FOUND;




1,314,716✔





2769



  char   *name = pItem->name;




1,314,716✔





2770



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




20,509,913✔





2771



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




19,859,411✔





2772



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




19,859,411✔





2773



    code = TSDB_CODE_SUCCESS;




664,214✔





2774



    switch (pItem->dtype) {




664,214✔





2775



      case CFG_DTYPE_BOOL: {




25,412✔





2776



        int32_t flag = pItem->i32;




25,412✔





2777



        bool   *pVar = pOptions[d].optionVar;




25,412✔





2778



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




25,412✔





2779



        *pVar = flag;




25,412✔





2780



      } break;




25,412✔





2781



      case CFG_DTYPE_INT32: {




636,890✔





2782



        int32_t  flag = pItem->i32;




636,890✔





2783



        int32_t *pVar = pOptions[d].optionVar;




636,890✔





2784



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




636,890✔





2785



        *pVar = flag;




636,890✔





2786












2787



        if (isDebugflag) {




636,890✔





2788



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




13,712✔





2789



        }










2790



      } break;




636,890✔





2791



      case CFG_DTYPE_INT64: {




1,912✔





2792



        int64_t  flag = pItem->i64;




1,912✔





2793



        int64_t *pVar = pOptions[d].optionVar;




1,912✔





2794



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




1,912✔





2795



        *pVar = flag;




1,912✔





2796



      } break;




1,912✔






UNCOV

2797



      case CFG_DTYPE_FLOAT:




×







2798



      case CFG_DTYPE_DOUBLE: {











UNCOV

2799



        float  flag = pItem->fval;




×








UNCOV

2800



        float *pVar = pOptions[d].optionVar;




×








UNCOV

2801



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




×








UNCOV

2802



        *pVar = flag;




×








UNCOV

2803



      } break;




×








UNCOV

2804



      case CFG_DTYPE_STRING:




×







2805



      case CFG_DTYPE_DIR:










2806



      case CFG_DTYPE_LOCALE:










2807



      case CFG_DTYPE_CHARSET:










2808



      case CFG_DTYPE_TIMEZONE: {











UNCOV

2809



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




×








UNCOV

2810



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




×








UNCOV

2811



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




×







2812



        } else {











UNCOV

2813



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




×








UNCOV

2814



          code = TSDB_CODE_INVALID_CFG;




×








UNCOV

2815



          break;




×







2816



        }










2817



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




×







2818



      } break;




×







2819



      default:




×








UNCOV

2820



        code = TSDB_CODE_INVALID_CFG;




×








UNCOV

2821



        break;




×







2822



    }










2823












2824



    break;




664,214✔





2825



  }










2826












2827



  TAOS_RETURN(code);




1,314,716✔





2828



}










2829












2830



extern void tsdbAlterNumCompactThreads();










2831












2832



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




97,252✔





2833



  int32_t code = TSDB_CODE_SUCCESS;




97,252✔





2834



  int32_t lino = -1;




97,252✔





2835












2836



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




97,252✔





2837



    TAOS_RETURN(TSDB_CODE_SUCCESS);




255✔





2838



  }










2839












2840



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




96,997✔





2841



    // trigger, no item in cfg










2842



    taosResetLog();




251✔





2843



    cfgDumpCfg(tsCfg, 0, false);




251✔





2844



    TAOS_RETURN(TSDB_CODE_SUCCESS);




251✔





2845



  }










2846












2847



  cfgLock(pCfg);




96,746✔





2848












2849



  SConfigItem *pItem = cfgGetItem(pCfg, name);




96,746✔





2850



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




96,746✔






UNCOV

2851



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




×








UNCOV

2852



    code = TSDB_CODE_INVALID_CFG;




×








UNCOV

2853



    goto _exit;




×







2854



  }










2855












2856



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




96,746✔





2857



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




22,184✔





2858



    goto _exit;




22,184✔





2859



  }










2860












2861



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




74,562✔






UNCOV

2862



    tsEnableCoreFile = pItem->bval;




×








UNCOV

2863



    taosSetCoreDump(tsEnableCoreFile);




×








UNCOV

2864



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




×








UNCOV

2865



    goto _exit;




×







2866



  }










2867












2868



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




74,562✔






UNCOV

2869



    int32_t scope = 0;




×







2870



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




×







2871



    tsSlowLogScope = scope;




×








UNCOV

2872



    code = TSDB_CODE_SUCCESS;




×








UNCOV

2873



    goto _exit;




×







2874



  }










2875












2876



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




74,562✔






UNCOV

2877



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




×







2878



    code = TSDB_CODE_SUCCESS;




×







2879



    goto _exit;




×







2880



  }










2881



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




74,562✔





2882



    code = TSDB_CODE_SUCCESS;




×







2883



    goto _exit;




×







2884



  }










2885



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




74,562✔





2886



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




85✔





2887



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




85✔





2888



    code = TSDB_CODE_SUCCESS;




85✔





2889



    goto _exit;




85✔





2890



  }










2891












2892



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




74,477✔





2893



#ifdef TD_ENTERPRISE











UNCOV

2894



    tsNumOfCompactThreads = pItem->i32;




×








UNCOV

2895



    code = TSDB_CODE_SUCCESS;




×







2896



    // tsdbAlterNumCompactThreads();










2897



#else










2898



    code = TSDB_CODE_INVALID_CFG;










2899



#endif











UNCOV

2900



    goto _exit;




×







2901



  }










2902



#ifdef TD_ENTERPRISE










2903



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




74,477✔






UNCOV

2904



    tsAuthServer = pItem->bval;




×








UNCOV

2905



    goto _exit;




×







2906



  }










2907



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




74,477✔






UNCOV

2908



    tsAuthReq = pItem->bval;




×








UNCOV

2909



    goto _exit;




×







2910



  }










2911



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




74,477✔






UNCOV

2912



    tsAuthReqInterval = pItem->i32;




×








UNCOV

2913



    goto _exit;




×







2914



  }










2915



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




74,477✔






UNCOV

2916



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




×








UNCOV

2917



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




×








UNCOV

2918



    goto _exit;




×







2919



  }










2920



#endif










2921












2922



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




74,477✔





2923



    tsMinReservedMemorySize = pItem->i32;




255✔





2924



    code = taosMemoryPoolCfgUpdateReservedSize(tsMinReservedMemorySize);




255✔





2925



    goto _exit;




255✔





2926



  }










2927












2928



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




74,222✔





2929



    tsStreamBufferSize = pItem->i32;




296✔





2930



    atomic_store_64(&tsStreamBufferSizeBytes, tsStreamBufferSize * 1048576);




296✔





2931



    goto _exit;




296✔





2932



  }










2933












2934



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










2935



    static OptionNameAndVar debugOptions[] = {










2936



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










2937



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










2938



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










2939



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










2940



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










2941



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










2942



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










2943



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










2944



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










2945



    };










2946












2947



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










2948



                                         {"asynclog", &tsAsyncLog},










2949



                                         {"countAlwaysReturnValue", &tsCountAlwaysReturnValue},










2950



                                         {"enableWhiteList", &tsEnableWhiteList},










2951



                                         {"statusInterval", &tsStatusInterval},










2952



                                         {"statusIntervalMs", &tsStatusIntervalMs},










2953



                                         {"statusSRTimeoutMs", &tsStatusSRTimeoutMs},










2954



                                         {"statusTimeoutMs", &tsStatusTimeoutMs},










2955



                                         {"telemetryReporting", &tsEnableTelem},










2956



                                         {"monitor", &tsEnableMonitor},










2957



                                         {"monitorInterval", &tsMonitorInterval},










2958



                                         {"monitorComp", &tsMonitorComp},










2959



                                         {"monitorForceV2", &tsMonitorForceV2},










2960



                                         {"monitorLogProtocol", &tsMonitorLogProtocol},










2961



                                         {"monitorMaxLogs", &tsMonitorMaxLogs},










2962



                                         {"auditCreateTable", &tsEnableAuditCreateTable},










2963



                                         {"auditInterval", &tsAuditInterval},










2964



                                         {"auditLevel", &tsAuditLevel},










2965



                                         {"auditHttps", &tsAuditHttps},










2966



                                         {"auditUseToken", &tsAuditUseToken},










2967



                                         {"auditSaveInSelf", &tsAuditSaveInSelf},










2968



                                         {"slowLogThreshold", &tsSlowLogThreshold},










2969



                                         {"compressMsgSize", &tsCompressMsgSize},










2970



                                         {"compressor", &tsCompressor},










2971



                                         {"dPrecision", &tsDPrecision},










2972



                                         {"fPrecision", &tsFPrecision},










2973



                                         {"maxRange", &tsMaxRange},










2974



                                         {"maxTsmaNum", &tsMaxTsmaNum},










2975



                                         {"queryRsmaTolerance", &tsQueryRsmaTolerance},










2976



                                         {"uptimeInterval", &tsUptimeInterval},










2977












2978



                                         {"slowLogMaxLen", &tsSlowLogMaxLen},










2979



                                         {"slowLogScope", &tsSlowLogScope},










2980



                                         {"slowLogExceptDb", &tsSlowLogExceptDb},










2981












2982



                                         {"mndSdbWriteDelta", &tsMndSdbWriteDelta},










2983



                                         {"minDiskFreeSize", &tsMinDiskFreeSize},










2984



                                         {"randErrorChance", &tsRandErrChance},










2985



                                         {"randErrorDivisor", &tsRandErrDivisor},










2986



                                         {"randErrorScope", &tsRandErrScope},










2987



                                         {"syncLogBufferMemoryAllowed", &tsLogBufferMemoryAllowed},










2988



                                         {"syncApplyQueueSize", &tsSyncApplyQueueSize},










2989



                                         {"syncHeartbeatInterval", &tsHeartbeatInterval},










2990



                                         {"syncElectInterval", &tsElectInterval},










2991



                                         {"syncVnodeHeartbeatIntervalMs", &tsVnodeHeartbeatIntervalMs},










2992



                                         {"syncVnodeElectIntervalMs", &tsVnodeElectIntervalMs},










2993



                                         {"syncMnodeHeartbeatIntervalMs", &tsMnodeHeartbeatIntervalMs},










2994



                                         {"syncMnodeElectIntervalMs", &tsMnodeElectIntervalMs},










2995



                                         {"syncHeartbeatTimeout", &tsHeartbeatTimeout},










2996



                                         {"syncSnapReplMaxWaitN", &tsSnapReplMaxWaitN},










2997



                                         {"syncRoutineReportInterval", &tsRoutineReportInterval},










2998



                                         {"syncLogHeartbeat", &tsSyncLogHeartbeat},










2999



                                         {"syncTimeout", &tsSyncTimeout},










3000



                                         {"syncAssignedCheckAppliedGap", &tsSyncAssignedCheckAppliedGap},










3001



                                         {"walFsyncDataSizeLimit", &tsWalFsyncDataSizeLimit},










3002












3003



                                         {"numOfCores", &tsNumOfCores},










3004












3005



                                         {"enableCoreFile", &tsEnableCoreFile},










3006












3007



                                         {"telemetryInterval", &tsTelemInterval},










3008












3009



                                         {"retentionSpeedLimitMB", &tsRetentionSpeedLimitMB},










3010



                                         {"ttlChangeOnWrite", &tsTtlChangeOnWrite},










3011












3012



                                         {"logKeepDays", &tsLogKeepDays},










3013



                                         {"metaEntryCacheSize", &tsMetaEntryCacheSize},










3014



                                         {"mqRebalanceInterval", &tsMqRebalanceInterval},










3015



                                         {"numOfLogLines", &tsNumOfLogLines},










3016



                                         {"queryRspPolicy", &tsQueryRspPolicy},










3017



                                         {"timeseriesThreshold", &tsTimeSeriesThreshold},










3018



                                         {"tmqMaxTopicNum", &tmqMaxTopicNum},










3019



                                         {"transPullupInterval", &tsTransPullupInterval},










3020



                                         {"compactPullupInterval", &tsCompactPullupInterval},










3021



                                         {"queryTrimIntervalSec", &tsQueryTrimIntervalSec},










3022



                                         {"querySsMigrateIntervalSec", &tsQuerySsMigrateIntervalSec},










3023



                                         {"trimVDbIntervalSec", &tsTrimVDbIntervalSec},










3024



                                         {"ttlBatchDropNum", &tsTtlBatchDropNum},










3025



                                         {"ttlFlushThreshold", &tsTtlFlushThreshold},










3026



                                         {"ttlPushInterval", &tsTtlPushIntervalSec},










3027



                                         {"ttlUnit", &tsTtlUnit},










3028



                                         {"ssAutoMigrateIntervalSec", &tsSsAutoMigrateIntervalSec},










3029



                                         {"ssBlockCacheSize", &tsSsBlockCacheSize},










3030



                                         {"ssPageCacheSize", &tsSsPageCacheSize},










3031



                                         {"ssUploadDelaySec", &tsSsUploadDelaySec},










3032



                                         {"mndLogRetention", &tsMndLogRetention},










3033



                                         {"supportVnodes", &tsNumOfSupportVnodes},










3034



                                         {"experimental", &tsExperimental},










3035












3036



                                         {"numOfRpcSessions", &tsNumOfRpcSessions},










3037



                                         {"shellActivityTimer", &tsShellActivityTimer},










3038



                                         {"readTimeout", &tsReadTimeout},










3039



                                         {"safetyCheckLevel", &tsSafetyCheckLevel},










3040



                                         {"bypassFlag", &tsBypassFlag},










3041



                                         {"arbHeartBeatIntervalSec", &tsArbHeartBeatIntervalSec},










3042



                                         {"arbCheckSyncIntervalSec", &tsArbCheckSyncIntervalSec},










3043



                                         {"arbSetAssignedTimeoutSec", &tsArbSetAssignedTimeoutSec},










3044



                                         {"arbHeartBeatIntervalMs", &tsArbHeartBeatIntervalMs},










3045



                                         {"arbCheckSyncIntervalMs", &tsArbCheckSyncIntervalMs},










3046



                                         {"arbSetAssignedTimeoutMs", &tsArbSetAssignedTimeoutMs},










3047



                                         {"queryNoFetchTimeoutSec", &tsQueryNoFetchTimeoutSec},










3048



                                         {"enableStrongPassword", &tsEnableStrongPassword},










3049



                                         {"enableAdvancedSecurity", &tsEnableAdvancedSecurity},










3050



                                         {"enableGrantLegacySyntax", &tsEnableGrantLegacySyntax},










3051



                                         {"enableMetrics", &tsEnableMetrics},










3052



                                         {"metricsInterval", &tsMetricsInterval},










3053



                                         {"metricsLevel", &tsMetricsLevel},










3054



                                         {"forceKillTrans", &tsForceKillTrans},










3055



                                         {"enableTLS", &tsEnableTLS},










3056



                                         {"enableSasl", &tsEnableSasl},










3057



                                         {"rpcRecvLogThreshold", &tsRpcRecvLogThreshold},










3058



                                         {"tagFilterCache", &tsTagFilterCache},










3059



                                         {"stableTagFilterCache", &tsStableTagFilterCache}};










3060












3061



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




73,926✔





3062



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




60,214✔





3063



    }










3064



  }










3065












3066



_exit:




96,746✔





3067



  cfgUnLock(pCfg);




96,746✔





3068



  TAOS_RETURN(code);




96,746✔





3069



}










3070












3071



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




595,030✔





3072



  int32_t code = TSDB_CODE_SUCCESS;




595,030✔





3073



  int32_t lino = 0;




595,030✔





3074












3075



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




595,030✔





3076



    TAOS_RETURN(TSDB_CODE_SUCCESS);




477✔





3077



  }










3078












3079



  cfgLock(pCfg);




594,553✔





3080












3081



  SConfigItem *pItem = cfgGetItem(pCfg, name);




594,553✔





3082



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




594,553✔





3083



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




×








UNCOV

3084



    code = TSDB_CODE_INVALID_CFG;




×








UNCOV

3085



    goto _out;




×







3086



  }










3087












3088



  bool matched = false;




594,553✔





3089












3090



  int32_t len = strlen(name);




594,553✔





3091



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




594,553✔





3092



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




594,553✔





3093












3094



  switch (lowcaseName[0]) {




594,553✔





3095



    case 'd': {




16✔





3096



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




16✔





3097



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




16✔





3098



        matched = true;




16✔





3099



      }










3100



      break;




16✔





3101



    }










3102



    case 'e': {




174✔





3103



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




174✔






UNCOV

3104



        tsEnableCoreFile = pItem->bval;




×








UNCOV

3105



        taosSetCoreDump(tsEnableCoreFile);




×








UNCOV

3106



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




×







3107



        matched = true;




×







3108



      }










3109



      break;




174✔





3110



    }










3111



    case 'f': {




32✔





3112



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




32✔





3113



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




16✔





3114



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




16✔





3115



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




16✔





3116



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




16✔






UNCOV

3117



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




×








UNCOV

3118



          code = TSDB_CODE_CFG_NOT_FOUND;




×








UNCOV

3119



          goto _out;




×







3120



        }










3121












3122



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




16✔





3123



        tsServerPort = (uint16_t)pServerPortItem->i32;




16✔





3124



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




16✔





3125












3126



        char defaultFirstEp[TSDB_EP_LEN] = {0};




16✔





3127



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




16✔





3128












3129



        SEp firstEp = {0};




16✔





3130



        TAOS_CHECK_GOTO(




16✔





3131



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










3132



            _out);










3133



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




16✔





3134












3135



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




16✔





3136



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




16✔





3137



        matched = true;




16✔





3138



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




16✔





3139



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




16✔





3140



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




16✔





3141



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




16✔





3142



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




16✔





3143



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




×








UNCOV

3144



          code = TSDB_CODE_CFG_NOT_FOUND;




×








UNCOV

3145



          goto _out;




×







3146



        }










3147












3148



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




16✔





3149



        tsServerPort = (uint16_t)pServerPortItem->i32;




16✔





3150



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




16✔





3151












3152



        char defaultFirstEp[TSDB_EP_LEN] = {0};




16✔





3153



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




16✔





3154












3155



        SEp firstEp = {0};




16✔





3156



        TAOS_CHECK_GOTO(




16✔





3157



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










3158



            _out);










3159



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




16✔





3160












3161



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




16✔





3162



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




16✔





3163



        matched = true;




16✔





3164



      }










3165



      break;




32✔





3166



    }










3167



    case 'l': {




387✔





3168



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




387✔






UNCOV

3169



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




×








UNCOV

3170



        if (pLocaleItem == NULL) {




×








UNCOV

3171



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




×








UNCOV

3172



          code = TSDB_CODE_CFG_NOT_FOUND;




×








UNCOV

3173



          goto _out;




×







3174



        }










3175













UNCOV

3176



        const char *locale = pLocaleItem->str;




×








UNCOV

3177



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




×








UNCOV

3178



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




×








UNCOV

3179



        matched = true;




×







3180



      }










3181



      break;




387✔





3182



    }










3183



    case 'm': {




4,180✔





3184



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




4,180✔





3185



        atomic_store_32(&tsMetaCacheMaxSize, pItem->i32);




16✔





3186



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




16✔





3187



        matched = true;




16✔





3188



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




4,164✔





3189



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




214✔





3190



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




214✔





3191



        matched = true;




214✔





3192



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




3,950✔





3193



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




16✔





3194



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




16✔





3195



        matched = true;




16✔





3196



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




3,934✔





3197



        tsMaxSQLLength = pItem->i32;




1,670✔





3198



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




1,670✔





3199



        matched = true;




1,670✔





3200



      }










3201



      break;




4,180✔





3202



    }










3203



    case 's': {




5,903✔





3204



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




5,903✔





3205



        SEp secondEp = {0};




16✔





3206



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




16✔





3207



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




16✔





3208



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




16✔





3209



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




16✔





3210



        matched = true;




16✔





3211



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




5,887✔





3212



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




16✔





3213



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




16✔





3214



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




16✔





3215



        matched = true;




16✔





3216



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




5,871✔





3217



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




16✔





3218



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




16✔





3219



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




16✔





3220



        matched = true;




16✔





3221



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




5,855✔





3222



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




16✔





3223



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




16✔





3224



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




16✔





3225



        matched = true;




16✔





3226



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




5,839✔





3227



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




16✔





3228



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




16✔





3229



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




16✔





3230



        matched = true;




16✔





3231



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




5,823✔






UNCOV

3232



        tsSqlSecurityEnabled = pItem->bval;




×








UNCOV

3233



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




×








UNCOV

3234



        matched = true;




×







3235



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




5,823✔





3236



        tsSqlSecurityWhitelistMode = pItem->i32;




1,029✔





3237



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




1,029✔





3238



        matched = true;




1,029✔





3239



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




4,794✔






UNCOV

3240



        tsSqlSecurityStringCheck = pItem->bval;




×








UNCOV

3241



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




×








UNCOV

3242



        matched = true;




×







3243



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




4,794✔






UNCOV

3244



        tsSqlSecurityASTCheck = pItem->bval;




×








UNCOV

3245



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




×








UNCOV

3246



        matched = true;




×







3247



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




4,794✔





3248



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




×







3249



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




×







3250



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




×







3251



        matched = true;




×







3252



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




4,794✔





3253



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




16✔





3254



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




16✔





3255



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




16✔





3256



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




16✔





3257



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




×








UNCOV

3258



          code = TSDB_CODE_CFG_NOT_FOUND;




×








UNCOV

3259



          goto _out;




×







3260



        }










3261












3262



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




16✔





3263



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




16✔





3264



        tsServerPort = (uint16_t)pServerPortItem->i32;




16✔





3265



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




16✔





3266












3267



        char defaultFirstEp[TSDB_EP_LEN] = {0};




16✔





3268



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




16✔





3269












3270



        SEp firstEp = {0};




16✔





3271



        TAOS_CHECK_GOTO(




16✔





3272



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










3273



            _out);










3274



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




16✔





3275












3276



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




16✔





3277



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




16✔





3278



        matched = true;




16✔





3279



      }










3280



      break;




5,903✔





3281



    }










3282



    case 't': {




174✔





3283



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




174✔






UNCOV

3284



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




×








UNCOV

3285



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




×








UNCOV

3286



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




×








UNCOV

3287



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




×








UNCOV

3288



        if (taosMulMkDir(tsTempDir) != 0) {




×








UNCOV

3289



          code = TAOS_SYSTEM_ERROR(ERRNO);




×








UNCOV

3290



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




×








UNCOV

3291



          goto _out;




×







3292



        }











UNCOV

3293



        matched = true;




×







3294



      }










3295



      break;




174✔





3296



    }










3297



    case 'w': {




1,176✔





3298



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




1,176✔





3299



        tsWhitelistLearning = pItem->bval;




1,029✔





3300



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




1,029✔





3301



        matched = true;




1,029✔





3302



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




147✔






UNCOV

3303



        tsWhitelistLearningPeriod = pItem->i32;




×








UNCOV

3304



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




×








UNCOV

3305



        matched = true;




×







3306



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




147✔





3307



        tsWhitelistLearningThreshold = pItem->i32;




147✔





3308



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




147✔





3309



        matched = true;




147✔





3310



      }










3311



      break;




1,176✔





3312



    }










3313



    default:




582,511✔





3314



      code = TSDB_CODE_CFG_NOT_FOUND;




582,511✔





3315



      break;




582,511✔





3316



  }










3317












3318



  if (matched) goto _out;




594,553✔





3319












3320



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










3321



    static OptionNameAndVar debugOptions[] = {










3322



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










3323



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










3324



        {"rpcDebugFlag", &rpcDebugFlag}, {"smaDebugFlag", &smaDebugFlag}, {"tmrDebugFlag", &tmrDebugFlag},










3325



        {"uDebugFlag", &uDebugFlag},     {"simDebugFlag", &simDebugFlag},










3326



    };










3327












3328



    static OptionNameAndVar options[] = {{"asyncLog", &tsAsyncLog},










3329



                                         {"compressMsgSize", &tsCompressMsgSize},










3330



                                         {"countAlwaysReturnValue", &tsCountAlwaysReturnValue},










3331



                                         {"crashReporting", &tsEnableCrashReport},










3332



                                         {"enableQueryHb", &tsEnableQueryHb},










3333



                                         {"keepColumnName", &tsKeepColumnName},










3334



                                         {"logKeepDays", &tsLogKeepDays},










3335



                                         {"maxInsertBatchRows", &tsMaxInsertBatchRows},










3336



                                         {"minSlidingTime", &tsMinSlidingTime},










3337



                                         {"minIntervalTime", &tsMinIntervalTime},










3338



                                         {"numOfLogLines", &tsNumOfLogLines},










3339



                                         {"querySmaOptimize", &tsQuerySmaOptimize},










3340



                                         {"queryPolicy", &tsQueryPolicy},










3341



                                         {"queryTableNotExistAsEmpty", &tsQueryTbNotExistAsEmpty},










3342



                                         {"queryPlannerTrace", &tsQueryPlannerTrace},










3343



                                         {"queryNodeChunkSize", &tsQueryNodeChunkSize},










3344



                                         {"queryUseNodeAllocator", &tsQueryUseNodeAllocator},










3345



                                         {"smlDot2Underline", &tsSmlDot2Underline},










3346



                                         {"useAdapter", &tsUseAdapter},










3347



                                         {"multiResultFunctionStarReturnTags", &tsMultiResultFunctionStarReturnTags},










3348



                                         {"maxTsmaCalcDelay", &tsMaxTsmaCalcDelay},










3349



                                         {"tsmaDataDeleteMark", &tsmaDataDeleteMark},










3350



                                         {"numOfRpcSessions", &tsNumOfRpcSessions},










3351



                                         {"bypassFlag", &tsBypassFlag},










3352



                                         {"safetyCheckLevel", &tsSafetyCheckLevel},










3353



                                         {"compareAsStrInGreatest", &tsCompareAsStrInGreatest},










3354



                                         {"showFullCreateTableColumn", &tsShowFullCreateTableColumn}};










3355












3356



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




590,288✔





3357



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




590,288✔





3358



    }










3359



  }










3360












3361



_out:




594,165✔





3362



  if (TSDB_CODE_SUCCESS != code) {




594,553✔






UNCOV

3363



    uError("failed to set option:%s, lino:%d, since:%s", name, lino, tstrerror(code));




×







3364



  }










3365












3366



  cfgUnLock(pCfg);




594,553✔





3367



  TAOS_RETURN(code);




594,553✔





3368



}










3369












3370



int32_t taosCfgDynamicOptions(SConfig *pCfg, const char *name, bool forServer) {




692,282✔





3371



  if (forServer) {




692,282✔





3372



    return taosCfgDynamicOptionsForServer(pCfg, name);




97,252✔





3373



  } else {










3374



    return taosCfgDynamicOptionsForClient(pCfg, name);




595,030✔





3375



  }










3376



}










3377












3378



int32_t taosSetDebugFlag(int32_t *pFlagPtr, const char *flagName, int32_t flagVal) {




3,622,902✔





3379



  SConfigItem *pItem = NULL;




3,622,902✔





3380



  TAOS_CHECK_GET_CFG_ITEM(tsCfg, pItem, flagName);




3,622,902✔





3381



  pItem->i32 = flagVal;




1,605,167✔





3382



  if (pFlagPtr != NULL) {




1,605,167✔





3383



    *pFlagPtr = flagVal;




1,605,167✔





3384



  }










3385



  TAOS_RETURN(TSDB_CODE_SUCCESS);




1,605,167✔





3386



}










3387












3388



static int taosLogVarComp(void const *lp, void const *rp) {




11,706,354✔





3389



  SLogVar *lpVar = (SLogVar *)lp;




11,706,354✔





3390



  SLogVar *rpVar = (SLogVar *)rp;




11,706,354✔





3391



  return taosStrcasecmp(lpVar->name, rpVar->name);




11,706,354✔





3392



}










3393












3394



static void taosCheckAndSetDebugFlag(int32_t *pFlagPtr, char *name, int32_t flag, SArray *noNeedToSetVars) {




5,011,344✔





3395



  if (noNeedToSetVars != NULL && taosArraySearch(noNeedToSetVars, name, taosLogVarComp, TD_EQ) != NULL) {




5,011,344✔





3396



    return;




1,402,154✔





3397



  }










3398



  int32_t code = 0;




3,609,190✔





3399



  if ((code = taosSetDebugFlag(pFlagPtr, name, flag)) != 0) {




3,609,190✔





3400



    if (code != TSDB_CODE_CFG_NOT_FOUND) {




2,017,735✔






UNCOV

3401



      uError("failed to set flag %s to %d, since:%s", name, flag, tstrerror(code));




×







3402



    } else {










3403



      uTrace("failed to set flag %s to %d, since:%s", name, flag, tstrerror(code));




2,017,735✔





3404



    }










3405



  }










3406



  return;




3,609,190✔





3407



}










3408













UNCOV

3409



int32_t taosSetGlobalDebugFlag(int32_t flag) { return taosSetAllDebugFlag(tsCfg, flag); }




×







3410












3411



// NOTE: set all command does not change the tmrDebugFlag










3412



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




6,019,775✔





3413



  if (flag < 0) TAOS_RETURN(TSDB_CODE_INVALID_PARA);




6,019,775✔





3414



  if (flag == 0) TAOS_RETURN(TSDB_CODE_SUCCESS);  // just ignore




6,019,775✔





3415












3416



  SArray      *noNeedToSetVars = NULL;




192,744✔





3417



  SConfigItem *pItem = NULL;




192,744✔





3418



  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "debugFlag");




192,744✔





3419












3420



  pItem->i32 = flag;




192,744✔





3421



  noNeedToSetVars = pItem->array;




192,744✔





3422












3423



  taosCheckAndSetDebugFlag(&simDebugFlag, "simDebugFlag", flag, noNeedToSetVars);




192,744✔





3424



  taosCheckAndSetDebugFlag(&uDebugFlag, "uDebugFlag", flag, noNeedToSetVars);




192,744✔





3425



  taosCheckAndSetDebugFlag(&rpcDebugFlag, "rpcDebugFlag", flag, noNeedToSetVars);




192,744✔





3426



  taosCheckAndSetDebugFlag(&qDebugFlag, "qDebugFlag", flag, noNeedToSetVars);




192,744✔





3427












3428



  taosCheckAndSetDebugFlag(&jniDebugFlag, "jniDebugFlag", flag, noNeedToSetVars);




192,744✔





3429



  taosCheckAndSetDebugFlag(&cDebugFlag, "cDebugFlag", flag, noNeedToSetVars);




192,744✔





3430












3431



  taosCheckAndSetDebugFlag(&dDebugFlag, "dDebugFlag", flag, noNeedToSetVars);




192,744✔





3432



  taosCheckAndSetDebugFlag(&vDebugFlag, "vDebugFlag", flag, noNeedToSetVars);




192,744✔





3433



  taosCheckAndSetDebugFlag(&mDebugFlag, "mDebugFlag", flag, noNeedToSetVars);




192,744✔





3434



  taosCheckAndSetDebugFlag(&wDebugFlag, "wDebugFlag", flag, noNeedToSetVars);




192,744✔





3435



  taosCheckAndSetDebugFlag(&azDebugFlag, "azDebugFlag", flag, noNeedToSetVars);




192,744✔





3436



  taosCheckAndSetDebugFlag(&tssDebugFlag, "tssDebugFlag", flag, noNeedToSetVars);




192,744✔





3437



  taosCheckAndSetDebugFlag(&sDebugFlag, "sDebugFlag", flag, noNeedToSetVars);




192,744✔





3438



  taosCheckAndSetDebugFlag(&tsdbDebugFlag, "tsdbDebugFlag", flag, noNeedToSetVars);




192,744✔





3439



  taosCheckAndSetDebugFlag(&tqDebugFlag, "tqDebugFlag", flag, noNeedToSetVars);




192,744✔





3440



  taosCheckAndSetDebugFlag(&fsDebugFlag, "fsDebugFlag", flag, noNeedToSetVars);




192,744✔





3441



  taosCheckAndSetDebugFlag(&udfDebugFlag, "udfDebugFlag", flag, noNeedToSetVars);




192,744✔





3442



  taosCheckAndSetDebugFlag(&smaDebugFlag, "smaDebugFlag", flag, noNeedToSetVars);




192,744✔





3443



  taosCheckAndSetDebugFlag(&idxDebugFlag, "idxDebugFlag", flag, noNeedToSetVars);




192,744✔





3444



  taosCheckAndSetDebugFlag(&tdbDebugFlag, "tdbDebugFlag", flag, noNeedToSetVars);




192,744✔





3445



  taosCheckAndSetDebugFlag(&metaDebugFlag, "metaDebugFlag", flag, noNeedToSetVars);




192,744✔





3446



  taosCheckAndSetDebugFlag(&stDebugFlag, "stDebugFlag", flag, noNeedToSetVars);




192,744✔





3447



  taosCheckAndSetDebugFlag(&sndDebugFlag, "sndDebugFlag", flag, noNeedToSetVars);




192,744✔





3448



  taosCheckAndSetDebugFlag(&bseDebugFlag, "bseDebugFlag", flag, noNeedToSetVars);




192,744✔





3449



  taosCheckAndSetDebugFlag(&bndDebugFlag, "bndDebugFlag", flag, noNeedToSetVars);




192,744✔





3450



  taosCheckAndSetDebugFlag(&xndDebugFlag, "xndDebugFlag", flag, noNeedToSetVars);




192,744✔





3451












3452



  taosArrayClear(noNeedToSetVars);  // reset array




192,744✔





3453












3454



  uInfo("all debug flag are set to %d", flag);




192,744✔





3455



  TAOS_RETURN(TSDB_CODE_SUCCESS);




192,744✔





3456



}










3457












3458



int32_t taosGranted(int8_t type) {




313,914,704✔





3459



  switch (type) {




313,914,704✔





3460



    case TSDB_GRANT_ALL: {




313,615,618✔





3461



      if (atomic_load_32(&tsGrant) & GRANT_FLAG_ALL) {




313,615,618✔





3462



        return 0;




313,600,041✔





3463



      }











UNCOV

3464



      int32_t grantVal = atomic_load_32(&tsGrant);




×








UNCOV

3465



      if (grantVal & GRANT_FLAG_EX_MULTI_TIER) {




×








UNCOV

3466



        return TSDB_CODE_GRANT_MULTI_STORAGE_EXPIRED;




×







3467



      } else if (grantVal & GRANT_FLAG_EX_STORAGE) {




×







3468



        return TSDB_CODE_GRANT_STORAGE_LIMITED;




×







3469



      }











UNCOV

3470



      return TSDB_CODE_GRANT_EXPIRED;




×







3471



    }










3472



    case TSDB_GRANT_AUDIT: {




918✔





3473



      return (atomic_load_32(&tsGrant) & GRANT_FLAG_AUDIT) ? 0 : TSDB_CODE_GRANT_AUDIT_EXPIRED;




918✔





3474



    }










3475



    case TSDB_GRANT_VIEW:




329,446✔





3476



      return (atomic_load_32(&tsGrant) & GRANT_FLAG_VIEW) ? 0 : TSDB_CODE_GRANT_VIEW_EXPIRED;




329,446✔






UNCOV

3477



    default:




×








UNCOV

3478



      uWarn("undefined grant type:%" PRIi8, type);




×








UNCOV

3479



      break;




×







3480



  }











UNCOV

3481



  return 0;




×







3482



}










3483












3484



int32_t globalConfigSerialize(int32_t version, SArray *array, char **serialized) {




548,358✔





3485



  char   buf[30];




544,493✔





3486



  cJSON *json = cJSON_CreateObject();




548,358✔





3487



  if (json == NULL) goto _exit;




548,358✔





3488



  if (cJSON_AddNumberToObject(json, "file_version", GLOBAL_CONFIG_FILE_VERSION) == NULL) goto _exit;




548,358✔





3489



  if (cJSON_AddNumberToObject(json, "version", version) == NULL) goto _exit;




548,358✔





3490



  int sz = taosArrayGetSize(array);




548,358✔





3491












3492



  cJSON *cField = cJSON_CreateObject();




548,358✔





3493



  if (cField == NULL) goto _exit;




548,358✔





3494












3495



  if (!cJSON_AddItemToObject(json, "configs", cField)) goto _exit;




548,358✔





3496












3497



  // cjson only support int32_t or double










3498



  // string are used to prohibit the loss of precision










3499



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




63,192,193✔





3500



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




62,643,835✔





3501



    switch (item->dtype) {




62,643,835✔





3502



      {











UNCOV

3503



        case CFG_DTYPE_NONE:




×








UNCOV

3504



          break;




×







3505



        case CFG_DTYPE_BOOL:




15,797,141✔





3506



          if (cJSON_AddBoolToObject(cField, item->name, item->bval) == NULL) goto _exit;




15,797,141✔





3507



          break;




15,797,141✔





3508



        case CFG_DTYPE_INT32:




32,139,011✔





3509



          if (cJSON_AddNumberToObject(cField, item->name, item->i32) == NULL) goto _exit;




32,139,011✔





3510



          break;




32,139,011✔





3511



        case CFG_DTYPE_INT64:




3,813,103✔





3512



          (void)snprintf(buf, sizeof(buf), "%" PRId64, item->i64);




3,813,103✔





3513



          if (cJSON_AddStringToObject(cField, item->name, buf) == NULL) goto _exit;




3,813,103✔





3514



          break;




3,813,103✔





3515



        case CFG_DTYPE_FLOAT:




1,089,458✔





3516



        case CFG_DTYPE_DOUBLE:










3517



          (void)snprintf(buf, sizeof(buf), "%f", item->fval);




1,089,458✔





3518



          if (cJSON_AddStringToObject(cField, item->name, buf) == NULL) goto _exit;




1,089,458✔





3519



          break;




1,089,458✔





3520



        case CFG_DTYPE_STRING:




9,805,122✔





3521



        case CFG_DTYPE_DIR:










3522



        case CFG_DTYPE_LOCALE:










3523



        case CFG_DTYPE_CHARSET:










3524



        case CFG_DTYPE_TIMEZONE:










3525



          if (cJSON_AddStringToObject(cField, item->name, item->str) == NULL) goto _exit;




9,805,122✔





3526



          break;




9,805,122✔





3527



      }










3528



    }










3529



  }










3530



  char *pSerialized = tjsonToString(json);




548,358✔





3531



_exit:




548,358✔





3532



  if (terrno != TSDB_CODE_SUCCESS) {




548,358✔





3533



    uError("failed to serialize global config since %s", tstrerror(terrno));




2,051✔





3534



  }










3535



  cJSON_Delete(json);




548,358✔





3536



  *serialized = pSerialized;




548,358✔





3537



  return terrno;




548,358✔





3538



}










3539












3540



int32_t localConfigSerialize(SArray *array, char **serialized) {




759,955✔





3541



  char   buf[30];




759,594✔





3542



  cJSON *json = cJSON_CreateObject();




759,955✔





3543



  if (json == NULL) goto _exit;




759,955✔





3544












3545



  int sz = taosArrayGetSize(array);




759,955✔





3546












3547



  cJSON *cField = cJSON_CreateObject();




759,955✔





3548



  if (cField == NULL) goto _exit;




759,955✔





3549



  if (cJSON_AddNumberToObject(json, "file_version", LOCAL_CONFIG_FILE_VERSION) == NULL) goto _exit;




759,955✔





3550



  if (!cJSON_AddItemToObject(json, "configs", cField)) goto _exit;




759,955✔





3551












3552



  // cjson only support int32_t or double










3553



  // string are used to prohibit the loss of precision










3554



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




121,592,800✔





3555



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




120,832,845✔





3556



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




120,832,845✔





3557



      int32_t sz = taosArrayGetSize(item->array);




759,955✔





3558



      cJSON  *dataDirs = cJSON_CreateArray();




759,955✔





3559



      if (!cJSON_AddItemToObject(cField, item->name, dataDirs)) {




759,955✔






UNCOV

3560



        uError("failed to serialize global config since %s", tstrerror(terrno));




×








UNCOV

3561



        goto _exit;




×







3562



      }










3563



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




1,589,152✔





3564



        SDiskCfg *disk = (SDiskCfg *)taosArrayGet(item->array, j);




829,197✔





3565



        cJSON    *dataDir = cJSON_CreateObject();




829,197✔





3566



        if (dataDir == NULL) goto _exit;




829,197✔





3567



        if (!cJSON_AddItemToArray(dataDirs, dataDir)) {




829,197✔






UNCOV

3568



          uError("failed to serialize global config since %s", tstrerror(terrno));




×








UNCOV

3569



          goto _exit;




×







3570



        }










3571



        if (cJSON_AddStringToObject(dataDir, "dir", disk->dir) == NULL) goto _exit;




829,197✔





3572



        if (cJSON_AddNumberToObject(dataDir, "level", disk->level) == NULL) goto _exit;




829,197✔





3573



        if (disk->diskId == 0) {




829,197✔





3574



          if (taosGetFileDiskID(disk->dir, &disk->diskId) != 0) {




748,745✔






UNCOV

3575



            uError("failed to get disk id for %s", disk->dir);




×








UNCOV

3576



            goto _exit;




×







3577



          }










3578



        }










3579



        (void)snprintf(buf, sizeof(buf), "%" PRId64, disk->diskId);




829,197✔





3580



        if (cJSON_AddStringToObject(dataDir, "disk_id", buf) == NULL) goto _exit;




829,197✔





3581



        if (cJSON_AddNumberToObject(dataDir, "primary", disk->primary) == NULL) goto _exit;




829,197✔





3582



        if (cJSON_AddNumberToObject(dataDir, "disable", disk->disable) == NULL) goto _exit;




829,197✔





3583



      }










3584



      continue;




759,955✔





3585



    }










3586



    switch (item->dtype) {




120,072,890✔





3587



      {











UNCOV

3588



        case CFG_DTYPE_NONE:




×








UNCOV

3589



          break;




×







3590



        case CFG_DTYPE_BOOL:




24,318,560✔





3591



          if (cJSON_AddBoolToObject(cField, item->name, item->bval) == NULL) goto _exit;




24,318,560✔





3592



          break;




24,318,560✔





3593



        case CFG_DTYPE_INT32:




66,876,040✔





3594



          if (cJSON_AddNumberToObject(cField, item->name, item->i32) == NULL) goto _exit;




66,876,040✔





3595



          break;




66,876,040✔





3596



        case CFG_DTYPE_INT64:




6,079,640✔





3597



          (void)snprintf(buf, sizeof(buf), "%" PRId64, item->i64);




6,079,640✔





3598



          if (cJSON_AddStringToObject(cField, item->name, buf) == NULL) goto _exit;




6,079,640✔





3599



          break;




6,079,640✔





3600



        case CFG_DTYPE_FLOAT:




3,039,820✔





3601



        case CFG_DTYPE_DOUBLE:










3602



          (void)snprintf(buf, sizeof(buf), "%f", item->fval);




3,039,820✔





3603



          if (cJSON_AddStringToObject(cField, item->name, buf) == NULL) goto _exit;




3,039,820✔





3604



          break;




3,039,820✔





3605



        case CFG_DTYPE_STRING:




19,758,830✔





3606



        case CFG_DTYPE_DIR:










3607



        case CFG_DTYPE_LOCALE:










3608



        case CFG_DTYPE_CHARSET:










3609



        case CFG_DTYPE_TIMEZONE:










3610



          if (cJSON_AddStringToObject(cField, item->name, item->str) == NULL) goto _exit;




19,758,830✔





3611



          break;




19,758,830✔





3612



      }










3613



    }










3614



  }










3615



  char *pSerialized = tjsonToString(json);




759,955✔





3616



_exit:




759,955✔





3617



  if (terrno != TSDB_CODE_SUCCESS) {




759,955✔






UNCOV

3618



    uError("failed to serialize local config since %s", tstrerror(terrno));




×







3619



  }










3620



  cJSON_Delete(json);




759,955✔





3621



  *serialized = pSerialized;




759,955✔





3622



  return terrno;




759,955✔





3623



}










3624












3625



int32_t stypeConfigSerialize(SArray *array, char **serialized) {




759,955✔





3626



  char   buf[30];










3627



  cJSON *json = cJSON_CreateObject();




759,955✔





3628



  if (json == NULL) goto _exit;




759,955✔





3629












3630



  int sz = taosArrayGetSize(array);




759,955✔





3631












3632



  cJSON *cField = cJSON_CreateObject();




759,955✔





3633



  if (cField == NULL) goto _exit;




759,955✔





3634



  if (cJSON_AddNumberToObject(json, "file_version", LOCAL_CONFIG_FILE_VERSION) == NULL) goto _exit;




759,955✔





3635



  if (!cJSON_AddItemToObject(json, "config_stypes", cField)) goto _exit;




759,955✔





3636












3637



  // cjson only support int32_t or double










3638



  // string are used to prohibit the loss of precision










3639



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




121,592,800✔





3640



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




120,832,845✔





3641



    if (cJSON_AddNumberToObject(cField, item->name, item->stype) == NULL) goto _exit;




120,832,845✔





3642



  }










3643



  char *pSerialized = tjsonToString(json);




759,955✔





3644



_exit:




759,955✔





3645



  if (terrno != TSDB_CODE_SUCCESS) {




759,955✔






UNCOV

3646



    uError("failed to serialize local config since %s", tstrerror(terrno));




×







3647



  }










3648



  cJSON_Delete(json);




759,955✔





3649



  *serialized = pSerialized;




759,955✔





3650



  return terrno;




759,955✔





3651



}










3652












3653



int32_t taosPersistGlobalConfig(SArray *array, const char *path, int32_t version) {




548,358✔





3654



  int32_t   code = 0;




548,358✔





3655



  int32_t   lino = 0;




548,358✔





3656



  char     *serialized = NULL;




548,358✔





3657



  char      filepath[CONFIG_FILE_LEN] = {0};




548,358✔





3658



  char      filename[CONFIG_FILE_LEN] = {0};




548,358✔





3659



  snprintf(filepath, sizeof(filepath), "%s%sconfig", path, TD_DIRSEP);




548,358✔





3660



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




548,358✔





3661












3662



  TAOS_CHECK_GOTO(taosMkDir(filepath), &lino, _exit);




548,358✔





3663












3664



  TAOS_CHECK_GOTO(globalConfigSerialize(version, array, &serialized), &lino, _exit);




548,358✔





3665












3666



  // Use taosWriteCfgFile for encryption support (automatically encrypts if tsCfgKey is set)










3667



  code = taosWriteCfgFile(filename, serialized, strlen(serialized));




546,307✔





3668



  if (code != TSDB_CODE_SUCCESS) {




546,307✔





3669



    lino = __LINE__;




×








UNCOV

3670



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




×








UNCOV

3671



    goto _exit;




×







3672



  }










3673












3674



_exit:




546,307✔





3675



  if (code != TSDB_CODE_SUCCESS) {




548,358✔





3676



    uError("failed to persist global config at line:%d, since %s", lino, tstrerror(code));




2,051✔





3677



  }










3678



  taosMemoryFree(serialized);




548,358✔





3679



  return code;




548,358✔





3680



}










3681












3682



int32_t taosPersistLocalConfig(const char *path) {




759,955✔





3683



  int32_t   code = 0;




759,955✔





3684



  int32_t   lino = 0;




759,955✔





3685



  char     *serializedCfg = NULL;




759,955✔





3686



  char     *serializedStype = NULL;




759,955✔





3687



  char      filepath[CONFIG_FILE_LEN] = {0};




759,955✔





3688



  char      filename[CONFIG_FILE_LEN] = {0};




759,955✔





3689



  char      stypeFilename[CONFIG_FILE_LEN] = {0};




759,955✔





3690



  snprintf(filepath, sizeof(filepath), "%s%sconfig", path, TD_DIRSEP);




759,955✔





3691



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




759,955✔





3692



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




759,955✔





3693












3694



  // TODO(beryl) need to check if the file is existed










3695



  TAOS_CHECK_GOTO(taosMkDir(filepath), &lino, _exit);




759,955✔





3696












3697



  // Serialize local config










3698



  TAOS_CHECK_GOTO(localConfigSerialize(taosGetLocalCfg(tsCfg), &serializedCfg), &lino, _exit);




759,955✔





3699












3700



  // Use taosWriteCfgFile for encryption support (automatically encrypts if tsCfgKey is set)










3701



  code = taosWriteCfgFile(filename, serializedCfg, strlen(serializedCfg));




759,955✔





3702



  if (code != TSDB_CODE_SUCCESS) {




759,955✔





3703



    lino = __LINE__;




×







3704



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




×








UNCOV

3705



    goto _exit;




×







3706



  }










3707












3708



  // Serialize stype config










3709



  TAOS_CHECK_GOTO(stypeConfigSerialize(taosGetLocalCfg(tsCfg), &serializedStype), &lino, _exit);




759,955✔





3710












3711



  // Use taosWriteCfgFile for encryption support (automatically encrypts if tsCfgKey is set)










3712



  code = taosWriteCfgFile(stypeFilename, serializedStype, strlen(serializedStype));




759,955✔





3713



  if (code != TSDB_CODE_SUCCESS) {




759,955✔






UNCOV

3714



    lino = __LINE__;




×








UNCOV

3715



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




×








UNCOV

3716



    goto _exit;




×







3717



  }










3718












3719



_exit:




759,955✔





3720



  if (code != TSDB_CODE_SUCCESS) {




759,955✔






UNCOV

3721



    uError("failed to persist local config at line:%d, since %s", lino, tstrerror(code));




×







3722



  }










3723



  taosMemoryFree(serializedCfg);




759,955✔





3724



  taosMemoryFree(serializedStype);




759,955✔





3725



  return code;




759,955✔





3726



}










3727












3728



int32_t tSerializeSConfigArray(SEncoder *pEncoder, SArray *array) {




2,749,940✔





3729



  int32_t code = 0;




2,749,940✔





3730



  int32_t lino = 0;




2,749,940✔





3731



  int32_t sz = taosArrayGetSize(array);




2,749,940✔





3732



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, sz));




2,749,940✔





3733



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




282,294,700✔





3734



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




279,544,760✔





3735



    TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, item->name));




559,089,520✔





3736



    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, item->dtype));




559,089,520✔





3737



    switch (item->dtype) {




279,544,760✔





3738



      {











UNCOV

3739



        case CFG_DTYPE_NONE:




×








UNCOV

3740



          break;




×







3741



        case CFG_DTYPE_BOOL:




70,493,896✔





3742



          TAOS_CHECK_EXIT(tEncodeBool(pEncoder, item->bval));




70,493,896✔





3743



          break;




70,493,896✔





3744



        case CFG_DTYPE_INT32:




143,418,616✔





3745



          TAOS_CHECK_EXIT(tEncodeI32(pEncoder, item->i32));




286,837,232✔





3746



          break;




143,418,616✔





3747



        case CFG_DTYPE_INT64:




17,015,768✔





3748



          TAOS_CHECK_EXIT(tEncodeI64(pEncoder, item->i64));




34,031,536✔





3749



          break;




17,015,768✔





3750



        case CFG_DTYPE_FLOAT:




4,861,648✔





3751



        case CFG_DTYPE_DOUBLE:










3752



          TAOS_CHECK_EXIT(tEncodeFloat(pEncoder, item->fval));




9,723,296✔





3753



          break;




4,861,648✔





3754



        case CFG_DTYPE_STRING:




43,754,832✔





3755



        case CFG_DTYPE_DIR:










3756



        case CFG_DTYPE_LOCALE:










3757



        case CFG_DTYPE_CHARSET:










3758



        case CFG_DTYPE_TIMEZONE:










3759



          TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, item->str));




87,509,664✔





3760



          break;




43,754,832✔





3761



      }










3762



    }










3763



  }










3764



_exit:




2,749,940✔





3765



  return code;




2,749,940✔





3766



}










3767












3768



int32_t tDeserializeSConfigArray(SDecoder *pDecoder, SArray *array) {




1,370,158✔





3769



  int32_t code = 0;




1,370,158✔





3770



  int32_t lino = 0;




1,370,158✔





3771



  int32_t sz = 0;




1,370,158✔





3772



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &sz));




1,370,158✔





3773



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




140,621,703✔





3774



    SConfigItem item = {0};




139,251,545✔





3775



    TAOS_CHECK_EXIT(tDecodeCStr(pDecoder, &item.name));




139,251,545✔





3776



    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, (int32_t *)&item.dtype));




139,251,545✔





3777



    switch (item.dtype) {




139,251,545✔





3778



      {











UNCOV

3779



        case CFG_DTYPE_NONE:




×








UNCOV

3780



          break;




×







3781



        case CFG_DTYPE_BOOL:




35,115,607✔





3782



          TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &item.bval));




35,115,607✔





3783



          break;




35,115,607✔





3784



        case CFG_DTYPE_INT32:




71,442,097✔





3785



          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &item.i32));




71,442,097✔





3786



          break;




71,442,097✔





3787



        case CFG_DTYPE_INT64:




8,476,181✔





3788



          TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &item.i64));




8,476,181✔





3789



          break;




8,476,181✔





3790



        case CFG_DTYPE_FLOAT:




2,421,766✔





3791



        case CFG_DTYPE_DOUBLE:










3792



          TAOS_CHECK_EXIT(tDecodeFloat(pDecoder, &item.fval));




2,421,766✔





3793



          break;




2,421,766✔





3794



        case CFG_DTYPE_STRING:




21,795,894✔





3795



        case CFG_DTYPE_DIR:










3796



        case CFG_DTYPE_LOCALE:










3797



        case CFG_DTYPE_CHARSET:










3798



        case CFG_DTYPE_TIMEZONE:










3799



          TAOS_CHECK_EXIT(tDecodeCStr(pDecoder, &item.str));




21,795,894✔





3800



          break;




21,795,894✔





3801



      }










3802



    }










3803



    if (taosArrayPush(array, &item) == NULL) {




139,251,545✔






UNCOV

3804



      code = terrno;




×








UNCOV

3805



      goto _exit;




×







3806



    }










3807



  }










3808



_exit:




1,370,158✔





3809



  if (code != TSDB_CODE_SUCCESS) {




1,370,158✔






UNCOV

3810



    uError("failed to deserialize SConfigItem at line:%d, since %s", lino, tstrerror(code));




×







3811



  }










3812



  return code;




1,370,158✔





3813



}










3814












3815



bool isConifgItemLazyMode(SConfigItem *item) {




97,695✔





3816



  if (item->dynScope == CFG_DYN_CLIENT_LAZY || item->dynScope == CFG_DYN_SERVER_LAZY ||




97,695✔





3817



      item->dynScope == CFG_DYN_BOTH_LAZY) {




97,086✔





3818



    return true;




694✔





3819



  }










3820



  return false;




97,001✔





3821



}










3822












3823



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




77,678,207✔





3824



  if (strlen(value) > len) {




77,678,207✔






UNCOV

3825



    uError("invalid config:%s, value:%s, length should be less than %d", name, value, len);




×








UNCOV

3826



    TAOS_RETURN(TSDB_CODE_INVALID_CFG_VALUE);




×







3827



  }










3828



  TAOS_RETURN(TSDB_CODE_SUCCESS);




77,678,207✔





3829



}
























    

  • 

    •