config

type App string

type Castor struct {
	Enabled             bool       `toml:"enabled"`
	PyWorkerAddr        []string   `toml:"pyworker-addr"`
	ConnPoolSize        int        `toml:"connect-pool-size"`
	ResultWaitTimeout   int        `toml:"result-wait-timeout"`
	FitDetect           algoConfig `toml:"fit_detect"`
	Detect              algoConfig `toml:"detect"`
	Predict             algoConfig `toml:"predict"`
	Fit                 algoConfig `toml:"fit"`
	TracingEnabled      bool       `toml:"tracing-enabled"`
	TracingEndpoint     string     `toml:"tracing-endpoint"`
	TracingHttpsEnabled bool       `toml:"tracing-https-enabled"`
	TracingRatio        float64    `toml:"tracing-ratio"`
	TracingStorePath    string     `toml:"tracing-store-path"`
}

type CertValidator struct {
	// contains filtered or unexported fields
}

type ClvConfig struct {
	QMax      int    `toml:"q-max"`
	Threshold int    `toml:"token-threshold"`
	DocCount  uint32 `toml:"document-count"`
	Enabled   bool   `toml:"enabled"`
}

type ColumnStore struct {
	MergesetEnabled bool `toml:"mergeset-enabled"`
	CompactEnabled  bool `toml:"compact-enabled"`
}

type Common struct {
	MetaJoin     []string `toml:"meta-join"`
	CryptoConfig string   `toml:"crypto-config"`
	ClusterID    string   `toml:"cluster-id"`
	CPUNum       int      `toml:"cpu-num"`

	ReaderStop     bool `toml:"read-stop"`
	WriterStop     bool `toml:"write-stop"`
	IgnoreEmptyTag bool `toml:"ignore-empty-tag"`
	ReportEnable   bool `toml:"report-enable"`
	PreAggEnabled  bool `toml:"pre-agg-enabled"`
	PprofEnabled   bool `toml:"pprof-enabled"`

	MemorySize         itoml.Size     `toml:"memory-size"`
	MemoryLimitSize    itoml.Size     `toml:"executor-memory-size-limit"`
	MemoryWaitTime     itoml.Duration `toml:"executor-memory-wait-time"`
	OptHashAlgo        string         `toml:"select-hash-algorithm"`
	CpuAllocationRatio int            `toml:"cpu-allocation-ratio"`
	HaPolicy           string         `toml:"ha-policy"`
	NodeRole           string         `toml:"node-role"`
	ProductType        string         `toml:"product-type"`
	PprofBindAddress   string         `toml:"pprof-bind-address"`
	StorePprofPort     string         `toml:"store-pprof-port"`
	SqlPprofPort       string         `toml:"sql-pprof-port"`
	MetaPprofPort      string         `toml:"meta-pprof-port"`

	Bindjoin        []string `toml:"bind-join"`
	GlobalDictFiles []string `toml:"global-dict-files"`

	MetaConnRetryTime   itoml.Duration `toml:"meta-conn-retry-time"`
	MetaConnRetryNumber int            `toml:"meta-conn-retry-number"`
}

type Compact struct {
	CompactFullWriteColdDuration toml.Duration `toml:"compact-full-write-cold-duration"`
	MaxConcurrentCompactions     int           `toml:"max-concurrent-compactions"`
	MaxFullCompactions           int           `toml:"max-full-compactions"`
	CompactThroughput            toml.Size     `toml:"compact-throughput"`
	CompactThroughputBurst       toml.Size     `toml:"compact-throughput-burst"`
	SnapshotThroughput           toml.Size     `toml:"snapshot-throughput"`
	SnapshotThroughputBurst      toml.Size     `toml:"snapshot-throughput-burst"`
	BackGroundReadThroughput     toml.Size     `toml:"back-ground-read-throughput"`
	CompactionMethod             int           `toml:"compaction-method"` // 0:auto, 1: streaming, 2: non-streaming
	MaxCompactionLevel           int           `toml:"max-compaction-level"`

	CompactRecovery     bool `toml:"compact-recovery"`
	CsCompactionEnabled bool `toml:"column-store-compact-enabled"`
	CorrectTimeDisorder bool `toml:"correct-time-disorder"`
}

type CompactionType int32

type Comparable interface {
	int | float64
}

type Config interface {
	ApplyEnvOverrides(func(string) string) error
	Validate() error
	GetLogging() *Logger
	GetSpdy() *Spdy
	GetCommon() *Common
	ShowConfigs() map[string]interface{}
	GetLogStoreConfig() *LogStoreConfig
}

