api

type ActionType int64

type AffinityTerm struct {
	Namespaces  sets.String
	Selector    labels.Selector
	TopologyKey string
}

type BindPlugin interface {
	Plugin
	// Bind plugins will not be called until all pre-bind plugins have completed. Each
	// bind plugin is called in the configured order. A bind plugin may choose whether
	// to handle the given Pod. If a bind plugin chooses to handle a Pod, the
	// remaining bind plugins are skipped. When a bind plugin does not handle a pod,
	// it must return Skip in its Status code. If a bind plugin returns an Error, the
	// pod is rejected and will not be bound.
	Bind(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string) *Status
}

type BinderFramework interface {
	RunCheckTopologyPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeInfo NodeInfo) PluginToStatus

	// RunCheckConflictsPlugins runs the set of configured CheckConflicts plugins for pod on
	// the given node. Note that for the node being evaluated, the passed nodeInfo
	// reference could be different from the one in NodeInfoSnapshot map (e.g., pods
	// considered to be running on the node could be different). For example, during
	// preemption, we may pass a copy of the original nodeInfo object that has some pods
	// removed from it to evaluate the possibility of preempting them to
	// schedule the target pod.
	RunCheckConflictsPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeInfo NodeInfo) PluginToStatus

	// RunPreBindPlugins runs the set of configured PreBind plugins. It returns
	// *Status and its code is set to non-success if any of the plugins returns
	// anything but Success. If the Status code is "Unschedulable", it is
	// considered as a scheduling check failure, otherwise, it is considered as an
	// internal error. In either case the pod is not going to be bound.
	RunPreBindPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string) *Status

	// RunPostBindPlugins runs the set of configured PostBind plugins.
	RunPostBindPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string)

	// RunBindPlugins runs the set of configured Bind plugins. A Bind plugin may choose
	// whether to handle the given Pod. If a Bind plugin chooses to skip the
	// binding, it should return code=5("skip") status. Otherwise, it should return "Error"
	// or "Success". If none of the plugins handled binding, RunBindPlugins returns
	// code=5("skip") status.
	RunBindPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string) *Status

	// RunReservePluginsReserve runs the Reserve method of the set of
	// configured Reserve plugins. If any of these calls returns an error, it
	// does not continue running the remaining ones and returns the error. In
	// such case, pod will not be scheduled.
	RunReservePluginsReserve(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string) *Status

	// RunReservePluginsUnreserve runs the Unreserve method of the set of
	// configured Reserve plugins.
	RunReservePluginsUnreserve(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string)

	// RunPermitPlugins runs the set of configured Permit plugins. If any of these
	// plugins returns a status other than "Success" or "Wait", it does not continue
	// running the remaining plugins and returns an error. Otherwise, if any of the
	// plugins returns "Wait", then this function will create and add waiting pod
	// to a map of currently waiting pods and return status with "Wait" code.
	// Pod will remain waiting pod for the minimum duration returned by the Permit plugins.
	RunPermitPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeName string) *Status

	// WaitOnPermit will block, if the pod is a waiting pod, until the waiting pod is rejected or allowed.
	WaitOnPermit(ctx context.Context, pod *v1.Pod) *Status

	// HasCheckConflictsPlugins returns true if at least one CheckConflicts plugin is defined.
	HasCheckConflictsPlugins() bool

	// HasCheckTopologyPlugins returns true if at least one CheckTopology plugin is defined.
	HasCheckTopologyPlugins() bool

	HasPlugin(pluginName string) bool

	// ListPlugins returns a map of extension point name to list of configured Plugins.
	ListPlugins() map[string]sets.String

	// InitCycleState returns a new cycle state to be used in scheduling process, storing default common data from pod annotation in CycleState
	// This function is used to reduce unmarshalling operations in plugins for pod annotations.
	InitCycleState(pod *v1.Pod) (*CycleState, error)

	RunClusterPrePreemptingPlugins(preemptor *v1.Pod, state, preemptionState *CycleState) *Status
	RunVictimCheckingPlugins(preemptor, pod *v1.Pod, state, preemptionState *CycleState) *Status
	RunPostVictimCheckingPlugins(preemptor, pod *v1.Pod, state, preemptionState *CycleState) *Status
}

type BinderFrameworkHandle interface {
	GetPodGroupPods(podGroupName string) []*v1.Pod
	GetPodGroupInfo(podGroupName string) (*schedulingv1a1.PodGroup, error)

	// ClientSet returns a kubernetes clientSet.
	ClientSet() clientset.Interface
	CRDClientSet() crdclientset.Interface
	SharedInformerFactory() informers.SharedInformerFactory
	CRDSharedInformerFactory() crdinformers.SharedInformerFactory
	GetFrameworkForPod(*v1.Pod) (BinderFramework, error)
	VolumeBinder() scheduling.GodelVolumeBinder
	GetPDBItemList() []PDBItem

	GetNode(string) (NodeInfo, error)
}

type CachePodInfo struct {
	Pod     *v1.Pod
	Victims *Victims
}

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

type CachePodState struct {
	Pod *v1.Pod
	// Used by assumedPod to determinate expiration.
	Deadline *time.Time
	// Used to block cache from expiring assumedPod if binding still runs
	BindingFinished bool
}

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

type Candidate struct {
	Victims *Victims
	Name    string
}

type CandidatesSortingPlugin interface {
	Plugin
	Compare(*Candidate, *Candidate) int
}

