taosdata / TDengine / #3903

/*

 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>

 *

 * This program is free software: you can use, redistribute, and/or modify

 * it under the terms of the GNU Affero General Public License, version 3

 * or later ("AGPL"), as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.

 *

 * You should have received a copy of the GNU Affero General Public License

 * along with this program. If not, see <http://www.gnu.org/licenses/>.

 */

#define _DEFAULT_SOURCE

#include "tglobal.h"

#include "cJSON.h"

#include "defines.h"

#include "os.h"

#include "osString.h"

#include "tconfig.h"

#include "tgrant.h"

#include "tjson.h"

#include "tlog.h"

#include "tmisce.h"

#include "tunit.h"

#include "tutil.h"

#define CONFIG_PATH_LEN (TSDB_FILENAME_LEN + 12)

#define CONFIG_FILE_LEN (CONFIG_PATH_LEN + 32)

// GRANT_CFG_DECLARE;

SConfig *tsCfg = NULL;

// cluster

char          tsFirst[TSDB_EP_LEN] = {0};

char          tsSecond[TSDB_EP_LEN] = {0};

char          tsLocalFqdn[TSDB_FQDN_LEN] = {0};

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

char          tsVersionName[16] = "community";

uint16_t      tsServerPort = 6030;

int32_t       tsVersion = 30000000;

int32_t       tsForceReadConfig = 0;

int32_t       tsdmConfigVersion = -1;

int32_t       tsConfigInited = 0;

int32_t       tsStatusInterval = 1;  // second

int32_t       tsNumOfSupportVnodes = 256;

char          tsEncryptAlgorithm[16] = {0};

char          tsEncryptScope[100] = {0};

EEncryptAlgor tsiEncryptAlgorithm = 0;

EEncryptScope tsiEncryptScope = 0;

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

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

char tsEncryptKey[17] = {0};

int8_t tsEnableStrongPassword = 1;

// common

int32_t tsMaxShellConns = 50000;

int32_t tsShellActivityTimer = 3;  // second

// memory pool

int8_t tsMemPoolFullFunc = 0;

#ifndef TD_ASTRA

int8_t tsQueryUseMemoryPool = 1;

#else

int8_t tsQueryUseMemoryPool = 0;

#endif

int32_t tsQueryBufferPoolSize = 0;       // MB

int32_t tsSingleQueryMaxMemorySize = 0;  // MB

int32_t tsMinReservedMemorySize = 0;     // MB

int64_t tsCurrentAvailMemorySize = 0;

int8_t  tsNeedTrim = 0;

// queue & threads

int32_t tsQueryMinConcurrentTaskNum = 1;

int32_t tsQueryMaxConcurrentTaskNum = 0;

int32_t tsQueryConcurrentTaskNum = 0;

int32_t tsQueryNoFetchTimeoutSec = 3600 * 5;

int32_t tsNumOfRpcThreads = 1;

int32_t tsNumOfRpcSessions = 30000;

#ifdef WINDOWS

int32_t tsShareConnLimit = 1;

#else

int32_t tsShareConnLimit = 10;

#endif

int32_t tsReadTimeout = 900;

int32_t tsTimeToGetAvailableConn = 500000;

int32_t tsNumOfQueryThreads = 0;

int32_t tsNumOfCommitThreads = 2;

int32_t tsNumOfTaskQueueThreads = 16;

int32_t tsNumOfMnodeQueryThreads = 16;

int32_t tsNumOfMnodeFetchThreads = 1;

int32_t tsNumOfMnodeReadThreads = 1;

int32_t tsNumOfVnodeQueryThreads = 16;

float   tsRatioOfVnodeStreamThreads = 0.5F;

int32_t tsNumOfVnodeFetchThreads = 4;

int32_t tsNumOfVnodeRsmaThreads = 2;

int32_t tsNumOfQnodeQueryThreads = 16;

int32_t tsNumOfQnodeFetchThreads = 1;

int32_t tsNumOfSnodeStreamThreads = 4;

int32_t tsNumOfSnodeWriteThreads = 1;

int32_t tsMaxStreamBackendCache = 128;  // M

int32_t tsPQSortMemThreshold = 16;      // M

int32_t tsRetentionSpeedLimitMB = 0;    // unlimited

int32_t tsNumOfCompactThreads = 2;

int32_t tsNumOfRetentionThreads = 1;

// sync raft

int32_t tsElectInterval = 25 * 1000;