type Consume struct {
	ConsumeEnable      bool      `toml:"consume-enabled"`
	ConsumeHost        string    `toml:"consume-host"`
	ConsumePort        uint32    `toml:"consume-port"`
	ConsumeMaxReadSize toml.Size `toml:"consume-max-read-size"`
}

type ContinuousQueryConfig struct {
	// If this flag is set to false, both the brokers and data nodes should ignore any CQ processing.
	Enabled bool `toml:"enabled"`

	// The interval at which the CQ service will run.
	RunInterval toml.Duration `toml:"run-interval"`

	// MaxProcessCQNumber is the max number of CQs to process in one run.
	MaxProcessCQNumber int `toml:"max-process-CQ-number"`
}

type Coordinator struct {
	WriteTimeout         toml.Duration `toml:"write-timeout"`
	MaxConcurrentQueries int           `toml:"max-concurrent-queries"`
	QueryTimeout         toml.Duration `toml:"query-timeout"`
	LogQueriesAfter      toml.Duration `toml:"log-queries-after"`
	ShardWriterTimeout   toml.Duration `toml:"shard-writer-timeout"`
	ShardMapperTimeout   toml.Duration `toml:"shard-mapper-timeout"`
	// Maximum number of memory bytes to use from the query
	MaxQueryMem              toml.Size       `toml:"max-query-mem"`
	MetaExecutorWriteTimeout toml.Duration   `toml:"meta-executor-write-timeout"`
	QueryLimitIntervalTime   int             `toml:"query-limit-interval-time"`
	QueryLimitLevel          int             `toml:"query-limit-level"`
	RetentionPolicyLimit     int             `toml:"rp-limit"`
	DatabaseNumLimit         int32           `toml:"db-limit"`
	ShardTier                string          `toml:"shard-tier"`
	TimeRangeLimit           []toml.Duration `toml:"time-range-limit"`
	MeasurementBlacklist     []string        `toml:"measurement-blacklist"`

	// Maximum number of tag keys in a measurement
	TagLimit   int `toml:"tag-limit"`
	FieldLimit int `toml:"field-limit"`

	QueryLimitFlag          bool `toml:"query-limit-flag"`
	QueryTimeCompareEnabled bool `toml:"query-time-compare-enabled"`
	ForceBroadcastQuery     bool `toml:"force-broadcast-query"`

	HardWrite bool `toml:"hard-write"`
}

type EngineType uint8

type Fence struct {
	FenceFilePath string `toml:"fence-file-path"`
	FenceEnable   bool   `toml:"fence-enable"`
}

type Gossip struct {
	Enabled       bool          `toml:"enabled"`
	LogEnabled    bool          `toml:"log-enabled"`
	BindAddr      string        `toml:"bind-address"`
	MetaBindPort  int           `toml:"meta-bind-port"`
	StoreBindPort int           `toml:"store-bind-port"`
	SqlBindPort   int           `toml:"sql-bind-port"`
	ProbInterval  toml.Duration `toml:"prob-interval"`
	SuspicionMult int           `toml:"suspicion-mult"`
	Members       []string      `toml:"members"`
}

type HAPolicy uint8

type HierarchicalConfig struct {
	// If false, close hierarchical storage service
	Enabled bool `toml:"enabled"`

	// If false, close index hierarchical storage service
	IndexEnabled bool `toml:"index-enabled"`

	// Interval time for checking hierarchical storage.
	RunInterval toml.Duration `toml:"run-interval"`

	// Interval time for checking index hierarchical storage.
	IndexRunInterval toml.Duration `toml:"index-run-interval"`

	// Max process number for shard moving
	MaxProcessN int `toml:"max-process-hs-number"`

	EnableWriteColdShard bool `toml:"enable-write-cold-shard"`
}

type HotMode struct {
	Enabled              bool          `toml:"enabled"`
	ShelfOnly            bool          `toml:"shelf-only"`
	MemoryAllowedPercent uint8         `toml:"memory-allowed-percent"`
	Duration             toml.Duration `toml:"duration"`
	TimeWindow           toml.Duration `toml:"time-window"`
	MaxFileSize          toml.Size     `toml:"max-file-size"`
	PoolObjectCnt        int           `toml:"pool-object-cnt"`
	MaxCacheSize         toml.Size     `toml:"max-cache-size"`
}

