config

Documentation

Index

• Constants
• func GetTxnScopeFromConfig() string
• func ParsePath(path string) (etcdAddrs []string, disableGC bool, err error)
• func StoreGlobalConfig(config *Config)
• func UpdateGlobal(f func(conf *Config)) func()
• type AsyncCommit
• type Config
  • func DefaultConfig() Config
  • func GetGlobalConfig() *Config
• type CoprocessorCache
• type PDClient
  • func DefaultPDClient() PDClient
• type PessimisticTxn
• type Security
  • func NewSecurity(sslCA, sslCert, sslKey string, verityCN []string) Security
  • func (s *Security) ToTLSConfig() (tlsConfig *tls.Config, err error)
• type TiKVClient
  • func DefaultTiKVClient() TiKVClient
  • func (config *TiKVClient) Valid() error
• type TxnLocalLatches
  • func DefaultTxnLocalLatches() TxnLocalLatches
  • func (c *TxnLocalLatches) Valid() error

Constants

const (
	// DefStoreLivenessTimeout is the default value for store liveness timeout.
	DefStoreLivenessTimeout = "1s"
)

const (
	// DefStoresRefreshInterval is the default value of StoresRefreshInterval
	DefStoresRefreshInterval = 60
)

Functions

func GetTxnScopeFromConfig

func GetTxnScopeFromConfig() string

GetTxnScopeFromConfig extracts @@txn_scope value from the config.

func ParsePath

func ParsePath(path string) (etcdAddrs []string, disableGC bool, err error)

ParsePath parses this path. Path example: tikv://etcd-node1:port,etcd-node2:port?cluster=1&disableGC=false

func StoreGlobalConfig

func StoreGlobalConfig(config *Config)

StoreGlobalConfig stores a new config to the globalConf. It mostly uses in the test to avoid some data races.

func UpdateGlobal

func UpdateGlobal(f func(conf *Config)) func()

UpdateGlobal updates the global config, and provide a restore function that can be used to restore to the original.

Types

type AsyncCommit

type AsyncCommit struct {
	// Use async commit only if the number of keys does not exceed KeysLimit.
	KeysLimit uint `toml:"keys-limit" json:"keys-limit"`
	// Use async commit only if the total size of keys does not exceed TotalKeySizeLimit.
	TotalKeySizeLimit uint64 `toml:"total-key-size-limit" json:"total-key-size-limit"`
	// The duration within which is safe for async commit or 1PC to commit with an old schema.
	// The following two fields should NOT be modified in most cases. If both async commit
	// and 1PC are disabled in the whole cluster, they can be set to zero to avoid waiting in DDLs.
	SafeWindow time.Duration `toml:"safe-window" json:"safe-window"`
	// The duration in addition to SafeWindow to make DDL safe.
	AllowedClockDrift time.Duration `toml:"allowed-clock-drift" json:"allowed-clock-drift"`
}

AsyncCommit is the config for the async commit feature. The switch to enable it is a system variable.

type Config

type Config struct {
	CommitterConcurrency int
	MaxTxnTTL            uint64
	TiKVClient           TiKVClient
	Security             Security
	PDClient             PDClient
	PessimisticTxn       PessimisticTxn
	TxnLocalLatches      TxnLocalLatches
	// StoresRefreshInterval indicates the interval of refreshing stores info, the unit is second.
	StoresRefreshInterval uint64
	OpenTracingEnable     bool
	Path                  string
	EnableForwarding      bool
	TxnScope              string
	EnableAsyncCommit     bool
	Enable1PC             bool
}

Config contains configuration options.

func DefaultConfig

func DefaultConfig() Config

DefaultConfig returns the default configuration.

func GetGlobalConfig

func GetGlobalConfig() *Config

GetGlobalConfig returns the global configuration for this server. It should store configuration from command line and configuration file. Other parts of the system can read the global configuration use this function.

type CoprocessorCache

type CoprocessorCache struct {
	// The capacity in MB of the cache. Zero means disable coprocessor cache.
	CapacityMB float64 `toml:"capacity-mb" json:"capacity-mb"`

	// Only cache requests that containing small number of ranges. May to be changed in future.
	AdmissionMaxRanges uint64 `toml:"admission-max-ranges" json:"-"`
	// Only cache requests whose result set is small.
	AdmissionMaxResultMB float64 `toml:"admission-max-result-mb" json:"-"`
	// Only cache requests takes notable time to process.
	AdmissionMinProcessMs uint64 `toml:"admission-min-process-ms" json:"-"`
}

CoprocessorCache is the config for coprocessor cache.

type PDClient

type PDClient struct {
	// PDServerTimeout is the max time which PD client will wait for the PD server in seconds.
	PDServerTimeout uint `toml:"pd-server-timeout" json:"pd-server-timeout"`
}

PDClient is the config for PD client.

func DefaultPDClient

func DefaultPDClient() PDClient

DefaultPDClient returns the default configuration for PDClient

type PessimisticTxn