int32_t tsHeartbeatInterval = 1000;

int32_t tsHeartbeatTimeout = 20 * 1000;

int32_t tsSnapReplMaxWaitN = 128;

int64_t tsLogBufferMemoryAllowed = 0;  // bytes

// mnode

int64_t tsMndSdbWriteDelta = 200;

int64_t tsMndLogRetention = 2000;

bool    tsMndSkipGrant = false;

bool    tsEnableWhiteList = false;  // ip white list cfg

// arbitrator

int32_t tsArbHeartBeatIntervalSec = 2;

int32_t tsArbCheckSyncIntervalSec = 3;

int32_t tsArbSetAssignedTimeoutSec = 14;

// dnode

int64_t tsDndStart = 0;

int64_t tsDndStartOsUptime = 0;

int64_t tsDndUpTime = 0;

// dnode misc

uint32_t tsEncryptionKeyChksum = 0;

int8_t   tsEncryptionKeyStat = ENCRYPT_KEY_STAT_UNSET;

int8_t   tsGrant = 1;

bool tsCompareAsStrInGreatest = true;

// monitor

#ifdef USE_MONITOR

bool tsEnableMonitor = true;

#else

bool tsEnableMonitor = false;

#endif

int32_t  tsMonitorInterval = 30;

char     tsMonitorFqdn[TSDB_FQDN_LEN] = {0};

uint16_t tsMonitorPort = 6043;

int32_t  tsMonitorMaxLogs = 100;

bool     tsMonitorComp = false;

bool     tsMonitorLogProtocol = false;

#ifdef USE_MONITOR

bool tsMonitorForceV2 = true;

#else

bool tsMonitorForceV2 = false;

#endif

// audit

#ifdef USE_AUDIT

bool    tsEnableAudit = true;

bool    tsEnableAuditCreateTable = true;

bool    tsEnableAuditDelete = true;

int32_t tsAuditInterval = 5000;

#else

bool    tsEnableAudit = false;

bool    tsEnableAuditCreateTable = false;

bool    tsEnableAuditDelete = false;

int32_t tsAuditInterval = 200000;

#endif

// telem

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

bool tsEnableTelem = false;

#else

bool    tsEnableTelem = true;

#endif

int32_t  tsTelemInterval = 86400;

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

uint16_t tsTelemPort = 80;

char    *tsTelemUri = "/report";

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

bool tsEnableCrashReport = false;

#else

bool    tsEnableCrashReport = true;

#endif

char   *tsClientCrashReportUri = "/ccrashreport";

char   *tsSvrCrashReportUri = "/dcrashreport";

int32_t tsSafetyCheckLevel = TSDB_SAFETY_CHECK_LEVELL_NORMAL;

// schemaless

bool tsSmlDot2Underline = true;

char tsSmlTsDefaultName[TSDB_COL_NAME_LEN] = "_ts";

char tsSmlTagName[TSDB_COL_NAME_LEN] = "_tag_null";

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

char tsSmlAutoChildTableNameDelimiter[TSDB_TABLE_NAME_LEN] = "";

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

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

// bool    tsSmlDataFormat = false;

// int32_t tsSmlBatchSize = 10000;

// checkpoint backup

char    tsSnodeAddress[TSDB_FQDN_LEN] = {0};

int32_t tsRsyncPort = 873;

#ifdef WINDOWS

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

#else

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

#endif

// tmq

int32_t tmqMaxTopicNum = 20;

int32_t tmqRowSize = 1000;

// query

int32_t tsQueryPolicy = 1;

bool    tsQueryTbNotExistAsEmpty = false;

int32_t tsQueryRspPolicy = 0;

int64_t tsQueryMaxConcurrentTables = 200;  // unit is TSDB_TABLE_NUM_UNIT

bool    tsEnableQueryHb = true;

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

int32_t tsQuerySmaOptimize = 0;

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

bool    tsQueryPlannerTrace = false;

int32_t tsQueryNodeChunkSize = 32 * 1024;

bool    tsQueryUseNodeAllocator = true;

bool    tsKeepColumnName = false;

int32_t tsRedirectPeriod = 10;

int32_t tsRedirectFactor = 2;

int32_t tsRedirectMaxPeriod = 1000;

int32_t tsMaxRetryWaitTime = 10000;

bool    tsUseAdapter = false;

int32_t tsMetaCacheMaxSize = -1;                   // MB