type Index struct {
	TSIDCacheSize          int `toml:"tsid-cache-size"`
	SKeyCacheSize          int `toml:"skey-cache-size"`
	TagCacheSize           int `toml:"tag-cache-size"`
	TagFilterCostCacheSize int `toml:"tag-filter-cost-cache-size"`
	Concurrency            int `toml:"concurrency"`

	TagScanPruneThreshold int           `toml:"tag-scan-prune-threshold"`
	MemoryAllowedPercent  int           `toml:"memory-allowed-percent"`
	CacheExpireDuration   toml.Duration `toml:"cache-expire-duration"`

	CacheCompressEnable bool `toml:"cache-compress-enable"`
	BloomFilterEnabled  bool `toml:"bloom-filter-enable"`
}

type LastRowCacheConfig struct {
	CacheEnabled bool `toml:"enabled"`

	NumCounters int64 `toml:"number-counters"`
	MaxCost     int64 `toml:"max-cost"`
	BufferItems int64 `toml:"buffer-items"`
	Metrics     bool  `toml:"metrics"`
}

type Limits struct {
	PromLimitEnabled bool `toml:"prom-limit-enabled" yaml:"prom_limit_enabled"`

	// prom metrics write limits
	MaxLabelNameLength        int            `toml:"max-label-name-length" yaml:"max_label_name_length"`
	MaxLabelValueLength       int            `toml:"max-label-value-length" yaml:"max_label_value_length"`
	MaxLabelNamesPerSeries    int            `toml:"max-label-names-per-series" yaml:"max_label_names_per_series"`
	MaxMetadataLength         int            `toml:"max-metadata-length" yaml:"max_metadata_length"`
	RejectOldSamples          bool           `toml:"reject-old-samples" yaml:"reject_old_samples"`
	RejectOldSamplesMaxAge    model.Duration `toml:"reject-old-samples-max-age" yaml:"reject_old_samples_max_age"`
	CreationGracePeriod       model.Duration `toml:"creation-grace-period" yaml:"creation_grace_period"`
	EnforceMetadataMetricName bool           `toml:"enforce-metadata-metric-name" yaml:"enforce_metadata_metric_name"`
	EnforceMetricName         bool           `toml:"enforce-metric-name" yaml:"enforce_metric_name"`
	// query limits
	MaxQueryLength model.Duration `toml:"max-query-length" yaml:"max_query_length"`
}

type LogStoreConfig struct {
	MemorySize   uint64
	CacheEnabled bool          `toml:"cache-segment-metadata"`
	CacheRate    float32       `toml:"cache-segment-metadata-memory-rate"`
	CacheTTL     toml.Duration `toml:"cache-segment-metadata-ttl"`

	VlmCacheHotData       bool          `toml:"vlm-cache-hotdata"`
	VlmCachePiecePrefetch bool          `toml:"vlm-cache-piece-prefetch"`
	VlmCachePieceSize     uint32        `toml:"vlm-cache-piece-size"`
	VlmCacheGroupPrefetch bool          `toml:"vlm-cache-group-prefetch"`
	VlmCacheGroupSize     uint32        `toml:"vlm-cache-group-size"`
	VlmCachePrefetchNum   uint32        `toml:"vlm-cache-prefetch-shard-num"`
	VlmCacheTtl           toml.Duration `toml:"vlm-cache-ttl"`
	ContainerBasePath     string        `toml:"container-base-path"`
}

type Logger struct {
	Format          string        `toml:"format"`
	Level           zapcore.Level `toml:"level"`
	MaxSize         toml.Size     `toml:"max-size"`
	MaxNum          int           `toml:"max-num"`
	MaxAge          int           `toml:"max-age"`
	CompressEnabled bool          `toml:"compress-enabled"`
	Path            string        `toml:"path"`
	// contains filtered or unexported fields
}

type MemTable struct {
	WriteColdDuration      toml.Duration `toml:"write-cold-duration"`
	ForceSnapShotDuration  toml.Duration `toml:"force-snapShot-duration"`
	ShardMutableSizeLimit  toml.Size     `toml:"shard-mutable-size-limit"`
	NodeMutableSizeLimit   toml.Size     `toml:"node-mutable-size-limit"`
	MaxWriteHangTime       toml.Duration `toml:"max-write-hang-time"`
	MemDataReadEnabled     bool          `toml:"mem-data-read-enabled"`
	CsDetachedFlushEnabled bool          `toml:"column-store-detached-flush-enabled"`
	SnapshotTblNum         int           `toml:"snapshot-table-number"`
	FragmentsNumPerFlush   int           `toml:"fragments-num-per-flush"`
}