type CheckConflictsPlugin interface {
	Plugin
	// CheckConflicts is called by framework in Binder.
	// All CheckConflictsPlugin should return "Success" to declare that
	// the given node fits the pod. If CheckConflicts doesn't return "Success",
	// CheckConflictsPlugin set proper error message.
	// For the node being evaluated, CheckConflicts plugins should look at the passed
	// nodeInfo reference for this particular node's information (e.g., pods
	// considered to be running on the node) instead of looking it up in the
	// NodeInfoSnapshot because we don't guarantee that they will be the same.
	// For example, during preemption, we may pass a copy of the original
	// nodeInfo object that has some pods removed from it to evaluate the
	// possibility of preempting them to schedule the target pod.
	CheckConflicts(ctx context.Context, state *CycleState, pod *v1.Pod, nodeInfo NodeInfo) *Status
}

type CheckTopologyPlugin interface {
	Plugin
	CheckTopology(ctx context.Context, state *CycleState, pod *v1.Pod, nodeInfo NodeInfo) *Status
}

type ClusterEvent struct {
	Resource   GVK
	ActionType ActionType
}

type ClusterNodeInfoLister interface {
	// List Returns the list of NodeInfos.
	List() []NodeInfo
	// HavePodsWithAffinityList Returns the list of NodeInfos of nodes with pods with affinity terms.
	HavePodsWithAffinityList() []NodeInfo
	// HavePodsWithRequiredAntiAffinityList Returns the list of NodeInfos of nodes with pods with required anti-affinity terms.
	HavePodsWithRequiredAntiAffinityList() []NodeInfo
	// Get Returns the NodeInfo of the given node name.
	Get(nodeName string) (NodeInfo, error)
}

type ClusterPrePreemptingPlugin interface {
	Plugin
	ClusterPrePreempting(*v1.Pod, *CycleState, *CycleState) *Status
}

type ClusterSharedLister interface {
	NodeInfos() ClusterNodeInfoLister
}

type Code int

type CrossNodesPlugin interface {
	Plugin
	HasCrossNodesConstraints(ctx context.Context, p *v1.Pod) bool
}

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

type FilterPlugin interface {
	Plugin
	// Filter is called by the scheduling framework.
	// All FilterPlugins should return "Success" to declare that
	// the given node fits the pod. If Filter doesn't return "Success",
	// please refer scheduler/algorithm/predicates/error.go
	// to set error message.
	// For the node being evaluated, Filter plugins should look at the passed
	// nodeInfo reference for this particular node's information (e.g., pods
	// considered to be running on the node) instead of looking it up in the
	// NodeInfoSnapshot because we don't guarantee that they will be the same.
	// For example, during preemption, we may pass a copy of the original
	// nodeInfo object that has some pods removed from it to evaluate the
	// possibility of preempting them to schedule the target pod.
	Filter(ctx context.Context, state *CycleState, pod *v1.Pod, nodeInfo NodeInfo) *Status
}

type FitError struct {
	Pod                   *v1.Pod
	NumAllNodes           int
	FilteredNodesStatuses NodeToStatusMap
}

type GVK string

type GenerationPodGroup interface {
	SetPodGroup(*schedulingv1a1.PodGroup)
	GetPodGroup() *schedulingv1a1.PodGroup
	Clone() GenerationPodGroup
	generationstore.StoredObj
}

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

type GenerationStringSet interface {
	Has(string) bool
	Insert(...string)
	Delete(...string)
	Len() int
	GetGeneration() int64
	SetGeneration(generation int64)
	Equal(GenerationStringSet) bool
	Reset(GenerationStringSet)
	Range(GenerationStringSetRangeFunc)
	Strings() []string
}

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

type GenerationStringSetRangeFunc func(key string)

type GroupingPlugin interface {
	Plugin
	Grouping(context.Context, ScheduleUnit, *CycleState, NodeGroup) ([]NodeGroup, *Status)
}

type HostPortInfo map[string]map[ProtocolPort]struct{}

type ImageStateSummary struct {
	// Size of the image
	Size int64
	// Used to track how many nodes have this image
	NumNodes int
}

type LessFunc func(podInfo1, podInfo2 *QueuedPodInfo) bool

type LoadAwareNodeMetricInfo struct {
	Name                 string
	UpdateTime           metav1.Time
	ProfileMilliCPUUsage int64
	ProfileMEMUsage      int64
}

type LoadAwareNodeUsage struct {
	RequestMilliCPU int64
	RequestMEM      int64
	ProfileMilliCPU int64
	ProfileMEM      int64
}

type LocatingPlugin interface {
	Plugin
	Locating(context.Context, ScheduleUnit, *CycleState, NodeGroup) (NodeGroup, *Status)
}

type MetaPod struct {
	UID string
}

type MetaVictims struct {
	Pods             []*MetaPod
	NumPDBViolations int64
}

type NodeCircle interface {
	NodeInfoLister
	GetKey() string
	Validate() error
}

type NodeCircleImpl struct {
	NodeInfoLister
	// contains filtered or unexported fields
}

type NodeCircleList []NodeCircle

type NodeGroup interface {
	GetKey() string
	Validate() error

	GetNodeCircles() NodeCircleList
	SetNodeCircles(NodeCircleList)

	GetPreferredNodes() PreferredNodes
	SetPreferredNodes(PreferredNodes)
}

type NodeGroupImpl struct {
	Key            string
	NodeCircles    []NodeCircle
	PreferredNodes PreferredNodes
}