int32_t tsSlowLogThreshold = 10;                   // seconds

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

int32_t tsSlowLogScope = SLOW_LOG_TYPE_QUERY;

char   *tsSlowLogScopeString = "query";

int32_t tsSlowLogMaxLen = 4096;

int32_t tsTimeSeriesThreshold = 50;

bool    tsMultiResultFunctionStarReturnTags = false;

/*

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

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

 *

 * 0: all data are compressed

 * -1: all data are not compressed

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

 */

int32_t tsCompressMsgSize = -1;

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

int32_t tsCountAlwaysReturnValue = 1;

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

int32_t tsMinSlidingTime = 1;

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

int32_t tsMinIntervalTime = 1;

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

int32_t tsMaxInsertBatchRows = 1000000;

float   tsSelectivityRatio = 1.0;

int32_t tsTagFilterResCacheSize = 1024 * 10;

char    tsTagFilterCache = 0;

int32_t tsBypassFlag = 0;

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

// -1 no limit (default)

// 0  no query allowed, queries are disabled

// positive value (in MB)

int32_t tsQueryBufferSize = -1;

int64_t tsQueryBufferSizeBytes = -1;

int32_t tsCacheLazyLoadThreshold = 500;

int32_t  tsDiskCfgNum = 0;

SDiskCfg tsDiskCfg[TFS_MAX_DISKS] = {0};

int64_t  tsMinDiskFreeSize = TFS_MIN_DISK_FREE_SIZE;

// stream scheduler

bool tsDeployOnSnode = true;

/*

 * minimum scale for whole system, millisecond by default

 * for TSDB_TIME_PRECISION_MILLI: 60000L

 *     TSDB_TIME_PRECISION_MICRO: 60000000L

 *     TSDB_TIME_PRECISION_NANO:  60000000000L

 */

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

/*

 * millisecond by default

 * for TSDB_TIME_PRECISION_MILLI: 3600000L

 *     TSDB_TIME_PRECISION_MICRO: 3600000000L

 *     TSDB_TIME_PRECISION_NANO:  3600000000000L

 */

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

// lossy compress 7

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

                                           // set empty can close lossy compress.

// below option can take effect when tsLossyColumns not empty

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

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

uint32_t tsMaxRange = 500;                      // max quantization intervals

uint32_t tsCurRange = 100;                      // current quantization intervals

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

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

// udf

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

bool tsStartUdfd = false;

#else

bool    tsStartUdfd = true;

#endif

// wal

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

// ttl

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

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

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

                                      */

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

// internal

bool    tsDiskIDCheckEnabled = false;

int32_t tsTransPullupInterval = 2;

int32_t tsCompactPullupInterval = 10;

int32_t tsMqRebalanceInterval = 2;

int32_t tsStreamCheckpointInterval = 300;

float   tsSinkDataRate = 2.0;

int32_t tsStreamNodeCheckInterval = 20;

int32_t tsMaxConcurrentCheckpoint = 1;

int32_t tsTtlUnit = 86400;

int32_t tsTtlPushIntervalSec = 10;

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

int32_t tsS3MigrateIntervalSec = 60 * 60;  // interval of s3migrate db in all vgroups

bool    tsS3MigrateEnabled = 0;

int32_t tsGrantHBInterval = 60;

int32_t tsUptimeInterval = 300;    // seconds

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

char    tsUdfdLdLibPath[512] = "";

#ifdef USE_STREAM

bool tsDisableStream = false;

#else

bool tsDisableStream = true;

#endif

int64_t tsStreamBufferSize = 128 * 1024 * 1024;

int64_t tsStreamFailedTimeout = 30 * 60 * 1000;

bool    tsFilterScalarMode = false;

int     tsStreamAggCnt = 100000;

bool    tsStreamCoverage = false;

char     tsAdapterFqdn[TSDB_FQDN_LEN] = "localhost";

uint16_t tsAdapterPort = 6041;

char     tsAdapterToken[512] = "cm9vdDp0YW9zZGF0YQ==";

bool tsUpdateCacheBatch = true;

int8_t tsS3EpNum = 0;

char   tsS3Endpoint[TSDB_MAX_EP_NUM][TSDB_FQDN_LEN] = {"<endpoint>"};

char   tsS3AccessKey[TSDB_MAX_EP_NUM][TSDB_FQDN_LEN] = {"<accesskey>"};

