config

type ColumnSelector struct {
	Matcher []string `toml:"matcher" json:"matcher"`
	Columns []string `toml:"columns" json:"columns"`
}

type ConsistentConfig struct {
	Level             string `toml:"level" json:"level"`
	MaxLogSize        int64  `toml:"max-log-size" json:"max-log-size"`
	FlushIntervalInMs int64  `toml:"flush-interval" json:"flush-interval"`
	Storage           string `toml:"storage" json:"storage"`
}

type CyclicConfig struct {
	Enable          bool     `toml:"enable" json:"enable"`
	ReplicaID       uint64   `toml:"replica-id" json:"replica-id"`
	FilterReplicaID []uint64 `toml:"filter-replica-ids" json:"filter-replica-ids"`
	IDBuckets       int      `toml:"id-buckets" json:"id-buckets"`
	SyncDDL         bool     `toml:"sync-ddl" json:"sync-ddl"`
}

type DBConfig struct {
	// Count is the number of leveldb count.
	//
	// The default value is 16.
	Count int `toml:"count" json:"count"`
	// Concurrency is the maximum write and read concurrency.
	//
	// The default value is 256.
	Concurrency int `toml:"concurrency" json:"concurrency"`
	// MaxOpenFiles is the maximum number of open FD by leveldb sorter.
	//
	// The default value is 10000.
	MaxOpenFiles int `toml:"max-open-files" json:"max-open-files"`
	// BlockSize the block size of leveldb sorter.
	//
	// The default value is 65536, 64KB.
	BlockSize int `toml:"block-size" json:"block-size"`
	// BlockCacheSize is the capacity of leveldb block cache.
	//
	// The default value is 4294967296, 4GB.
	BlockCacheSize int `toml:"block-cache-size" json:"block-cache-size"`
	// WriterBufferSize is the size of memory table of leveldb.
	//
	// The default value is 8388608, 8MB.
	WriterBufferSize int `toml:"writer-buffer-size" json:"writer-buffer-size"`
	// Compression is the compression algorithm that is used by leveldb.
	// Valid values are "none" or "snappy".
	//
	// The default value is "snappy".
	Compression string `toml:"compression" json:"compression"`
	// TargetFileSizeBase limits size of leveldb sst file that compaction generates.
	//
	// The default value is 8388608, 8MB.
	TargetFileSizeBase int `toml:"target-file-size-base" json:"target-file-size-base"`
	// WriteL0SlowdownTrigger defines number of leveldb sst file at level-0 that
	// will trigger write slowdown.
	//
	// The default value is 1<<31 - 1.
	WriteL0SlowdownTrigger int `toml:"write-l0-slowdown-trigger" json:"write-l0-slowdown-trigger"`
	// WriteL0PauseTrigger defines number of leveldb sst file at level-0 that will
	// pause write.
	//
	// The default value is 1<<31 - 1.
	WriteL0PauseTrigger int `toml:"write-l0-pause-trigger" json:"write-l0-pause-trigger"`

	// CompactionL0Trigger defines number of leveldb sst file at level-0 that will
	// trigger compaction.
	//
	// The default value is 160.
	CompactionL0Trigger int `toml:"compaction-l0-trigger" json:"compaction-l0-trigger"`
	// CompactionDeletionThreshold defines the threshold of the number of deletion that
	// trigger compaction.
	//
	// The default value is 160000.
	// Iterator.First() takes about 27ms to 149ms in this case,
	// see pkg/db.BenchmarkNext.
	CompactionDeletionThreshold int `toml:"compaction-deletion-threshold" json:"compaction-deletion-threshold"`

	// IteratorMaxAliveDuration the maximum iterator alive duration in ms.
	//
	// The default value is 10000, 10s
	IteratorMaxAliveDuration int `toml:"iterator-max-alive-duration" json:"iterator-max-alive-duration"`

	// IteratorSlowReadDuration is the iterator slow read threshold.
	// A reading that exceeds the duration triggers a db compaction.
	//
	// The default value is 256, 256ms.
	IteratorSlowReadDuration int `toml:"iterator-slow-read-duration" json:"iterator-slow-read-duration"`

	// CleanupSpeedLimit limits clean up speed, based on key value entry count.
	//
	// The default value is 10000.
	CleanupSpeedLimit int `toml:"cleanup-speed-limit" json:"cleanup-speed-limit"`
}