type NodeHashSlice interface {
	Add(NodeInfo) bool
	Del(NodeInfo) bool
	Has(string) bool
	Nodes() []NodeInfo
	Len() int
}

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

type NodeInfo interface {
	GetNodeName() string
	GetGeneration() int64
	SetGeneration(generation int64)
	GetNodeLabels(podLauncher podutil.PodLauncher) map[string]string
	GetUsedPorts() HostPortInfo
	SetUsedPorts(HostPortInfo)

	GetGuaranteedRequested() *Resource
	GetGuaranteedNonZeroRequested() *Resource
	GetGuaranteedAllocatable() *Resource
	GetGuaranteedCapacity() *Resource
	GetBestEffortRequested() *Resource
	GetBestEffortNonZeroRequested() *Resource
	GetBestEffortAllocatable() *Resource
	SetGuaranteedRequested(*Resource)
	SetGuaranteedNonZeroRequested(*Resource)
	SetGuaranteedAllocatable(*Resource)
	SetGuaranteedCapacity(*Resource)
	SetBestEffortRequested(*Resource)
	SetBestEffortNonZeroRequested(*Resource)
	SetBestEffortAllocatable(*Resource)

	GetNodeInSchedulerPartition() bool   // TODO
	SetNodeInSchedulerPartition(bool)    // TODO
	GetNMNodeInSchedulerPartition() bool // TODO
	SetNMNodeInSchedulerPartition(bool)  // TODO

	GetImageStates() map[string]*ImageStateSummary
	SetImageStates(map[string]*ImageStateSummary)
	SetTransientInfo(info *TransientSchedulerInfo)
	GetTransientInfo() *TransientSchedulerInfo

	GetNode() *v1.Node
	GetNMNode() *nodev1alpha1.NMNode
	GetCNR() *katalystv1alpha1.CustomNodeResource
	SetNode(node *v1.Node) error
	SetNMNode(nmNode *nodev1alpha1.NMNode) error
	SetCNR(cnr *katalystv1alpha1.CustomNodeResource) error
	RemoveNode()
	RemoveNMNode()
	RemoveCNR()
	ObjectIsNil() bool
	SetNodePartition(inSchedulerPartition bool) error

	Clone() NodeInfo
	String() string

	GetPodsWithAffinity() []*PodInfo
	GetPodsWithRequiredAntiAffinity() []*PodInfo

	AddPod(pod *v1.Pod)
	RemovePod(pod *v1.Pod, preempt bool) error
	GetPods() []*PodInfo
	NumPods() int
	GetVictimCandidates(partitionInfo *PodPartitionInfo) []*PodInfo
	GetOccupiableResources(partitionInfo *PodPartitionInfo) *Resource

	VolumeLimits() map[v1.ResourceName]int64

	GetNumaTopologyStatus() *NumaTopologyStatus
	GetResourcesAvailableForSharedCoresPods(unavailableNumaList []int) *Resource
	GetResourcesRequestsOfSharedCoresPods() *Resource

	GetPrioritiesForPodsMayBePreempted(resourceType podutil.PodResourceType) []int64
}

type NodeInfoImpl struct {
	// Overall node information, collected by k8s.
	Node *v1.Node

	// node information, collected by node manager
	NMNode *nodev1alpha1.NMNode

	// cnr stores additional/custom node information, such as numa topology, etc.
	CNR *katalystv1alpha1.CustomNodeResource

	// Whether Node is in the partition of the scheduler
	NodeInSchedulerPartition bool

	// Whether NMNode is in the partition of the scheduler
	NMNodeInSchedulerPartition bool

	// PodInfoMaintainer maintain all the pods running on the node.
	PodInfoMaintainer *PodInfoMaintainer

	// Ports allocated on the node.
	UsedPorts HostPortInfo

	// Total requested resources of all guaranteed pods on this node. This includes
	// assumed pods, which scheduler has sent for binding, but may not be scheduled
	// yet.
	GuaranteedRequested *Resource
	// Total requested resources of all guaranteed pods on this node with a minimum
	// value applied to each container's CPU and memory requests. This does not reflect
	// the actual resource requests for this node, but is used to avoid scheduling
	// many zero-request pods onto one node.
	GuaranteedNonZeroRequested *Resource
	// We store guaranteed allocatedResources (which is the minimum of Node.Status.Allocatable.*
	// and CNR.Status.ResourceAllocatable.*) explicitly
	// as int64, to avoid conversions and accessing map.
	GuaranteedAllocatable *Resource
	// GuaranteedCapacity is capacity resource of node
	GuaranteedCapacity *Resource

	// Total requested resources of all best-effort pods on this node. This includes assumed
	// pods, which scheduler has sent for binding, but may not be scheduled yet.
	BestEffortRequested *Resource
	// Total requested resources of all best-effort pods on this node with a minimum value
	// applied to each container's CPU and memory requests. This does not reflect
	// the actual resource requests for this node, but is used to avoid scheduling
	// many zero-request pods onto one node.
	BestEffortNonZeroRequested *Resource
	// We store best-effort allocatedResources (which is CNR.Status.BestEffortResourceAllocatable.*) explicitly
	// as int64, to avoid conversions and accessing map.
	BestEffortAllocatable *Resource

	// ImageStates holds the entry of an image if and only if this image is on the node. The entry can be used for
	// checking an image's existence and advanced usage (e.g., image locality scheduling policy) based on the image
	// state information.
	ImageStates map[string]*ImageStateSummary

	// TransientInfo holds the information pertaining to a scheduling cycle. This will be destructed at the end of
	// scheduling cycle.
	TransientInfo *TransientSchedulerInfo

	// Whenever NodeInfoImpl changes, generation is bumped.
	// This is used to avoid cloning it if the object didn't change.
	Generation int64

	NumaTopologyStatus *NumaTopologyStatus
	// contains filtered or unexported fields
}