type Merge struct {
	// merge only unordered data
	MergeSelfOnly bool `toml:"merge-self-only"`

	// The total size of unordered files to be merged each time cannot exceed MaxUnorderedFileSize
	MaxUnorderedFileSize toml.Size `toml:"max-unordered-file-size"`
	// The number of unordered files to be merged each time cannot exceed MaxUnorderedFileNumber
	MaxUnorderedFileNumber int `toml:"max-unordered-file-number"`

	MaxMergeSelfLevel uint16 `toml:"max-merge-self-level"`

	MinInterval toml.Duration `toml:"min-interval"`

	StreamMergeModeLevel int `toml:"stream-merge-mode-level"`
}

type Meta struct {
	HTTPSEnabled        bool `toml:"https-enabled"`
	RetentionAutoCreate bool `toml:"retention-autocreate"`
	ClusterTracing      bool `toml:"cluster-tracing"`
	LoggingEnabled      bool `toml:"logging-enabled"`
	BatchApplyCh        bool `toml:"batch-enabled"`
	TakeOverEnable      bool `toml:"takeover-enable"`
	ExpandShardsEnable  bool `toml:"expand-shards-enable"`
	PingFailedNode      bool `toml:"ping-failed-node"`
	RepairPT            bool `toml:"repair-pt"`

	DataDir                 string
	WalDir                  string
	Domain                  string  `toml:"domain"`
	Dir                     string  `toml:"dir"`
	HTTPBindAddress         string  `toml:"http-bind-address"`
	RPCBindAddress          string  `toml:"rpc-bind-address"`
	BindAddress             string  `toml:"bind-address"`
	AuthEnabled             bool    `toml:"auth-enabled"`
	HTTPSCertificate        string  `toml:"https-certificate"`
	HTTPSPrivateKey         string  `toml:"https-private-key"`
	HTTPSClientCertificate  string  `toml:"https-client-certificate"`
	MaxConcurrentWriteLimit int     `toml:"-"`
	Version                 int     `toml:"meta-version"`
	Hostname                string  `toml:"hostname"`
	SplitRowThreshold       uint64  `toml:"split-row-threshold"`
	ImbalanceFactor         float64 `toml:"imbalance-factor"`
	RemoteHostname          string

	JoinPeers          []string
	ElectionTimeout    toml.Duration `toml:"election-timeout"`
	HeartbeatTimeout   toml.Duration `toml:"heartbeat-timeout"`
	LeaderLeaseTimeout toml.Duration `toml:"leader-lease-timeout"`
	CommitTimeout      toml.Duration `toml:"commit-timeout"`
	LeaseDuration      toml.Duration `toml:"lease-duration"`
	Logging            Logger        `toml:"logging"`

	PtNumPerNode uint32 `toml:"ptnum-pernode"`
	BalanceAlgo  string `toml:"balance-algorithm-version"`

	// Number of shards for each measurement in a shard group
	NumOfShards                         int32 `toml:"num-of-shards"`
	UseIncSyncData                      bool  `toml:"inc-sync-data"`
	SQLiteEnabled                       bool  `toml:"sqlite-enabled"`
	RepDisPolicy                        uint8 `toml:"rep-dis-policy"`
	SchemaCleanEn                       bool  `toml:"schema-clean-enable"`
	AsyncSchemaEndtimeUpdateEn          bool  `toml:"async-schema-endtime-update-enable"`
	AsyncSchemaEndtimeUpdateCache       int   `toml:"async-schema-endtime-update-cache"`
	AsyncSchemaEndtimeUpdateConcurrency int   `toml:"async-schema-endtime-update-concurrency"`

	MetaEventHandleEn bool `toml:"meta-event-handle-enable"`
	BindPeers         []string

	ReplicaColdSelectEnable   bool          `toml:"replica_cold_select_enable"`
	ReplicaColdSelectInterval toml.Duration `toml:"replica_cold_select_interval"`
	MetaRecover               bool          `toml:"meta_recover_enable"`
	ShardGroupTimeZone        string        `toml:"shard-group-time-zone"`
}

type Monitor struct {
	Pushers       string        `toml:"pushers"`
	StoreEnabled  bool          `toml:"store-enabled"`
	StoreDatabase string        `toml:"store-database"`
	StoreInterval toml.Duration `toml:"store-interval"`
	StorePath     string        `toml:"store-path"`
	Compress      bool          `toml:"compress"`
	HttpsEnabled  bool          `toml:"https-enabled"`
	HttpEndPoint  string        `toml:"http-endpoint"`
	Username      string        `toml:"username"`
	Password      string        `toml:"password"`
	// contains filtered or unexported fields
}