type PessimisticTxn struct {
	// The max count of retry for a single statement in a pessimistic transaction.
	MaxRetryCount uint `toml:"max-retry-count" json:"max-retry-count"`
}

PessimisticTxn is the config for pessimistic transaction.

type Security

type Security struct {
	ClusterSSLCA    string   `toml:"cluster-ssl-ca" json:"cluster-ssl-ca"`
	ClusterSSLCert  string   `toml:"cluster-ssl-cert" json:"cluster-ssl-cert"`
	ClusterSSLKey   string   `toml:"cluster-ssl-key" json:"cluster-ssl-key"`
	ClusterVerifyCN []string `toml:"cluster-verify-cn" json:"cluster-verify-cn"`
}

Security is the security section of the config.

func NewSecurity

func NewSecurity(sslCA, sslCert, sslKey string, verityCN []string) Security

NewSecurity creates a Security.

func (*Security) ToTLSConfig

func (s *Security) ToTLSConfig() (tlsConfig *tls.Config, err error)

ToTLSConfig generates tls's config based on security section of the config.

type TiKVClient

type TiKVClient struct {
	// GrpcConnectionCount is the max gRPC connections that will be established
	// with each tikv-server.
	GrpcConnectionCount uint `toml:"grpc-connection-count" json:"grpc-connection-count"`
	// After a duration of this time in seconds if the client doesn't see any activity it pings
	// the server to see if the transport is still alive.
	GrpcKeepAliveTime uint `toml:"grpc-keepalive-time" json:"grpc-keepalive-time"`
	// After having pinged for keepalive check, the client waits for a duration of Timeout in seconds
	// and if no activity is seen even after that the connection is closed.
	GrpcKeepAliveTimeout uint `toml:"grpc-keepalive-timeout" json:"grpc-keepalive-timeout"`
	// GrpcCompressionType is the compression type for gRPC channel: none or gzip.
	GrpcCompressionType string `toml:"grpc-compression-type" json:"grpc-compression-type"`
	// CommitTimeout is the max time which command 'commit' will wait.
	CommitTimeout string      `toml:"commit-timeout" json:"commit-timeout"`
	AsyncCommit   AsyncCommit `toml:"async-commit" json:"async-commit"`
	// MaxBatchSize is the max batch size when calling batch commands API.
	MaxBatchSize uint `toml:"max-batch-size" json:"max-batch-size"`
	// If TiKV load is greater than this, TiDB will wait for a while to avoid little batch.
	OverloadThreshold uint `toml:"overload-threshold" json:"overload-threshold"`
	// MaxBatchWaitTime in nanosecond is the max wait time for batch.
	MaxBatchWaitTime time.Duration `toml:"max-batch-wait-time" json:"max-batch-wait-time"`
	// BatchWaitSize is the max wait size for batch.
	BatchWaitSize uint `toml:"batch-wait-size" json:"batch-wait-size"`
	// EnableChunkRPC indicate the data encode in chunk format for coprocessor requests.
	EnableChunkRPC bool `toml:"enable-chunk-rpc" json:"enable-chunk-rpc"`
	// If a Region has not been accessed for more than the given duration (in seconds), it
	// will be reloaded from the PD.
	RegionCacheTTL uint `toml:"region-cache-ttl" json:"region-cache-ttl"`
	// If a store has been up to the limit, it will return error for successive request to
	// prevent the store occupying too much token in dispatching level.
	StoreLimit int64 `toml:"store-limit" json:"store-limit"`
	// StoreLivenessTimeout is the timeout for store liveness check request.
	StoreLivenessTimeout string           `toml:"store-liveness-timeout" json:"store-liveness-timeout"`
	CoprCache            CoprocessorCache `toml:"copr-cache" json:"copr-cache"`
	// TTLRefreshedTxnSize controls whether a transaction should update its TTL or not.
	TTLRefreshedTxnSize      int64  `toml:"ttl-refreshed-txn-size" json:"ttl-refreshed-txn-size"`
	ResolveLockLiteThreshold uint64 `toml:"resolve-lock-lite-threshold" json:"resolve-lock-lite-threshold"`
}

TiKVClient is the config for tikv client.

func DefaultTiKVClient

func DefaultTiKVClient() TiKVClient

DefaultTiKVClient returns default config for TiKVClient.

func (*TiKVClient) Valid

func (config *TiKVClient) Valid() error

Valid checks if this config is valid.

type TxnLocalLatches

type TxnLocalLatches struct {
	Enabled  bool `toml:"-" json:"-"`
	Capacity uint `toml:"-" json:"-"`
}

TxnLocalLatches is the TxnLocalLatches section of the config.

func DefaultTxnLocalLatches

func DefaultTxnLocalLatches() TxnLocalLatches

DefaultTxnLocalLatches returns the default configuration for TxnLocalLatches

func (*TxnLocalLatches) Valid

func (c *TxnLocalLatches) Valid() error

Valid returns true if the configuration is valid.