config

type BootOptions struct {
	Spec       `yaml:",inline"`
	Config     *Options    `yaml:"config" json:"config"`
	Listeners  []*Listener `validate:"required,dive" yaml:"listeners" json:"listeners"`
	Registry   *Registry   `yaml:"registry" json:"registry"`
	Trace      *Trace      `yaml:"trace" json:"trace"`
	Supervisor *User       `validate:"required,dive" yaml:"supervisor" json:"supervisor"`
	Logging    *log.Config `validate:"required,dive" yaml:"logging" json:"logging"`
}

type CacheConfigReaderTest = cacheConfigReader

type Center interface {
	io.Closer
	ConfigWriter
	ConfigReader
	ConfigWatcher
	// Tenant tenant info
	Tenant() string
}

type CenterTest = center

type ClusterEvent struct {
	Name        string
	Type        DataSourceType
	SqlMaxLimit int
	Parameters  ParametersMap
	GroupsEvent *GroupsEvent
}

type Clusters []*DataSourceCluster

type ClustersEvent struct {
	AddClusters    Clusters
	DeleteClusters Clusters
	UpdateClusters []*ClusterEvent
}

type ColumnRule struct {
	Name string `validate:"required" yaml:"name" json:"name"`
	Type string `yaml:"type" json:"type"`
	Step int    `yaml:"step" json:"step"`
}

type ConfigItem string

type ConfigReader interface {
	io.Closer
	// LoadAll loads the full Tenant configuration, the first time it will be loaded remotely,
	// and then it will be directly assembled from the cache layer
	LoadAll(ctx context.Context) (*Tenant, error)
	// Load loads the full Tenant configuration, the first time it will be loaded remotely,
	// and then it will be directly assembled from the cache layer
	Load(ctx context.Context, item ConfigItem) (*Tenant, error)
}

type ConfigWatcher interface {
	io.Closer
	// Subscribe subscribes to all changes of an event by EventType
	Subscribe(ctx context.Context, et EventType, c EventCallback) (context.CancelFunc, error)
}

type ConfigWatcherTest configWatcher

type ConfigWriter interface {
	io.Closer
	// Import imports the configuration information of a tenant
	Import(ctx context.Context, cfg *Tenant) error
	// Write imports the configuration information of a tenant
	Write(ctx context.Context, item ConfigItem, cfg *Tenant) error
}

type Configuration struct {
	Spec `yaml:",inline"`
	Data *Data `validate:"required,structonly" yaml:"data" json:"data"`
}

type Data struct {
	Tenants []*Tenant `validate:"required,dive" yaml:"tenants" json:"tenants"`
}

type DataRevision interface {
	Revision() string
}

type DataSourceCluster struct {
	Name        string         `yaml:"name" json:"name"`
	Type        DataSourceType `yaml:"type" json:"type"`
	SqlMaxLimit int            `default:"-1" yaml:"sql_max_limit" json:"sql_max_limit,omitempty"`
	Parameters  ParametersMap  `yaml:"parameters" json:"parameters"`
	Groups      []*Group       `yaml:"groups" json:"groups"`
}

type DataSourceType string

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

type Event interface {
	Type() EventType
}

type EventCallback func(e Event)

type EventType int32

type Group struct {
	Name  string   `yaml:"name" json:"name"`
	Nodes []string `yaml:"nodes" json:"nodes"`
}

type GroupEvent struct {
	Name        string
	AddNodes    Nodes
	UpdateNodes Nodes
	DeleteNodes Nodes
}

type Groups []*Group

type GroupsEvent struct {
	AddGroups    Groups
	UpdateGroups Groups
	DeleteGroups Groups
}

type Listener struct {
	ProtocolType  string         `yaml:"protocol_type" json:"protocol_type"`
	SocketAddress *SocketAddress `yaml:"socket_address" json:"socket_address"`
	ServerVersion string         `yaml:"server_version" json:"server_version"`
}

type MatchRule struct {
	Operation  []string         `yaml:"operation" json:"operation"`
	MatchType  string           `yaml:"match_type" json:"match_type"`
	Attributes []*RuleAttribute `yaml:"attributes" json:"attributes"`
}