char   tsS3AccessKeyId[TSDB_MAX_EP_NUM][TSDB_FQDN_LEN] = {"<accesskeyid>"};

char   tsS3AccessKeySecret[TSDB_MAX_EP_NUM][TSDB_FQDN_LEN] = {"<accesskeysecrect>"};

char   tsS3BucketName[TSDB_FQDN_LEN] = "<bucketname>";

char   tsS3AppId[TSDB_MAX_EP_NUM][TSDB_FQDN_LEN] = {"<appid>"};

int8_t tsS3Enabled = false;

int8_t tsS3EnabledCfg = false;

int8_t tsS3Oss[TSDB_MAX_EP_NUM] = {false};

int8_t tsS3Ablob = false;

int8_t tsS3StreamEnabled = false;

int8_t tsS3Https[TSDB_MAX_EP_NUM] = {true};

char   tsS3Hostname[TSDB_MAX_EP_NUM][TSDB_FQDN_LEN] = {"<hostname>"};

int32_t tsS3BlockSize = -1;        // number of tsdb pages (4096)

int32_t tsS3BlockCacheSize = 16;   // number of blocks

int32_t tsS3PageCacheSize = 4096;  // number of pages

int32_t tsS3UploadDelaySec = 60;

bool tsExperimental = true;

int32_t tsMaxTsmaNum = 3;

int32_t tsMaxTsmaCalcDelay = 600;

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

void   *pTimezoneNameMap = NULL;

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

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

int32_t tsStreamVirtualMergeMaxDelayMs = 10 * 1000;  // 10s

int32_t tsStreamVirtualMergeMaxMemKb = 16 * 1024;    // 16MB

int32_t tsStreamVirtualMergeWaitMode = 0;            // 0 wait forever, 1 wait for max delay, 2 wait for max mem

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

#define TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, pName) \

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

    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);           \

  }

#ifndef _STORAGE

int32_t taosSetTfsCfg(SConfig *pCfg) {

  SConfigItem *pItem = NULL;

  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "dataDir");

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

  int32_t size = taosArrayGetSize(pItem->array);

  tsDiskCfgNum = 1;

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

  tsDiskCfg[0].level = 0;

  tsDiskCfg[0].primary = 1;

  tsDiskCfg[0].disable = 0;

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

  if (taosMulMkDir(tsDataDir) != 0) {

    int32_t code = TAOS_SYSTEM_ERROR(ERRNO);

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

    TAOS_RETURN(code);

  }

  TAOS_RETURN(TSDB_CODE_SUCCESS);

}

#else

int32_t taosSetTfsCfg(SConfig *pCfg);

#endif

#ifndef _STORAGE

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

#else

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

#endif

}

                              int8_t *pNum) {

  }

  }

  }

}

  }

    }

  }

  }

    } else {

    }

      } else {

      }

    }

  }

#if defined(USE_COS) || defined(USE_S3)

#ifdef TD_ENTERPRISE

#endif

#endif

  }

}

                           char *apolloUrl) {

  }

  }

#ifdef CUS_PROMPT

                   "%s"

                   "%s"

                   "%s.cfg",

                   cfgDir, tdDirsep, CUS_PROMPT);

#else

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

                   "%s"

                   "%s"

                   "taos.cfg",

                   cfgDir, tdDirsep);