type NodeInfoLister interface {
	ClusterNodeInfoLister
	// InPartitionList Returns the list of NodeInfos in the partition of the scheduler
	InPartitionList() []NodeInfo
	// OutOfPartitionList Returns the list of NodeInfos out of the partition of the scheduler
	OutOfPartitionList() []NodeInfo
}

type NodeInfoListerImpl struct {
	// nodeInfoMap is a map of node name to its NodeInfo.
	NodeInfoMap map[string]NodeInfo
	// InPartitionNodes is the list of nodes in the partition of the scheduler.
	InPartitionNodes []NodeInfo
	// OutOfPartitionNodes is the list of nodes out of the partition of the scheduler.
	OutOfPartitionNodes []NodeInfo
	// HavePodsWithAffinityNodes is the list of nodes with at least one pod declaring affinity terms.
	HavePodsWithAffinityNodes []NodeInfo
	// HavePodsWithRequiredAntiAffinityNodes is the list of nodes with at least one pod declaring
	// required anti-affinity terms.
	HavePodsWithRequiredAntiAffinityNodes []NodeInfo
}

type NodePostPreemptingPlugin interface {
	Plugin
	NodePostPreempting(*v1.Pod, []*v1.Pod, *CycleState, *CycleState) *Status
}

type NodePrePreemptingPlugin interface {
	Plugin
	NodePrePreempting(*v1.Pod, NodeInfo, *CycleState, *CycleState) *Status
}

type NodeScore struct {
	Name  string
	Score int64
}

type NodeScoreList []NodeScore

type NodeToStatusMap map[string]*Status

type NodeToStatusMapByTemplate map[string]NodeToStatusMap

type NominatedNode struct {
	// NodeName is the node where the pod is supposed to place
	NodeName string `json:"node"`
	// VictimPods is the collection of all victim pods name. VictimPods should not be nil or empty.
	// If VictimPods is empty, this pod are supposed to be assumed
	VictimPods VictimPods `json:"victims"`
}

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

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

type ObservableUnit interface {
	GetUnitProperty() UnitProperty
}

type ObserveProperty interface {
	ConvertToMetricsLabels() metrics.Labels
	ConvertToTracingTags() trace.SpanOption
}

type OrderedPluginRegistry struct {
	Plugins []string
}

type OwnerItem interface {
	GetOwnerLabels() map[string]string
	AddPDB(string)
	RemovePDB(string)
	GetRelatedPDBs() []string
	SetPDBUpdated()
	GetPDBUpdated() bool
	Replace(OwnerItem)
	Clone() OwnerItem
	GetGeneration() int64
	SetGeneration(int64)
}

type PDBItem interface {
	GetPDB() *policy.PodDisruptionBudget
	SetPDB(*policy.PodDisruptionBudget)
	GetPDBSelector() labels.Selector
	SetPDBSelector(labels.Selector)
	RemoveAllOwners()
	AddOwner(string, string)
	RemoveOwner(string, string)
	GetRelatedOwnersByType(string) []string
	RemovePDBFromOwner(func(string, string))
	GetGeneration() int64
	SetGeneration(int64)
	Replace(PDBItem)
	Clone() PDBItem
}

type PermitPlugin interface {
	Plugin
	// TODO: remove the second return value
	// Permit is called before binding a pod (and before binder plugins). Permit
	// plugins are used to prevent or delay the binding of a Pod. A permit plugin
	// must return success or wait with timeout duration, or the pod will be rejected.
	// The pod will also be rejected if the wait timeout or the pod is rejected while
	// waiting. Note that if the plugin returns "wait", the framework will wait only
	// after running the remaining plugins given that no other plugin rejects the pod.
	Permit(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string) (*Status, time.Duration)
}

type Plugin interface {
	Name() string
}

type PluginCollection struct {
	// Filters is a set of plugins that should be invoked when filtering out nodes that cannot run the Pod.
	Filters []*PluginSpec

	// Scores is a set of plugins that should be invoked when ranking nodes that have passed the filtering phase.
	Scores []*PluginSpec

	// Searchings is a set of plugins that should be invoked in preemption phase
	Searchings []*VictimSearchingPluginCollectionSpec

	Sortings []*PluginSpec
}

type PluginCollectionSet map[string]*PluginCollection

type PluginList interface {
	List() []string
}

type PluginMap map[string]Plugin

type PluginOrder map[string]int

type PluginSpec struct {
	Name   string
	Weight int64
}

type PluginToNodeScores map[string]NodeScoreList

type PluginToStatus map[string]*Status

type Plugins []Plugin

type PluginsRunner interface {
	// RunFilterPlugins runs the set of configured filter plugins for pod on the given node.
	RunFilterPlugins(context.Context, *CycleState, *v1.Pod, NodeInfo) PluginToStatus
	// RunPreFilterExtensionAddPod calls the AddPod interface for the set of configured PreFilter plugins.
	RunPreFilterExtensionAddPod(ctx context.Context, state *CycleState, podToSchedule *v1.Pod, podToAdd *v1.Pod, nodeInfo NodeInfo) *Status
	// RunPreFilterExtensionRemovePod calls the RemovePod interface for the set of configured PreFilter plugins.
	RunPreFilterExtensionRemovePod(ctx context.Context, state *CycleState, podToSchedule *v1.Pod, podToRemove *v1.Pod, nodeInfo NodeInfo) *Status
}

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