type Node struct {
	Name       string                 `validate:"required" yaml:"name" json:"name"`
	Host       string                 `validate:"required" yaml:"host" json:"host"`
	Port       int                    `validate:"required" yaml:"port" json:"port"`
	Username   string                 `validate:"required" yaml:"username" json:"username"`
	Password   string                 `validate:"required" yaml:"password" json:"password"`
	Database   string                 `validate:"required" yaml:"database" json:"database"`
	Parameters ParametersMap          `yaml:"parameters" json:"parameters"`
	ConnProps  map[string]interface{} `yaml:"conn_props" json:"conn_props,omitempty"`
	Weight     string                 `default:"r10w10" yaml:"weight" json:"weight"`
	Labels     map[string]string      `yaml:"labels" json:"labels,omitempty"`
}

type Nodes map[string]*Node

type NodesEvent struct {
	AddNodes    []*Node
	UpdateNodes []*Node
	DeleteNodes []*Node
}

type Options struct {
	StoreName string                 `yaml:"name"`
	RootPath  string                 `yaml:"root_path"`
	Options   map[string]interface{} `yaml:"options"`
}

type ParametersMap map[string]string

type PathInfo struct {
	DefaultConfigSpecPath               PathKey
	DefaultTenantBaseConfigPath         PathKey
	DefaultConfigSysDBPath              PathKey
	DefaultConfigDataNodesPath          PathKey
	DefaultConfigDataUsersPath          PathKey
	DefaultConfigDataSourceClustersPath PathKey
	DefaultConfigDataShardingRulePath   PathKey
	DefaultConfigDataShadowRulePath     PathKey

	ConfigKeyMapping   map[PathKey]string
	ConfigEventMapping map[PathKey]EventType
	BuildEventMapping  map[EventType]func(pre, cur *Tenant) Event
	ConfigValSupplier  map[PathKey]func(cfg *Tenant) interface{}
}

type PathKey string

type Prop struct {
	Operation string `yaml:"operation" json:"operation"`
	Column    string `yaml:"column" json:"column"`
	Value     string `yaml:"value" json:"value"`
	Regex     string `yaml:"regex" json:"regex"`
}

type ProtocolType int32

type Registry struct {
	Enable   bool                   `yaml:"enable" json:"enable"`
	Name     string                 `yaml:"name" json:"name"`
	RootPath string                 `yaml:"root_path" json:"root_path"`
	Options  map[string]interface{} `yaml:"options" json:"options"`
}

type Rule struct {
	Columns []*ColumnRule `validate:"required" yaml:"columns" json:"columns"`
	Type    string        `validate:"required" yaml:"type" json:"type"`
	Expr    string        `validate:"required" yaml:"expr" json:"expr"`
}

type RuleAttribute struct {
	Column string `yaml:"column" json:"column"`
	Value  string `yaml:"value,omitempty" json:"value,omitempty"`
	Regex  string `yaml:"regex,omitempty" json:"regex,omitempty"`
}

type Rules []*Rule

type Sequence struct {
	Type   string            `yaml:"type" json:"type,omitempty"`
	Option map[string]string `yaml:"option" json:"option,omitempty"`
}

type ShadowRule struct {
	ShadowTables []*ShadowTable `yaml:"tables" json:"tables"`
}

type ShadowRuleEvent struct {
	AddTables    []*ShadowTable
	UpdateTables []*ShadowTable
	DeleteTables []*ShadowTable
}

type ShadowTable struct {
	Name       string       `yaml:"name" json:"name"`
	Enable     bool         `yaml:"enable" json:"enable"`
	GroupNode  string       `yaml:"group_node" json:"group_node"`
	MatchRules []*MatchRule `yaml:"match_rules" json:"match_rules"`
}

type ShardingRule struct {
	Tables []*Table `yaml:"tables" json:"tables"`
}

type ShardingRuleEvent struct {
	AddTables    []*Table
	UpdateTables []*Table
	DeleteTables []*Table
}

type SocketAddress struct {
	Address string `default:"0.0.0.0" yaml:"address" json:"address"`
	Port    int    `default:"13306" yaml:"port" json:"port"`
}