#endif

  } else {

  }

  }

  }

  }

  }

  }

  }

}

      cfgAddFloat(pCfg, "minimalLogDirGB", 1.0f, 0.001f, 10000000, CFG_SCOPE_BOTH, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

                                CFG_DYN_ENT_BOTH, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "logKeepDays", 0, -365000, 365000, CFG_SCOPE_BOTH, CFG_DYN_ENT_BOTH, CFG_CATEGORY_LOCAL));

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

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

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

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

      cfgAddInt32(pCfg, "jniDebugFlag", jniDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

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

      cfgAddInt32(pCfg, "cDebugFlag", cDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

                                CFG_CATEGORY_LOCAL));

}

      cfgAddInt32(pCfg, "dDebugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "vDebugFlag", vDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "mDebugFlag", mDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "wDebugFlag", wDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "azDebugFlag", azDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "sDebugFlag", sDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "tsdbDebugFlag", tsdbDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "tqDebugFlag", tqDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

                                CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "fsDebugFlag", fsDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "udfDebugFlag", udfDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "smaDebugFlag", smaDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "idxDebugFlag", idxDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "tdbDebugFlag", tdbDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "metaDebugFlag", metaDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "stDebugFlag", stDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

      cfgAddInt32(pCfg, "sndDebugFlag", sndDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER, CFG_CATEGORY_LOCAL));

}

  }

      cfgAddBool(pCfg, "forceReadConfig", tsForceReadConfig, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL));

                                CFG_CATEGORY_LOCAL));

      cfgAddFloat(pCfg, "minimalTmpDirGB", 1.0f, 0.001f, 10000000, CFG_SCOPE_BOTH, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

                                CFG_CATEGORY_GLOBAL));

                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL));

      cfgAddInt32(pCfg, "queryPolicy", tsQueryPolicy, 1, 4, CFG_SCOPE_CLIENT, CFG_DYN_ENT_CLIENT, CFG_CATEGORY_LOCAL));

                               CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

      cfgAddBool(pCfg, "enableQueryHb", tsEnableQueryHb, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

      cfgAddBool(pCfg, "enableScience", tsEnableScience, CFG_SCOPE_CLIENT, CFG_DYN_NONE, CFG_CATEGORY_LOCAL));

                                CFG_CATEGORY_LOCAL));

      cfgAddBool(pCfg, "queryPlannerTrace", tsQueryPlannerTrace, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

                               CFG_CATEGORY_LOCAL));

      cfgAddBool(pCfg, "keepColumnName", tsKeepColumnName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

                                 CFG_CATEGORY_LOCAL));

                                 CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

      cfgAddString(pCfg, "smlTagName", tsSmlTagName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

      cfgAddString(pCfg, "smlTsDefaultName", tsSmlTsDefaultName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

      cfgAddBool(pCfg, "smlDot2Underline", tsSmlDot2Underline, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

                                CFG_CATEGORY_LOCAL));

                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL) != 0);

                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL));

      cfgAddBool(pCfg, "crashReporting", tsEnableCrashReport, CFG_SCOPE_BOTH, CFG_DYN_BOTH, CFG_CATEGORY_GLOBAL));

                                CFG_SCOPE_CLIENT, CFG_DYN_NONE, CFG_CATEGORY_LOCAL));

                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

                                CFG_CATEGORY_GLOBAL));

                                CFG_CATEGORY_GLOBAL));

                                CFG_CATEGORY_GLOBAL));

                                CFG_CATEGORY_GLOBAL));

      cfgAddInt32(pCfg, "bypassFlag", tsBypassFlag, 0, INT32_MAX, CFG_SCOPE_BOTH, CFG_DYN_BOTH, CFG_CATEGORY_LOCAL));

                                CFG_CATEGORY_LOCAL));

                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_LOCAL));

                                CFG_CATEGORY_GLOBAL));

                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL));

                                CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL));

                                CFG_DYN_CLIENT_LAZY, CFG_CATEGORY_LOCAL));

      cfgAddBool(pCfg, "experimental", tsExperimental, CFG_SCOPE_BOTH, CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL));

                               CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

                                CFG_DYN_BOTH, CFG_CATEGORY_LOCAL));

                                CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

                                CFG_SCOPE_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

      cfgAddBool(pCfg, "streamCoverage", tsStreamCoverage, CFG_DYN_CLIENT, CFG_DYN_CLIENT, CFG_CATEGORY_LOCAL));

}

      cfgAddBool(pCfg, "enableCoreFile", tsEnableCoreFile, CFG_SCOPE_BOTH, CFG_DYN_BOTH_LAZY, CFG_CATEGORY_GLOBAL));

      cfgAddFloat(pCfg, "numOfCores", tsNumOfCores, 1, 100000, CFG_SCOPE_BOTH, CFG_DYN_BOTH_LAZY, CFG_CATEGORY_LOCAL));

      cfgAddBool(pCfg, "tagFilterCache", tsTagFilterCache, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL));

      cfgAddInt64(pCfg, "openMax", tsOpenMax, 0, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL));

#if !defined(_ALPINE)

      cfgAddInt64(pCfg, "streamMax", tsStreamMax, 0, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL));

#endif

      cfgAddInt32(pCfg, "pageSizeKB", tsPageSizeKB, 0, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_NONE, CFG_CATEGORY_LOCAL));

                                CFG_CATEGORY_LOCAL));

                                 CFG_CATEGORY_LOCAL));

}

                                TSDB_MAX_MSG_SIZE * QUEUE_MEMORY_USAGE_RATIO * 10000LL);

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

  // clang-format off