type PodGroupSchedulingStatus string

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

type PodInfo struct {
	Pod                        *v1.Pod
	RequiredAffinityTerms      []AffinityTerm
	RequiredAntiAffinityTerms  []AffinityTerm
	PreferredAffinityTerms     []WeightedAffinityTerm
	PreferredAntiAffinityTerms []WeightedAffinityTerm
	ParseError                 error

	Res              Resource
	Non0CPU, Non0Mem int64

	PodResourceType      podutil.PodResourceType
	PodResourceTypeError error

	PodKey        string
	PodPriority   int64
	IsSharedCores bool

	PodGroupName string
	PodLauncher  podutil.PodLauncher

	PodPreemptionInfo PodPreemptionInfo
}

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

type PodInfoSlice interface {
	Add(*PodInfo) bool
	Del(*PodInfo) bool
	Pods() []*PodInfo
	Len() int
	Clone() PodInfoSlice
	Equal(PodInfoSlice) bool
}

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

type PodMaintainableInfo struct {
	PodInfo  *PodInfo
	MilliCPU int64
	Memory   int64
}

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

type PodPreemptionInfo struct {
	CanBePreempted int

	StartTime               *metav1.Time
	ProtectionDuration      int64
	ProtectionDurationExist bool

	Labels    string
	OwnerType string
	OwnerKey  string
}

type PodProperty struct {
	Namespace  string
	UnitKey    string
	Priority   int32
	Qos        podutil.PodResourceType
	SubCluster string
}

type PostBindPlugin interface {
	Plugin
	// PostBind is called after a pod is successfully bound. These plugins are
	// informational. A common application of this extension point is for cleaning
	// up. If a plugin needs to clean-up its state after a pod is scheduled and
	// bound, PostBind is the extension point that it should register.
	PostBind(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string)
}

type PostVictimCheckingPlugin interface {
	Plugin
	PostVictimChecking(*v1.Pod, *v1.Pod, *CycleState, *CycleState) *Status
}

type PostVictimSearchingPlugin interface {
	Plugin
	PostVictimSearching(*v1.Pod, *PodInfo, *CycleState, *CycleState, *VictimState) *Status
}

type PotentialVictim struct {
	Queue       string `json:"queue"`
	Application string `json:"application"`
}

type PotentialVictims []PotentialVictim

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

type PreBindPlugin interface {
	Plugin
	// PreBind is called before binding a pod. All binder plugins must return
	// success or the pod will be rejected and won't be sent for binding.
	PreBind(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string) *Status
}

type PreFilterExtensions interface {
	// AddPod is called by the framework while trying to evaluate the impact
	// of adding podToAdd to the node while scheduling podToSchedule.
	AddPod(ctx context.Context, state *CycleState, podToSchedule *v1.Pod, podToAdd *v1.Pod, nodeInfo NodeInfo) *Status
	// RemovePod is called by the framework while trying to evaluate the impact
	// of removing podToRemove from the node while scheduling podToSchedule.
	RemovePod(ctx context.Context, state *CycleState, podToSchedule *v1.Pod, podToRemove *v1.Pod, nodeInfo NodeInfo) *Status
}

type PreFilterPlugin interface {
	Plugin
	// PreFilter is called at the beginning of the scheduling cycle. All PreFilter
	// plugins must return success or the pod will be rejected.
	PreFilter(ctx context.Context, state *CycleState, p *v1.Pod) *Status
	// PreFilterExtensions returns a PreFilterExtensions interface if the plugin implements one,
	// or nil if it does not. A Pre-filter plugin can provide extensions to incrementally
	// modify its pre-processed info. The framework guarantees that the extensions
	// AddPod/RemovePod will only be called after PreFilter, possibly on a cloned
	// CycleState, and may call those functions more than once before calling
	// Filter again on a specific node.
	PreFilterExtensions() PreFilterExtensions
}

type PreScorePlugin interface {
	Plugin
	// PreScore is called by the scheduling framework after a list of nodes
	// passed the filtering phase. All prescore plugins must return success or
	// the pod will be rejected
	PreScore(ctx context.Context, state *CycleState, pod *v1.Pod, nodes []NodeInfo) *Status
}

type PreemptionError string

type PreferNodeExtension interface {
	Plugin
	PrePreferNode(context.Context, *CycleState, *CycleState, *v1.Pod, NodeInfo) (NodeInfo, *CycleState, *Status)
	PostPreferNode(context.Context, *CycleState, *CycleState, *v1.Pod, NodeInfo, *Status) *Status // TODO: revisit this, should we pass in Status instead of `fit` bool?
}

type PreferNodeExtensionList []PreferNodeExtension

type PreferredNodes interface {
	Add(NodeInfo, ...PreferNodeExtension)
	Get(nodeName string) PreferNodeExtensionList
	List() []NodeInfo
}

type PreferredNodesImpl struct {
	NodeInfoHooks map[string]PreferNodeExtensionList
	NodeHashSlice NodeHashSlice
}

type ProtocolPort struct {
	Protocol string
	Port     int32
}

