proc

type CSEOptions struct {
	S3Endpoint string `yaml:"s3_endpoint"`
	Bucket     string `yaml:"bucket"`
	AccessKey  string `yaml:"access_key"`
	SecretKey  string `yaml:"secret_key"`
}

type Config struct {
	ConfigPath string `yaml:"config_path"`
	BinPath    string `yaml:"bin_path"`
	Num        int    `yaml:"num"`
	Host       string `yaml:"host"`
	Port       int    `yaml:"port"`
	UpTimeout  int    `yaml:"up_timeout"`
	Version    string `yaml:"version"`
}

type DMMaster struct {
	ProcessInfo
	Plan DMMasterPlan
}

type DMMasterPlan struct {
	InitialCluster []DMMemberPlan
	RequireReady   bool
}

type DMMemberPlan struct {
	Name       string
	PeerAddr   string // host:peerPort
	MasterAddr string // host:statusPort
}

type DMWorker struct {
	ProcessInfo
	Plan DMWorkerPlan
}

type DMWorkerPlan struct {
	MasterAddrs []string // host:statusPort
}

type Drainer struct {
	ProcessInfo
	Plan DrainerPlan
}

type DrainerPlan struct{ PDAddrs []string }

type GrafanaInstance struct {
	ProcessInfo

	PrometheusURL string
}

type GrafanaPlan struct {
	PrometheusURL string // http://host:port
}

type MetricAddr struct {
	Targets []string          `json:"targets"`
	Labels  map[string]string `json:"labels"`
}

type Mode = string

type NGMonitoringInstance struct {
	ProcessInfo

	Plan NGMonitoringPlan
}

type NGMonitoringPlan struct {
	PDAddrs []string
}

type OSProcess interface {
	Start() error
	Wait() error
	Pid() int
	Uptime() string
	SetOutputFile(fname string) error
	Cmd() *exec.Cmd
}

type PDInstance struct {
	ProcessInfo
	ShOpt SharedOptions
	Plan  PDPlan
}

type PDMemberPlan struct {
	Name     string
	PeerAddr string // host:peerPort
}

type PDPlan struct {
	// InitialCluster is used by pd/pd-api (choose one of InitialCluster/JoinAddrs).
	InitialCluster []PDMemberPlan
	// JoinAddrs is used by pd/pd-api when joining an existing cluster.
	JoinAddrs []string // host:peerPort

	// BackendAddrs is used by pd-* microservices as backend endpoints.
	BackendAddrs []string // host:statusPort

	KVIsSingleReplica bool
}

type Process interface {
	Info() *ProcessInfo

	// Prepare builds the process command (config + args) for later start.
	//
	// It does NOT start the underlying process. Playground owns the actual
	// proc.Start() call so it can consistently wire logs, waiters and readiness.
	Prepare(ctx context.Context) error
	// LogFile return the log file name
	LogFile() string
}

type ProcessInfo struct {
	ID         int
	Dir        string
	Host       string
	Port       int
	StatusPort int // client port for PD
	// UpTimeout is the maximum wait time (in seconds) for the instance to become
	// ready.
	//
	// It is only used by components that implement readiness checks (e.g. TiDB,
	// TiProxy, TiFlash). A value <= 0 means no limit.
	UpTimeout  int
	ConfigPath string
	// UserBinPath is the binary path provided by the user (if any).
	//
	// It is treated as input and must not be overwritten by binary resolution.
	UserBinPath string
	// BinPath is the resolved executable path used to start the instance.
	//
	// It is set by the playground planner/preloader and may come from either a
	// user-provided path or a repository-installed component.
	BinPath         string
	Version         utils.Version
	Proc            OSProcess
	RepoComponentID RepoComponentID
	Service         ServiceID
}

type PrometheusInstance struct {
	ProcessInfo
	// contains filtered or unexported fields
}

type Pump struct {
	ProcessInfo
	Plan PumpPlan
}

type PumpPlan struct{ PDAddrs []string }

type ReadyWaiter interface {
	// WaitReady blocks until the instance is ready, or ctx is done.
	//
	// The maximum waiting time should usually be controlled by the instance's
	// UpTimeout field (in seconds). A value <= 0 means no limit.
	WaitReady(ctx context.Context) error
}