type MonitorMain struct {
	Host         string `toml:"host"`
	MetricPath   string `toml:"metric-path"`
	ErrLogPath   string `toml:"error-log-path"`
	Process      string `toml:"process"`
	DiskPath     string `toml:"disk-path"`
	AuxDiskPath  string `toml:"aux-disk-path"`
	History      string `toml:"history-file"`
	Compress     bool   `toml:"compress"`
	HttpEndpoint string `toml:"http-endpoint"`
	LockFilePath string `toml:"lock-file-path"`
}

type MonitorQuery struct {
	QueryEnable   bool          `toml:"query-enable"`
	HttpEndpoint  string        `toml:"http-endpoint"`
	QueryInterval toml.Duration `toml:"query-interval"`
	Username      string        `toml:"username"`
	Password      string        `toml:"password"`
	HTTPSEnabled  bool          `toml:"https-enable"`
}

type MonitorReport struct {
	Address      string        `toml:"address"`
	Database     string        `toml:"database"`
	Rp           string        `toml:"rp"`
	RpDuration   toml.Duration `toml:"rp-duration"`
	Username     string        `toml:"username"`
	Password     string        `toml:"password"`
	HTTPSEnabled bool          `toml:"https-enable"`
	ReplicaN     int           `toml:"replicaN"`
}

type Obs struct {
	QueenSize     int `toml:"queen-size"`
	WalBufferSize int `toml:"wal-buffer-size"`
}

type OpsMonitor struct {
	HttpAddress      string `toml:"store-http-addr"`
	AuthEnabled      bool   `toml:"auth-enabled"`
	HttpsEnabled     bool   `toml:"store-https-enabled"`
	HttpsCertificate string `toml:"store-https-certificate"`
}

type ParquetTaskConfig struct {
	Enabled bool `toml:"enabled"`

	// the level of the TSSP file to be converted to a Parquet. 0: not convert
	TSSPToParquetLevel uint16 `toml:"tssp-to-parquet-level"`

	// group length of parquet file
	MaxRowGroupLen int `toml:"max-group-len"`

	// Page size of parquet file
	PageSize int `toml:"page-size"`

	// parquet writer batch size
	WriteBatchSize int `toml:"write-batch-size"`

	ItrBatchSize uint64 `toml:"itr-batch-size"`

	DictCompressEnable uint64 `toml:"dict-compress-enable"`

	CompressAlg uint64   `toml:"compress-alg"`
	EnableMst   []string `toml:"enable-mst"`

	MaxStatsSize int64 `toml:"max-stats-size"`

	OutputDir         string `toml:"output-dir"`
	ReliabilityLogDir string `toml:"reliability-log-dir"`
	// contains filtered or unexported fields
}

type ProductType uint8

type RaftStorage struct {
	RaftEntrySyncInterval toml.Duration `toml:"raft-entry-sync-interval"`
}

type ReadCache struct {
	ReadPageSize       string    `toml:"read-page-size"`
	ReadMetaPageSize   []string  `toml:"read-meta-page-size"`
	ReadMetaCacheEn    toml.Size `toml:"enable-meta-cache"`
	ReadMetaCacheEnPct toml.Size `toml:"read-meta-cache-limit-pct"`
	ReadDataCacheEn    toml.Size `toml:"enable-data-cache"`
	ReadDataCacheEnPct toml.Size `toml:"read-data-cache-limit-pct"`
}

type RecordWriteConfig struct {
	Enabled        bool      `toml:"enabled"`
	AuthEnabled    bool      `toml:"auth-enabled"`
	ShelfMode      bool      `toml:"shelf-mode"`
	TLS            tlsConfig `toml:"TLS"`
	RPCAddress     string    `toml:"rpc-address"`
	MaxRecvMsgSize int       `toml:"max-message-size"`
}

type RuntimeConfig struct {
	Enabled bool `toml:"enabled"`
	// How often to check runtime config file.
	ReloadPeriod toml.Duration `toml:"reload-period"`
	// LoadPath contains the path to the runtime config file;set empty if runtimecfg is not required.
	LoadPath string `toml:"load-path"`
}

type SFS struct {
	DataDir string `toml:"store-data-dir"`
}

type SelectSpecConfig struct {
	EnableWhenExceed bool `toml:"enable-query-when-exceed"`
	QuerySeriesLimit int  `toml:"query-series-limit"`
	QuerySchemaLimit int  `toml:"query-schema-limit"`
}

type ShardMergeConfig struct {
	// If false, close shard merge service
	Enabled bool `toml:"enabled"`

	// Interval time for checking merge shard
	RunInterval toml.Duration `toml:"run-interval"`
}