type QueueSortPlugin interface {
	Plugin
	// Less are used to sort pods in the scheduling queue.
	Less(*QueuedPodInfo, *QueuedPodInfo) bool
}

type QueuedPodInfo struct {
	Pod *v1.Pod

	// The time pod added to the scheduling queue.
	Timestamp time.Time
	// Number of schedule attempts before successfully scheduled.
	// It's used to record the # attempts metric.
	Attempts int
	// The time when the pod is added to the queue for the first time. The pod may be added
	// back to the queue multiple times before it's successfully scheduled.
	// It shouldn't be updated once initialized. It's used to record the e2e scheduling
	// latency for a pod.
	InitialAttemptTimestamp time.Time
	// The time when the pod is first attempted to preempt victim pods. There can be
	// multiple attempts for this pod to wait on victim pods to be preempted, this
	// timestamp tracks the first time. It is used to timeout if the victim preemption
	// takes more time.
	InitialPreemptAttemptTimestamp time.Time

	// Fields below are only used by binder, need to move this out of QueuedPodInfo and put them into BinderQueuedPodInfo
	// TODO: (liumeng) implement BinderQueuedPodInfo ?
	// assumedPod
	ReservedPod *v1.Pod
	// NominatedNode contains victims and nominated node for the pod
	NominatedNode *NominatedNode

	// NoConflictStillInHandling indicates the pod passed the conflict checking phase
	// NewlyAssumedButStillInHandling indicates the pod passed the conflict checking phase
	// but is still in processing
	// TODO: when this field is moved from QueuedPodInfo to BindQueuedPodInfo, add more fine-grained states to avoid duplicated checking in binder workflow
	// for example: VictimsDeleting, ReadyForBinding ...
	NewlyAssumedButStillInHandling bool
	AllVolumeBound                 bool

	// QueueSpan is used to record queue updates
	QueueSpan *tracing.SpanInfo

	OwnerReferenceKey string // TODO: revisit this.
	// contains filtered or unexported fields
}

type QueuedUnitInfo struct {
	UnitKey string
	ScheduleUnit
	// The time unit added to the scheduling queue (will be refreshed).
	Timestamp time.Time
	// Number of schedule attempts before successfully scheduled.
	// It's used to record the # attempts metric.
	Attempts int

	// The time when the unit is added to the queue for the first time. The unit may
	// back to the queue multiple times before it's successfully scheduled.
	// It shouldn't be updated once initialized. It's used to record the e2e sched
	// latency for a pod.
	InitialAttemptTimestamp time.Time

	// QueuePriorityScore is calculated according to pod.Spec, combined with priority. It should not change if no changes in pod.Spec.
	QueuePriorityScore float64
}

type RecorderFactory func(string) events.EventRecorder

type ReservePlugin interface {
	Plugin
	// Reserve is called by the scheduling framework when the scheduler cache is
	// updated. If this method returns a failed Status, the scheduler will call
	// the Unreserve method for all enabled ReservePlugins.
	Reserve(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string) *Status
	// Unreserve is called by the scheduling framework when a reserved pod was
	// rejected, an error occurred during reservation of subsequent plugins, or
	// in a later phase. The Unreserve method implementation must be idempotent
	// and may be called by the scheduler even if the corresponding Reserve
	// method for the same plugin was not called.
	Unreserve(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string)
}

type Resource struct {
	MilliCPU         int64
	Memory           int64
	EphemeralStorage int64
	// We store allowedPodNumber (which is Node.Status.Allocatable.Pods().Value())
	// explicitly as int, to avoid conversions and improve performance.
	AllowedPodNumber int
	// ScalarResources
	ScalarResources map[v1.ResourceName]int64
}

type ResourceStatus struct {
	Allocatable *resource.Quantity
	Available   *resource.Quantity
	Users       sets.String
}

