proto

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

type ExtraParams struct {
	// ManualRecovery indicates whether the task can be recovered manually.
	// if enabled, the task will enter 'awaiting-resolution' state when it failed,
	// then the user can recover the task manually or fail it if it's not recoverable.
	ManualRecovery bool `json:"manual_recovery,omitempty"`
	// MaxRuntimeSlots is the max slots when running subtasks of this task in
	// TargetSteps steps.
	// normally it's 0, means we will use the RequiredSlots to run the subtasks.
	// if set, we will use the min of RequiredSlots and MaxRuntimeSlots as the
	// execution effective slots of the task step defined in TargetSteps.
	// this field is used to workaround OOM issue where TiDB might repeatedly
	// restart. the DXF framework won't detect changes in this field, so it's not
	// part of normal schedule workflow, when TiDB restarts the newest value will
	// be used.
	// RequiredSlots might be modified, and MaxRuntimeSlots is not touched in this
	// case due to above reason, so MaxRuntimeSlots might > RequiredSlots.
	MaxRuntimeSlots int `json:"max_runtime_slots,omitempty"`
	// TargetSteps indicates the steps that MaxRuntimeSlots takes effect.
	// if empty or nil, MaxRuntimeSlots takes effect in all steps.
	// normally OOM only happens in some specific steps, so we can just limit the
	// concurrency in those steps to reduce the impact on the overall performance.
	TargetSteps []Step `json:"target_steps,omitempty"`
}

type ManagedNode struct {
	// ID see GenerateExecID, it's named as host in the meta table.
	ID string
	// Role of the node, either "" or "background"
	// all managed node should have the same role
	Role     string
	CPUCount int
}

type Modification struct {
	Type ModificationType `json:"type"`
	To   int64            `json:"to"`
}

type ModificationType string

type ModifyParam struct {
	PrevState     TaskState      `json:"prev_state"`
	Modifications []Modification `json:"modifications"`
}

type NodeResource struct {
	TotalCPU  int
	TotalMem  int64
	TotalDisk uint64
}

type Step int64

type StepResource struct {
	CPU *Allocatable
	Mem *Allocatable
}

type Subtask struct {
	SubtaskBase
	// UpdateTime is the time when the subtask is updated.
	// it can be used as subtask end time if the subtask is finished.
	// it's 0 if it hasn't started yet.
	UpdateTime time.Time
	// Meta is the metadata of subtask, should not be nil.
	// meta of different subtasks of same step must be different too.
	// NOTE: this field can be changed by StepExecutor.OnFinished method, to store
	// some result, and framework will update the subtask meta in the storage.
	// On other code path, this field should be read-only.
	Meta    []byte
	Summary string
}

type SubtaskBase struct {
	ID   int64
	Step Step
	Type TaskType
	// taken from task_key of the subtask table
	TaskID int64
	State  SubtaskState
	// Concurrency is the concurrency of the subtask.
	// it's initialized as the task's required slots, and it's NOT used now.
	// if the required slot of task is modified, the concurrency of un-finished
	// subtasks of the task will be updated too.
	// some subtasks like post-process of import into, don't consume too many resources,
	// can lower this value, can use this field to implement such feature later.
	Concurrency int
	// ExecID is the ID of target executor, right now it's the same as instance_id,
	// its value is IP:PORT, see GenerateExecID
	ExecID     string
	CreateTime time.Time
	// StartTime is the time when the subtask is started.
	// it's 0 if it hasn't started yet.
	StartTime time.Time
	// Ordinal is the ordinal of subtask, should be unique for some task and step.
	// starts from 1.
	Ordinal int
}

type SubtaskState string

type Task struct {
	TaskBase
	// SchedulerID is not used now.
	SchedulerID     string
	StartTime       time.Time
	StateUpdateTime time.Time
	// Meta is the metadata of task, it's read-only in most cases, but it can be
	// changed in below case, and framework will update the task meta in the storage.
	// 	- task switches to next step in Scheduler.OnNextSubtasksBatch
	// 	- on task cleanup, we might do some redaction on the meta.
	// 	- on task 'modifying', params inside the meta can be changed.
	Meta        []byte
	Error       error
	ModifyParam ModifyParam
}

type TaskBase struct {
	ID    int64
	Key   string
	Type  TaskType
	State TaskState
	Step  Step
	// Priority is the priority of task, the smaller value means the higher priority.
	// valid range is [1, 1024], default is NormalPriority.
	Priority int
	// RequiredSlots is the required slots of the task.
	// we use this field to allocate slots when scheduling and creating the task
	// executor, but the effective slots when running the task is determined by
	// GetRuntimeSlots.
	// in normal case, they are the same. but when meeting OOM and TiDB repeatedly
	// restarts, we might set a lower MaxRuntimeSlots in ExtraParams, then the
	// effective slots is smaller than RequiredSlots.
	// Note: in application layer, don't use this field directly, use GetRuntimeSlots
	// or GetResource of step executor instead.
	// Note: in the system table, we store it inside 'concurrency' column as
	// required slots is introduced later.
	RequiredSlots int
	// TargetScope indicates that the task should be running on tidb nodes which
	// contain the tidb_service_scope=TargetScope label.
	// To be compatible with previous version, if it's "" or "background", the
	// task try run on nodes of "background" scope,
	// if there is no such nodes, will try nodes of "" scope.
	TargetScope  string
	CreateTime   time.Time
	MaxNodeCount int
	ExtraParams  ExtraParams
	// keyspace name is the keyspace that the task belongs to.
	// it's only useful for nextgen cluster.
	Keyspace string
}

type TaskState string

type TaskType string