type ShelfMode struct {
	Enabled bool `toml:"enabled"`

	// Reliability requirements for data writing
	// 1: Low reliability. Data may be lost due to process faults.
	// 2: Medium reliability. Data may be lost due to container or VM faults. (default)
	// 3: High reliability. Data may be lost when a storage medium is faulty.
	ReliabilityLevel int           `toml:"reliability-level"`
	MaxWalFileSize   toml.Size     `toml:"max-wal-file-size"`
	MaxWalDuration   toml.Duration `toml:"max-wal-duration"`

	// WAL data compression mode. 0: not compressed; 1: LZ4 (default); 2: Snappy
	WalCompressMode int `toml:"wal-compress-mode"`

	// number of background write threads. default value is CPUNum
	Concurrent int `toml:"concurrent"`

	// Limit the number of WAL files (waiting to be converted + being converted + being written)
	// to prevent disk space from being fully occupied, which could cause node failure.
	// It is not a strict constraint; the actual number may exceed this limit.
	// Default value is concurrent*8
	MaxNumOfWal int `toml:"max-num-of-wal"`

	// by default, the table is grouped based on the hash value of the measurement name
	// If this parameter is set to a value greater than 1,
	// secondary grouping is performed based on the hash value of the series key
	SeriesHashFactor int `toml:"series-hash-factor"`

	// max number of concurrent WAL files to be converted to SSP files.
	// default value is the same as Concurrent
	TSSPConvertConcurrent int `toml:"tssp-convert-concurrent"`

	// max number of concurrent conversions from a single WAL file to TSSP file
	// default value is max(1, TSSPConvertConcurrent/4)
	OneTSSPConvertConcurrent int `toml:"one-tssp-convert-concurrent"`

	// Compress the series key in memory to save memory and reduce the risk of OOM
	// When the memory used by the series key exceeds this value, compression is enabled.
	// 0 means never compress
	SeriesKeyCompressThreshold toml.Size `toml:"series-key-compress-threshold"`
}

type SherlockConfig struct {
	SherlockEnable  bool          `toml:"sherlock-enable"`
	CollectInterval toml.Duration `toml:"collect-interval"`
	CPUMaxPercent   toml.Size     `toml:"cpu-max-percent"`
	DumpPath        string        `toml:"dump-path"`
	MaxNum          int           `toml:"max-num"`
	MaxAge          int           `toml:"max-age"`

	CPUConfig       typeConfig `toml:"cpu"`
	MemoryConfig    typeConfig `toml:"memory"`
	GoroutineConfig typeConfig `toml:"goroutine"`
}

type Spdy struct {
	ByteBufferPoolDefaultSize uint64

	RecvWindowSize          int `toml:"recv-window-size"`
	ConcurrentAcceptSession int `toml:"concurrent-accept-session"`
	ConnPoolSize            int `toml:"conn-pool-size"`

	OpenSessionTimeout   toml.Duration `toml:"open-session-timeout"`
	SessionSelectTimeout toml.Duration `toml:"session-select-timeout"`
	TCPDialTimeout       toml.Duration `toml:"tcp-dial-timeout"`
	DataAckTimeout       toml.Duration `toml:"data-ack-timeout"`

	CompressEnable        bool `toml:"compress-enable"`
	TLSEnable             bool `toml:"tls-enable"`
	TLSClientAuth         bool `toml:"tls-client-auth"`
	TLSInsecureSkipVerify bool `toml:"tls-insecure-skip-verify"`

	TLSCertificate       string `toml:"tls-certificate"`
	TLSPrivateKey        string `toml:"tls-private-key"`
	TLSClientCertificate string `toml:"tls-client-certificate"`
	TLSClientPrivateKey  string `toml:"tls-client-private-key"`
	TLSCARoot            string `toml:"tls-ca-root"`
	TLSServerName        string `toml:"tls-server-name"`
}