type ScheduleUnit interface {
	// Name is schedule unit name.
	// Name() string
	// Type is the schedule unit type. e.g. PodGroupUnit, DeploymentUnit, etc
	Type() ScheduleUnitType
	// GetKey returns the key of unit. This should be unique globally.
	GetKey() string
	// TODO: Should GetName()、GetNamespace() be there?
	// GetName returns the name of unit.
	GetName() string
	// GetNamespace returns the namespace of unit.
	GetNamespace() string
	// ReadyToBePopulated is used to determine whether the unit is ready to be populated.
	// This is a precondition check to schedule corresponding pods belonging to the unit.
	ReadyToBePopulated() bool
	// PodBelongToUnit is used in event handling to determine if a pod is a naked pod, or it belongs to unit.
	// If it does belong to the unit, the pods will be put into dedicated scheduling queue.
	PodBelongToUnit(pod *v1.Pod) bool
	// GetCreationTimestamp returns the creation timestamp of the original object.
	GetCreationTimestamp() *metav1.Time
	// GetEnqueuedTimestamp returns the timestamp when the unit is added to pending queue.
	GetEnqueuedTimestamp() *metav1.Time
	// GetPriority returns the priority score which is used to rank units in the readyQ
	GetPriority() int32
	// GetPods returns all pods belongs to this unit
	GetPods() []*QueuedPodInfo
	// ValidatePodCount checks if the podCount is a valid number in a batch operation for this unit
	ValidatePodCount(podCount int) bool
	// NumPods return the number of QueuedPodInfos in the unit
	NumPods() int
	// GetPod return a QueuedPodInfo with the same pod.UID
	GetPod(pod *QueuedPodInfo) *QueuedPodInfo
	// AddPod adds QueuedPodInfo into the Unit
	AddPod(pod *QueuedPodInfo) error
	// AddPods adds QueuedPodInfo into the Unit
	AddPods(pods []*QueuedPodInfo) error
	// UpdatePod updates QueuedPodInfo in the Unit
	UpdatePod(pod *QueuedPodInfo) error
	// DeletePod deletes QueuedPodInfo from the Unit
	DeletePod(pod *QueuedPodInfo) error
	// AddPodsIfNotPresent adds pods not existed in the Unit
	AddPodsIfNotPresent(pods ...*QueuedPodInfo) error
	GetTimeoutPeriod() int32
	// GetAnnotations returns the annotations of the Unit
	GetAnnotations() map[string]string
	// GetMinMember gets the min member value
	GetMinMember() (int, error)
	// GetRequiredAffinity returns required affinity scheduling rules, which
	// must be met in scheduling.
	GetRequiredAffinity() ([]UnitAffinityTerm, error)
	// GetPreferredAffinity returns preferred affinity scheduling rules, which
	// don't necessarily have to be satisfied but scheduler will prefer to schedule pods
	// to nodes that satisfy the affinity rules.
	GetPreferredAffinity() ([]UnitAffinityTerm, error)
	// GetAffinityNodeSelector returns the nodeSelector in affinity which defines the specific affinity rules.
	GetAffinityNodeSelector() (*v1.NodeSelector, error)
	// GetSortRulesForAffinity return the rules that indicate how the nodeGroups are sorted.
	// The rule's index in slice is the sort sequence.
	GetSortRulesForAffinity() ([]SortRule, error)
	// IsDebugModeOn checks whether the debug mode is set to on
	IsDebugModeOn() bool
	// SetEnqueuedTimeStamp set the timestamp when the unit is added to pending queue
	SetEnqueuedTimeStamp(time.Time)
	// GetUnitProperty returns unit property to be used by metrics and tracing
	GetUnitProperty() UnitProperty
	// ResetPods will empty all pods for the unit
	// It will be used by binder when we want to re-enqueue the unit (empty pods and then add waiting pods back)
	ResetPods()
}

type ScheduleUnitProperty struct {
	// TODO: figure out whether we should embed PodProperty into ScheduleUnitProperty
	*PodProperty
	MinMember int
	UnitType  string
}

type ScheduleUnitType string

type SchedulerFramework interface {
	// RunPreFilterPlugins runs the set of configured prefilter plugins. It returns
	// *Status and its code is set to non-success if any of the plugins returns
	// anything but Success. If a non-success status is returned, then the scheduling
	// cycle is aborted.
	RunPreFilterPlugins(ctx context.Context, state *CycleState, pod *v1.Pod) *Status

	// RunFilterPlugins runs the set of configured filter plugins for pod on
	// the given node. Note that for the node being evaluated, the passed nodeInfo
	// reference could be different from the one in NodeInfoSnapshot map (e.g., pods
	// considered to be running on the node could be different). For example, during
	// preemption, we may pass a copy of the original nodeInfo object that has some pods
	// removed from it to evaluate the possibility of preempting them to
	// schedule the target pod.
	RunFilterPlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeInfo NodeInfo, skipPlugins ...string) PluginToStatus

	// RunPreFilterExtensionAddPod calls the AddPod interface for the set of configured
	// PreFilter plugins. It returns directly if any of the plugins return any
	// status other than Success.
	RunPreFilterExtensionAddPod(ctx context.Context, state *CycleState, podToSchedule *v1.Pod, podToAdd *v1.Pod, nodeInfo NodeInfo) *Status

	// RunPreFilterExtensionRemovePod calls the RemovePod interface for the set of configured
	// PreFilter plugins. It returns directly if any of the plugins return any
	// status other than Success.
	RunPreFilterExtensionRemovePod(ctx context.Context, state *CycleState, podToSchedule *v1.Pod, podToAdd *v1.Pod, nodeInfo NodeInfo) *Status

	// RunPreScorePlugins runs the set of configured pre-score plugins. If any
	// of these plugins returns any status other than "Success", the given pod is rejected.
	RunPreScorePlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodes []NodeInfo) *Status

	// RunScorePlugins runs the set of configured scoring plugins. It returns a map that
	// stores for each scoring plugin name the corresponding NodeScoreList(s).
	// It also returns *Status, which is set to non-success if any of the plugins returns
	// a non-success status.
	RunScorePlugins(ctx context.Context, state *CycleState, pod *v1.Pod, nodeNames []string) (PluginToNodeScores, *Status)

	// HasFilterPlugins returns true if at least one filter plugin is defined.
	HasFilterPlugins() bool

	// HasScorePlugins returns true if at least one score plugin is defined.
	HasScorePlugins() bool

	// ListPlugins returns a map of extension point name to list of configured Plugins.
	ListPlugins() map[string]sets.String

	// InitCycleState returns a new cycle state to be used in scheduling process, storing default common data from pod annotation in CycleState
	// This function is used to reduce unmarshalling operations in plugins for pod annotations.
	InitCycleState(pod *v1.Pod) (*CycleState, error)
	SetPotentialVictims(node string, potentialVictims []string)
	GetPotentialVictims(node string) []string

	HasCrossNodesConstraints(ctx context.Context, pod *v1.Pod) bool
}