type RepoComponentID string

type ServiceID string

type ServicePlan struct {
	Name      string
	ServiceID string

	StartAfterServices []string

	ComponentID     string
	ResolvedVersion string
	BinPath         string

	Shared ServiceSharedPlan

	// Service-specific inputs (strong schema).
	PD           *PDPlan           `json:",omitempty"`
	TiKV         *TiKVPlan         `json:",omitempty"`
	TiDB         *TiDBPlan         `json:",omitempty"`
	TiKVWorker   *TiKVWorkerPlan   `json:",omitempty"`
	TiFlash      *TiFlashPlan      `json:",omitempty"`
	TiProxy      *TiProxyPlan      `json:",omitempty"`
	Grafana      *GrafanaPlan      `json:",omitempty"`
	NGMonitoring *NGMonitoringPlan `json:",omitempty"`
	TiCDC        *TiCDCPlan        `json:",omitempty"`
	TiKVCDC      *TiKVCDCPlan      `json:",omitempty"`
	DMMaster     *DMMasterPlan     `json:",omitempty"`
	DMWorker     *DMWorkerPlan     `json:",omitempty"`
	Pump         *PumpPlan         `json:",omitempty"`
	Drainer      *DrainerPlan      `json:",omitempty"`

	// Debug fields (not part of execution semantics).
	DebugConstraint string
}

type ServiceSharedPlan struct {
	Dir        string
	Host       string
	Port       int
	StatusPort int

	// Ports holds additional named ports allocated during planning.
	//
	// It is a low-level, per-instance detail: planner fills it based on service
	// catalog definitions and executor/proc implementations may read it when a
	// service needs more than the standard Port/StatusPort pair (e.g. TiFlash).
	Ports map[string]int `json:",omitempty"`

	ConfigPath string
	UpTimeout  int
}

type SharedOptions struct {
	/// Whether or not to tune the cluster in order to run faster (instead of easier to debug).
	HighPerf           bool       `yaml:"high_perf"`
	CSE                CSEOptions `yaml:"cse"` // Only available when mode == ModeCSE or ModeDisAgg
	PDMode             string     `yaml:"pd_mode"`
	Mode               string     `yaml:"mode"`
	PortOffset         int        `yaml:"port_offset"`
	EnableTiKVColumnar bool       `yaml:"enable_tikv_columnar"` // Only available when mode == ModeCSE
	ForcePull          bool       `yaml:"force_pull"`
}

type TiCDC struct {
	ProcessInfo
	Plan TiCDCPlan
}

type TiCDCPlan struct{ PDAddrs []string }

type TiDBInstance struct {
	ProcessInfo
	ShOpt          SharedOptions
	Plan           TiDBPlan
	TiProxyCertDir string
}

type TiDBPlan struct {
	PDAddrs []string

	EnableBinlog bool

	TiKVWorkerURLs []string // host:port
}

type TiFlashInstance struct {
	ProcessInfo
	ShOpt SharedOptions
	Plan  TiFlashPlan
}

type TiFlashPlan struct {
	PDAddrs []string

	// ProcessInfo.Port remains the TiFlash HTTP port.
	ServicePort     int
	TCPPort         int
	ProxyPort       int
	ProxyStatusPort int
}

type TiKVCDCInstance struct {
	ProcessInfo
	Plan TiKVCDCPlan
}

type TiKVCDCPlan struct{ PDAddrs []string }

type TiKVInstance struct {
	ProcessInfo
	ShOpt SharedOptions
	Plan  TiKVPlan
}

type TiKVPlan struct {
	PDAddrs  []string // host:statusPort
	TSOAddrs []string // host:statusPort (ms mode)
}

type TiKVWorkerInstance struct {
	ProcessInfo
	ShOpt SharedOptions
	Plan  TiKVWorkerPlan
}

type TiKVWorkerPlan struct {
	PDAddrs []string
}

type TiProxyInstance struct {
	ProcessInfo
	Plan TiProxyPlan
}

type TiProxyPlan struct {
	PDAddrs []string
}