type Spec struct {
	Kind                       string                 `yaml:"kind" json:"kind,omitempty"`
	APIVersion                 string                 `yaml:"apiVersion" json:"apiVersion,omitempty"`
	LogPath                    string                 `yaml:"log_path" json:"log_path,omitempty"`
	SlowLogPath                string                 `yaml:"slow_log_path" json:"slow_log_path,omitempty"`
	EnableLocalMathComputation bool                   `yaml:"enable_local_math_computation" json:"enable_local_math_computation,omitempty"`
	Metadata                   map[string]interface{} `yaml:"metadata" json:"metadata"`
}

type StoreOperator interface {
	io.Closer
	// Init plugin initialization
	Init(options map[string]interface{}) error
	// Save save a configuration data
	Save(key PathKey, val []byte) error
	// Get get a configuration
	Get(key PathKey) ([]byte, error)
	// Watch Monitor changes of the key
	Watch(key PathKey) (<-chan []byte, error)
	// Name plugin name
	Name() string
}

type SubscribeResult struct {
	EventChan <-chan Event
	Cancel    context.CancelFunc
}

type Table struct {
	Name           string            `validate:"required" yaml:"name" json:"name"`
	Sequence       *Sequence         `yaml:"sequence" json:"sequence"`
	DbRules        []*Rule           `yaml:"db_rules" json:"db_rules"`
	TblRules       []*Rule           `yaml:"tbl_rules" json:"tbl_rules"`
	Topology       *Topology         `validate:"required" yaml:"topology" json:"topology"`
	ShadowTopology *Topology         `yaml:"shadow_topology" json:"shadow_topology"`
	Attributes     map[string]string `yaml:"attributes" json:"attributes"`
}

type Tenant struct {
	Spec
	Name               string               `validate:"required" yaml:"name" json:"name"`
	Users              []*User              `validate:"required" yaml:"users" json:"users"`
	SysDB              *Node                `validate:"required" yaml:"sys_db" json:"sys_db"`
	DataSourceClusters []*DataSourceCluster `validate:"required,dive" yaml:"clusters" json:"clusters"`
	ShardingRule       *ShardingRule        `validate:"required,dive" yaml:"sharding_rule,omitempty" json:"sharding_rule,omitempty"`
	ShadowRule         *ShadowRule          `yaml:"shadow_rule,omitempty" json:"shadow_rule,omitempty"`
	Nodes              map[string]*Node     `validate:"required" yaml:"nodes" json:"nodes"`
}

type TenantOperator interface {
	io.Closer

	// ListTenants lists all tenants.
	ListTenants() []string

	// CreateTenant creates tenant.
	CreateTenant(string) error

	// UpdateTenant update tenant.
	UpdateTenant(tenant string, newTenant string) error

	// RemoveTenant removes tenant.
	RemoveTenant(string) error

	// RemoveTenantUser removes a tenant user.
	RemoveTenantUser(tenant, username string) error

	// CreateTenantUser creates a user.
	CreateTenantUser(tenant, username, password string) error

	// UpdateTenantUser update user by username.
	UpdateTenantUser(tenant, newUsername, password, oldUsername string) error

	// UpsertNode creates a node, or updates a node.
	UpsertNode(tenant, node, name, host string, port int, username, password, database, weight string) error

	// RemoveNode removes a node.
	RemoveNode(tenant, name string) error

	// Subscribe subscribes tenants change
	Subscribe(ctx context.Context, c EventCallback) context.CancelFunc
}

type Tenants []string

type TenantsEvent struct {
	AddTenants    Tenants
	DeleteTenants Tenants
}

type Topology struct {
	DbPattern  string `validate:"required" yaml:"db_pattern" json:"db_pattern"`
	TblPattern string `validate:"required" yaml:"tbl_pattern" json:"tbl_pattern"`
}

type Trace struct {
	Type    string `default:"jaeger" yaml:"type" json:"type"`
	Address string `default:"http://localhost:14268/api/traces" yaml:"address" json:"address"`
}

type User struct {
	Username string `yaml:"username" json:"username"`
	Password string `yaml:"password" json:"password"`
}

type Users []*User

type UsersEvent struct {
	AddUsers    Users
	UpdateUsers Users
	DeleteUsers Users
}