type SchedulerFrameworkHandle interface {
	// SwitchType indicates the cluster binary code corresponding to the current workflow.
	// It will be used to resolve BE/GT qos.
	SwitchType() SwitchType
	SubCluster() string
	SchedulerName() string

	// SnapshotSharedLister returns listers from the latest NodeInfo Snapshot. The snapshot
	// is taken at the beginning of a scheduling cycle and remains unchanged until
	// a pod finishes "Permit" point. There is no guarantee that the information
	// remains unchanged in the binding phase of scheduling, so plugins in the binding
	// cycle (pre-bind/bind/post-bind/un-reserve plugin) should not use it,
	// otherwise a concurrent read/write error might occur, they should use scheduler
	// cache instead.
	SnapshotSharedLister() SharedLister

	// ClientSet returns a kubernetes clientSet.
	ClientSet() clientset.Interface
	SharedInformerFactory() informers.SharedInformerFactory
	CRDSharedInformerFactory() crdinformers.SharedInformerFactory
	GetFrameworkForPod(*v1.Pod) (SchedulerFramework, error)

	// Note: The function's underlying access is Snapshot, Snapshot operations are lock-free.
	GetPodGroupInfo(podGroupName string) (*schedulingv1a1.PodGroup, error)
	// Note: The function's underlying access is Snapshot, Snapshot operations are lock-free.
	SetPotentialVictims(node string, potentialVictims []string)
	// Note: The function's underlying access is Snapshot, Snapshot operations are lock-free.
	GetPotentialVictims(node string) []string

	// Note: The function's underlying access is Snapshot, Snapshot operations are lock-free.
	GetPDBItemList() []PDBItem
	// Note: The function's underlying access is Snapshot, Snapshot operations are lock-free.
	GetPDBItemListForOwner(ownerType, ownerKey string) (bool, bool, []string)
	// Note: The function's underlying access is Snapshot, Snapshot operations are lock-free.
	GetOwnerLabels(ownerType, ownerKey string) map[string]string
	GetLoadAwareNodeMetricInfo(nodeName string, resourceType podutil.PodResourceType) *LoadAwareNodeMetricInfo
	GetLoadAwareNodeUsage(nodeName string, resourceType podutil.PodResourceType) *LoadAwareNodeUsage

	GetPreemptionFrameworkForPod(*v1.Pod) SchedulerPreemptionFramework
	GetPreemptionPolicy(deployName string) string
	CachePreemptionPolicy(deployName string, policyName string)
	CleanupPreemptionPolicyForPodOwner()
}

type SchedulerPreemptionFramework interface {
	ListPlugins() map[string]sets.String
	HasVictimSearchingPlugin(string) bool
	RunClusterPrePreemptingPlugins(preemptor *v1.Pod, state, commonState *CycleState) *Status
	RunNodePrePreemptingPlugins(preemptor *v1.Pod, nodeInfo NodeInfo, state *CycleState, preemptorState *CycleState) *Status
	RunVictimSearchingPlugins(preemptor *v1.Pod, podInfo *PodInfo, state, preemptionState *CycleState, victimState *VictimState) (Code, string)
	RunPostVictimSearchingPlugins(preemptor *v1.Pod, podInfo *PodInfo, state, preemptionState *CycleState, victimState *VictimState) *Status
	RunNodePostPreemptingPlugins(preemptor *v1.Pod, victims []*v1.Pod, state, commonState *CycleState) *Status

	RunCandidatesSortingPlugins(candidates []*Candidate, candidate *Candidate) []*Candidate
}

type SchedulerUnitFrameworkHandle interface {
	SwitchType() SwitchType
	SubCluster() string
	SchedulerName() string

	GetUnitStatus(string) unitstatus.UnitStatus
	IsCachedPod(pod *v1.Pod) (bool, error)
	GetNodeInfo(nodeName string) NodeInfo
}

type ScoreExtensions interface {
	// NormalizeScore is called for all node scores produced by the same plugin's "Score"
	// method. A successful run of NormalizeScore will update the scores list and return
	// a success status.
	NormalizeScore(ctx context.Context, state *CycleState, p *v1.Pod, scores NodeScoreList) *Status
}

type ScorePlugin interface {
	Plugin
	// Score is called on each filtered node. It must return success and an integer
	// indicating the rank of the node. All scoring plugins must return success or
	// the pod will be rejected.
	Score(ctx context.Context, state *CycleState, p *v1.Pod, nodeName string) (int64, *Status)

	// ScoreExtensions returns a ScoreExtensions interface if it implements one, or nil if it does not.
	ScoreExtensions() ScoreExtensions
}

type SharedLister interface {
	NodeInfos() NodeInfoLister
	GetPreemptorsByVictim(string, string) []string
}

type SinglePodUnit struct {
	Pod *QueuedPodInfo
	// contains filtered or unexported fields
}

type SortDimension string

type SortOrder string

type SortResource string

type SortRule struct {
	// Resource defines the resource name for sorting.
	Resource SortResource

	// Dimension may be Capacity or Available for the moment
	Dimension SortDimension

	// Order may be either Ascending or Descending
	Order SortOrder
}

type StateData interface {
	// Clone is an interface to make a copy of StateData. For performance reasons,
	// clone should make shallow copies for members (e.g., slices or maps) that are not
	// impacted by PreFilter's optional AddPod/RemovePod methods.
	Clone() StateData
}

type StateKey string

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

type StoredUnit interface {
	GetPods() []*QueuedPodInfo
	NumPods() int
	GetKey() string
}