framework

type Affinity struct {
	// Describes cluster affinity scheduling rules for the scheduling unit.
	ClusterAffinity *ClusterAffinity `json:"clusterAffinity,omitempty"`
}

type AutoMigrationInfo struct {
	// Describes the estimated max number of replicas a cluster can accommodate.
	EstimatedCapacity map[string]int64 `json:"estimatedCapacity,omitempty"`
	ScheduledReplicas map[string]int64 `json:"scheduledReplicas,omitempty"`
}

type AutoMigrationSpec struct {
	Info                      *AutoMigrationInfo
	KeepUnschedulableReplicas bool
}

type ClusterAffinity struct {
	// If the affinity requirements specified by this field are not met at
	// scheduling time, the scheduling unit will not be scheduled onto the cluster.
	RequiredDuringSchedulingIgnoredDuringExecution *ClusterSelector `json:"requiredDuringSchedulingIgnoredDuringExecution,omitempty"`
	// The scheduler will prefer to schedule scheduling units to clusters that satisfy
	// the affinity expressions specified by this field, but it may choose
	// a cluster that violates one or more of the expressions. The cluster that is
	// most preferred is the one with the greatest sum of weights, i.e.
	// for each cluster that meets all of the scheduling requirements (resource
	// request, requiredDuringScheduling affinity expressions, etc.),
	// compute a sum by iterating through the elements of this field and adding
	// "weight" to the sum if the cluster matches the corresponding matchExpressions; the
	// cluster(s) with the highest sum are the most preferred.
	// +optional
	PreferredDuringSchedulingIgnoredDuringExecution []PreferredSchedulingTerm `json:"preferredDuringSchedulingIgnoredDuringExecution,omitempty"`
}

type ClusterReplicas struct {
	Cluster  *fedcorev1a1.FederatedCluster
	Replicas int64
}

type ClusterReplicasList []ClusterReplicas

type ClusterScore struct {
	Cluster *fedcorev1a1.FederatedCluster
	Score   int64
}

type ClusterScoreList []ClusterScore

type ClusterSelector struct {
	// A list of cluster selector terms. The terms are ORed.
	ClusterSelectorTerms []fedcorev1a1.ClusterSelectorTerm `json:"clusterSelectorTerms"`
}

type ClusterToResultMap map[string]*Result

type Code int

type CustomMigrationInfo struct {
	// Describes the max number of replicas a cluster can accommodate.
	// Different from `maxReplicas` in policy, LimitedCapacity is not affected by `avoidDisruption`
	// and is a constraint that must be satisfied.
	LimitedCapacity map[string]int64 `json:"limitedCapacity,omitempty"`
	// Describes the list of unavailable clusters.
	UnavailableClusters []UnavailableCluster `json:"unavailableClusters,omitempty"`
}

type CustomMigrationSpec struct {
	Info *CustomMigrationInfo
}

type Diagnosis struct {
	ClusterToResultMap   ClusterToResultMap
	UnschedulablePlugins sets.Set[string]
}

type FilterPlugin interface {
	Plugin

	// Filter is called by the scheduling framework.
	Filter(context.Context, *SchedulingUnit, *fedcorev1a1.FederatedCluster) *Result
}

type FitError struct {
	NumAllClusters int
	Diagnosis      Diagnosis
}

type Framework interface {
	RunFilterPlugins(context.Context, *SchedulingUnit, *fedcorev1a1.FederatedCluster) *Result
	RunScorePlugins(context.Context, *SchedulingUnit, []*fedcorev1a1.FederatedCluster) (PluginToClusterScore, *Result)
	RunSelectClustersPlugin(context.Context, *SchedulingUnit, ClusterScoreList) ([]*fedcorev1a1.FederatedCluster, *Result)
	RunReplicasPlugin(context.Context, *SchedulingUnit, []*fedcorev1a1.FederatedCluster) (ClusterReplicasList, *Result)
}

type Handle interface {
	DynamicClient() dynamic.Interface
}