type DebugConfig struct {
	// identify if the keyspan actor is enabled for keyspan pipeline
	// TODO: turn on after GA.
	EnableKeySpanActor bool `toml:"enable-keyspan-actor" json:"enable-keyspan-actor"`

	// EnableDBSorter enables db sorter.
	//
	// The default value is false.
	// TODO: turn on after GA.
	EnableDBSorter bool      `toml:"enable-db-sorter" json:"enable-db-sorter"`
	DB             *DBConfig `toml:"db" json:"db"`
}

type DispatchRule struct {
	Matcher    []string `toml:"matcher" json:"matcher"`
	Dispatcher string   `toml:"dispatcher" json:"dispatcher"`
}

type KVClientConfig struct {
	// how many workers will be used for a single region worker
	WorkerConcurrent int `toml:"worker-concurrent" json:"worker-concurrent"`
	// background workerpool size, the workrpool is shared by all goroutines in cdc server
	WorkerPoolSize int `toml:"worker-pool-size" json:"worker-pool-size"`
	// region incremental scan limit for one table in a single store
	RegionScanLimit int `toml:"region-scan-limit" json:"region-scan-limit"`
	// the safe interval to move backward resolved ts
	ResolvedTsSafeInterval time.Duration `toml:"resolved-ts-safe-interval" json:"resolved-ts-safe-interval"`
}

type LogConfig struct {
	File              *LogFileConfig `toml:"file" json:"file"`
	InternalErrOutput string         `toml:"error-output" json:"error-output"`
}

type LogFileConfig struct {
	MaxSize    int `toml:"max-size" json:"max-size"`
	MaxDays    int `toml:"max-days" json:"max-days"`
	MaxBackups int `toml:"max-backups" json:"max-backups"`
}

type Protocol int

type ReplicaConfig replicaConfig

type SchedulerConfig struct {
	Tp string `toml:"type" json:"type"`
	// PollingTime represents the polling cycle of checking the skewness of workload and try to do schedule if needed
	PollingTime int `toml:"polling-time" json:"polling-time"`
}

type SecurityConfig = security.Credential

type ServerConfig struct {
	Addr          string `toml:"addr" json:"addr"`
	AdvertiseAddr string `toml:"advertise-addr" json:"advertise-addr"`

	LogFile  string     `toml:"log-file" json:"log-file"`
	LogLevel string     `toml:"log-level" json:"log-level"`
	Log      *LogConfig `toml:"log" json:"log"`

	DataDir string `toml:"data-dir" json:"data-dir"`

	GcTTL int64  `toml:"gc-ttl" json:"gc-ttl"`
	TZ    string `toml:"tz" json:"tz"`

	CaptureSessionTTL int `toml:"capture-session-ttl" json:"capture-session-ttl"`

	OwnerFlushInterval     TomlDuration `toml:"owner-flush-interval" json:"owner-flush-interval"`
	ProcessorFlushInterval TomlDuration `toml:"processor-flush-interval" json:"processor-flush-interval"`

	Sorter                   *SorterConfig   `toml:"sorter" json:"sorter"`
	Security                 *SecurityConfig `toml:"security" json:"security"`
	PerChangefeedMemoryQuota uint64          `toml:"per-changefeed-memory-quota" json:"per-changefeed-memory-quota"`
	KVClient                 *KVClientConfig `toml:"kv-client" json:"kv-client"`
	Debug                    *DebugConfig    `toml:"debug" json:"debug"`
}

type SinkConfig struct {
	DispatchRules   []*DispatchRule   `toml:"dispatchers" json:"dispatchers"`
	Protocol        string            `toml:"protocol" json:"protocol"`
	ColumnSelectors []*ColumnSelector `toml:"column-selectors" json:"column-selectors"`
}

type SorterConfig struct {
	// number of concurrent heap sorts
	NumConcurrentWorker int `toml:"num-concurrent-worker" json:"num-concurrent-worker"`
	// maximum size for a heap
	ChunkSizeLimit uint64 `toml:"chunk-size-limit" json:"chunk-size-limit"`
	// the maximum memory use percentage that allows in-memory sorting
	MaxMemoryPressure int `toml:"max-memory-percentage" json:"max-memory-percentage"`
	// the maximum memory consumption allowed for in-memory sorting
	MaxMemoryConsumption uint64 `toml:"max-memory-consumption" json:"max-memory-consumption"`
	// the size of workerpool
	NumWorkerPoolGoroutine int `toml:"num-workerpool-goroutine" json:"num-workerpool-goroutine"`
	// the directory used to store the temporary files generated by the sorter
	SortDir string `toml:"sort-dir" json:"sort-dir"`
}

type TomlDuration time.Duration