type Store struct {
	IngesterAddress string      `toml:"store-ingest-addr"`
	SelectAddress   string      `toml:"store-select-addr"`
	Domain          string      `toml:"domain"`
	TLS             *tls.Config `toml:"-"`
	DataDir         string      `toml:"store-data-dir"`
	WALDir          string      `toml:"store-wal-dir"`
	MetaDir         string      `toml:"store-meta-dir"`
	Engine          string      `toml:"engine-type"`
	Index           string      `toml:"index-version"`
	OpsMonitor      *OpsMonitor `toml:"ops-monitor"`

	// configs for compact
	Compact Compact `toml:"compact"`

	// configs for memTable
	MemTable MemTable `toml:"memtable"`

	// configs for wal
	Wal Wal `toml:"wal"`

	// configs for raftStorage
	RaftStorage RaftStorage `toml:"raft-storage"`

	// configs for readCache
	ReadCache ReadCache `toml:"readcache"`

	EnableMmapRead bool `toml:"enable-mmap-read"`
	Readonly       bool `toml:"readonly"`

	WriteConcurrentLimit int `toml:"write-concurrent-limit"`
	OpenShardLimit       int `toml:"open-shard-limit"`
	MaxSeriesPerDatabase int `toml:"max-series-per-database"`

	DownSampleWriteDrop          bool `toml:"downsample-write-drop"`
	ShardMoveLayoutSwitchEnabled bool `toml:"shard-move-layout-switch"`

	//parallelism allocator
	MaxWaitResourceTime          toml.Duration `toml:"max-wait-resource-time"`
	MaxSeriesParallelismNum      int           `toml:"max-series-parallelism-num"`
	MaxShardsParallelismNum      int           `toml:"max-shards-parallelism-num"`
	ChunkReaderThreshold         int           `toml:"chunk-reader-threshold"`
	MinChunkReaderConcurrency    int           `toml:"min-chunk-reader-concurrency"`
	MinShardsConcurrency         int           `toml:"min-shards-concurrency"`
	MaxDownSampleTaskConcurrency int           `toml:"max-downsample-task-concurrency"`

	// for query
	EnableQueryFileHandleCache bool   `toml:"enable_query_file_handle_cache"`
	MaxQueryCachedFileHandles  uint32 `toml:"max_query_cached_file_handles"`
	// config for lazy load shard
	LazyLoadShardEnable       bool          `toml:"lazy-load-shard-enable"`
	ThermalShardStartDuration toml.Duration `toml:"thermal-shard-start-duration"`
	ThermalShardEndDuration   toml.Duration `toml:"thermal-shard-end-duration"`

	// for auto interrupt query
	InterruptQuery       bool          `toml:"interrupt-query"`
	InterruptSqlMemPct   int           `toml:"interrupt-sql-mem-pct"`
	ProactiveMgrInterval toml.Duration `toml:"proactive-manager-interval"`

	TemporaryIndexCompressMode int    `toml:"temporary-index-compress-mode"`
	ChunkMetaCompressMode      int    `toml:"chunk-meta-compress-mode"`
	IndexReadCachePersistent   bool   `toml:"index-read-cache-persistent"`
	FloatCompressAlgorithm     string `toml:"float-compress-algorithm"`

	StringCompressAlgo string `toml:"string-compress-algo"`
	// Ordered data and unordered data are not distinguished. All data is processed as unordered data.
	UnorderedOnly bool `toml:"unordered-only"`

	Merge Merge `toml:"merge"`

	MaxRowsPerSegment int `toml:"max-rows-per-segment"`

	// in some scenarios, it is allowed to write past time but ordered data(for examle, some scenarios allow to write the past 14 days data in order)
	EnableWriteHistoryOrderedData bool `toml:"enable-write-history-ordered-data"`

	// for hierarchical storage
	SkipRegisterColdShard bool `toml:"skip-register-cold-shard"`

	AvailabilityZone string `toml:"availability-zone"`

	ClearEntryLogTolerateTime toml.Duration `toml:"clear-entryLog-tolerate-time"`

	ClearEntryLogTolerateSize toml.Size `toml:"clear-entryLog-tolerate-size"`

	ParquetTask *ParquetTaskConfig `toml:"parquet-task"`

	// configs for consume
	Consume Consume `toml:"consume"`
	Fence   Fence   `toml:"fence"`

	HotMode     HotMode     `toml:"hot-mode"`
	ColumnStore ColumnStore `toml:"column-store"`

	RaftMsgTimeout    toml.Duration `toml:"raft-msg-time-out"`
	ElectionTick      int           `toml:"election-tick"`
	HeartbeatTick     int           `toml:"heartbeat-tick"`
	RaftMsgCacheSize  int           `toml:"raft-msg-cache-size"`
	FileWrapSize      int           `toml:"file-wrap-size"`
	WaitCommitTimeout toml.Duration `toml:"wait-commit-time-out"`
	EnablePerlRegrep  bool          `toml:"enable-perl-regrep"`
	RetryPtCheckTime  int           `toml:"retry-pt-check-time"`
	EntryFileRWType   int           `toml:"entry-file-rw-type"`

	NagtPoolCap      int           `toml:"nagt-pool-cap"`
	DropSeriesPeriod toml.Duration `toml:"drop-series-period"`
}

type Subscriber struct {
	Enabled            bool          `toml:"enabled"`
	HTTPTimeout        toml.Duration `toml:"http-timeout"`
	InsecureSkipVerify bool          `toml:"insecure-skip-verify"`
	HttpsCertificate   string        `toml:"https-certificate"`
	WriteBufferSize    int           `toml:"write-buffer-size"`
	WriteConcurrency   int           `toml:"write-concurrency"`
}