type InsufficientResource struct {
	ResourceName corev1.ResourceName
	// We explicitly have a parameter for reason to avoid formatting a message on the fly
	// for common resources, which is expensive for cluster autoscaler simulations.
	Reason    string
	Requested int64
	Used      int64
	Capacity  int64
}

type MigrationConfig struct {
	// Describes the migration configuration for replicas in member clusters.
	ReplicasMigrations []ReplicasMigration `json:"replicasMigrations,omitempty"`
	// Describes the migration configuration for workloads in member clusters.
	WorkloadMigrations []WorkloadMigration `json:"workloadMigrations,omitempty"`
}

type Plugin interface {
	Name() string
}

type PluginToClusterScore map[string]ClusterScoreList

type PreferredSchedulingTerm struct {
	// Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
	Weight int32 `json:"weight"`
	// A node selector term, associated with the corresponding weight.
	Preference fedcorev1a1.ClusterSelectorTerm `json:"preference"`
}

type ReplicasMigration struct {
	Cluster string `json:"cluster"`
	// Describes the max number of replicas a cluster can accommodate.
	// Different from `maxReplicas` in policy, LimitedCapacity is not affected by `avoidDisruption`
	// and is a constraint that must be satisfied.
	LimitedCapacity *int64 `json:"limitedCapacity"`
}

type ReplicasPlugin interface {
	Plugin

	ReplicaScheduling(context.Context, *SchedulingUnit, []*fedcorev1a1.FederatedCluster) (ClusterReplicasList, *Result)
}

type Resource struct {
	MilliCPU         int64 `json:"millicpu"`
	Memory           int64 `json:"memory"`
	EphemeralStorage int64 `json:"ephemeralStorage"`
	// ScalarResources
	ScalarResources map[corev1.ResourceName]int64 `json:"scalarResources"`
}

type ResourceName string

type ResourceToValueMap map[corev1.ResourceName]int64

type ResourceToWeightMap map[corev1.ResourceName]int64

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

type SchedulingUnit struct {
	GroupVersion schema.GroupVersion
	Kind         string
	Resource     string

	Namespace   string
	Name        string
	Labels      map[string]string
	Annotations map[string]string

	// Only care about the requests resources
	// TODO(all), limit resources, Best Effort resources
	// The Resource and total replica could be deliver by resource type
	// or define by annotations
	// Describes the schedule request
	DesiredReplicas *int64
	ResourceRequest Resource

	// Describes the current scheduling state
	CurrentClusters map[string]*int64
	AutoMigration   *AutoMigrationSpec
	CustomMigration CustomMigrationSpec

	// Controls the scheduling behavior
	SchedulingMode   fedcorev1a1.SchedulingMode
	ReplicasStrategy fedcorev1a1.ReplicasStrategy
	StickyCluster    bool
	AvoidDisruption  bool

	// Used to filter/select clusters
	ClusterSelector map[string]string
	ClusterNames    map[string]struct{}
	Affinity        *Affinity
	Tolerations     []corev1.Toleration
	MaxClusters     *int64
	MinReplicas     map[string]int64
	MaxReplicas     map[string]int64
	Weights         map[string]int64
	Priorities      map[string]int64

	EnableKatalystSupport bool
}

type ScoreExtensions interface {
	// NormalizeScore is called for all cluster 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(context.Context, ClusterScoreList) *Result
}

type ScorePlugin interface {
	Plugin

	// Score is called on each filtered Cluster. It must return success and an integer
	// indicating the rank of the cluster. All scoring plugins must return success or
	// the pod will be rejected.
	Score(context.Context, *SchedulingUnit, *fedcorev1a1.FederatedCluster) (int64, *Result)

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

type SelectPlugin interface {
	Plugin

	SelectClusters(context.Context, *SchedulingUnit, ClusterScoreList) (ClusterScoreList, *Result)
}

type UnavailableCluster struct {
	Cluster    string      `json:"cluster"`
	ValidUntil metav1.Time `json:"validUntil"`
}

type WorkloadMigration struct {
	Cluster string `json:"cluster"`
	// Describes the timestamp after which workloads will no longer be evicted from the cluster.
	ValidUntil *metav1.Time `json:"validUntil"`
}