type TSMeta struct {
	Common  *Common `toml:"common"`
	Meta    *Meta   `toml:"meta"`
	Data    Store   `toml:"data"`
	Logging Logger  `toml:"logging"`
	Monitor Monitor `toml:"monitor"`
	Gossip  *Gossip `toml:"gossip"`
	Spdy    Spdy    `toml:"spdy"`

	// TLS provides configuration options for all https endpoints.
	TLS tlsconfig.Config `toml:"tls"`

	Sherlock   *SherlockConfig    `toml:"sherlock"`
	IODetector *iodetector.Config `toml:"io-detector"`
}

type TSMonitor struct {
	MonitorConfig MonitorMain   `toml:"monitor"`
	QueryConfig   MonitorQuery  `toml:"query"`
	ReportConfig  MonitorReport `toml:"report"`
	Logging       Logger        `toml:"logging"`
}

type TSSql struct {
	Common      *Common     `toml:"common"`
	Meta        *Meta       `toml:"meta"`
	Coordinator Coordinator `toml:"coordinator"`
	Monitor     Monitor     `toml:"monitor"`
	Logging     Logger      `toml:"logging"`
	Gossip      *Gossip     `toml:"gossip"`
	Spdy        Spdy        `toml:"spdy"`

	HTTP httpdConfig.Config `toml:"http"`

	// TLS provides configuration options for all https endpoints.
	TLS        tlsconfig.Config `toml:"tls"`
	Analysis   Castor           `toml:"castor"`
	Sherlock   *SherlockConfig  `toml:"sherlock"`
	SelectSpec SelectSpecConfig `toml:"spec-limit"`

	Subscriber Subscriber `toml:"subscriber"`

	ContinuousQuery ContinuousQueryConfig `toml:"continuous_queries"`
	Data            Store                 `toml:"data"`
	ShelfMode       ShelfMode             `toml:"shelf-mode"`

	Limits        Limits            `toml:"limits"`
	RuntimeConfig RuntimeConfig     `toml:"runtime-config"`
	RecordWrite   RecordWriteConfig `toml:"record-write"`
	Topo          Topo              `toml:"topo"`
}

type TSStore struct {
	Common      *Common     `toml:"common"`
	Data        Store       `toml:"data"`
	Coordinator Coordinator `toml:"coordinator"`
	Monitor     Monitor     `toml:"monitor"`
	Logging     Logger      `toml:"logging"`
	Gossip      *Gossip     `toml:"gossip"`
	Spdy        Spdy        `toml:"spdy"`

	ShelfMode ShelfMode `toml:"shelf-mode"`

	HTTPD             httpdConf.Config   `toml:"http"`
	Retention         retention.Config   `toml:"retention"`
	DownSample        retention.Config   `toml:"downsample"`
	HierarchicalStore HierarchicalConfig `toml:"hierarchical_storage"`
	Stream            stream.Config      `toml:"stream"`

	// TLS provides configuration options for all https endpoints.
	TLS        tlsconfig.Config   `toml:"tls"`
	Analysis   Castor             `toml:"castor"`
	Sherlock   *SherlockConfig    `toml:"sherlock"`
	IODetector *iodetector.Config `toml:"io-detector"`

	Meta       *Meta            `toml:"meta"`
	ClvConfig  *ClvConfig       `toml:"clv_config"`
	SelectSpec SelectSpecConfig `toml:"spec-limit"`

	// index
	Index *Index `toml:"index"`

	// last row cache
	LastRowCache *LastRowCacheConfig `toml:"last_row_cache"`

	// logkeeper config
	LogStore *LogStoreConfig `toml:"logstore"`

	ShardMerge ShardMergeConfig `toml:"shardMerge_service"`

	ObsMode Obs `toml:"Obs"`
}

type Topo struct {
	TopoManagerUrl string `toml:"topo-manager-url"`
}

type TsRecover struct {
	Data Store `toml:"data"`
}

type Validator interface {
	Validate() error
}

type Wal struct {
	WalSyncInterval    toml.Duration `toml:"wal-sync-interval"`
	WalEnabled         bool          `toml:"wal-enabled"`
	WalReplayParallel  bool          `toml:"wal-replay-parallel"`
	WalReplayAsync     bool          `toml:"wal-replay-async"`
	WalUsedForStream   bool          `toml:"wal-used-for-stream"`
	WalReplayBatchSize toml.Size     `toml:"wal-replay-batch-size"`
}