sharding

type AssignmentCache struct {
	Version     string
	Timestamp   time.Time
	Assignments map[string]*ShardAssignment // scheduler name -> assignment
}

type AssignmentChangeEvent struct {
	SchedulerName string
	OldNodes      []string
	NewNodes      []string
	NodesToAdd    []string
	NodesToRemove []string
	Version       string
	Timestamp     time.Time
}

type AssignmentContext struct {
	AllNodes         []*corev1.Node
	CurrentShards    map[string]*shardv1alpha1.NodeShard
	SchedulerConfigs []SchedulerConfig
	AssignedNodes    map[string]string // node name -> scheduler name
	Timestamp        time.Time
}

type NodeEvent struct {
	EventType string // "pod-added", "pod-updated", "pod-deleted", "node-updated"
	NodeName  string
	Source    string // "pod-controller", "node-controller"
	Timestamp time.Time
}

type NodeMetrics struct {
	NodeName        string
	ResourceVersion string
	LastUpdated     time.Time

	// Resource capacity and allocatable
	CPUCapacity       resource.Quantity
	CPUAllocatable    resource.Quantity
	MemoryCapacity    resource.Quantity
	MemoryAllocatable resource.Quantity

	// Resource utilization
	CPUUtilization    float64 // 0.0 to 1.0
	MemoryUtilization float64 // 0.0 to 1.0

	// Node characteristics
	IsWarmupNode bool
	PodCount     int
	Labels       map[string]string
	Annotations  map[string]string
}

type NodeMetricsProvider interface {
	GetNodeMetrics(nodeName string) *NodeMetrics
	GetAllNodeMetrics() map[string]*NodeMetrics
	UpdateNodeMetrics(nodeName string, metrics *NodeMetrics)
}

type NodeResourceInfo struct {
	NodeName          string
	CPUAllocatable    resource.Quantity
	CPUCapacity       resource.Quantity
	MemoryAllocatable resource.Quantity
	MemoryCapacity    resource.Quantity
	CPUUtilization    float64 // 0.0 to 1.0
	MemoryUtilization float64 // 0.0 to 1.0
	IsWarmupNode      bool
	PodCount          int
	Labels            map[string]string
	Annotations       map[string]string
}

type PolicyRef struct {
	Name      string                 // registered policy name (e.g. "allocation-rate")
	Weight    int                    // applied to Score output; default 1; only meaningful for Scorers
	Arguments map[string]interface{} // policy-specific arguments
}

type PolicySpec struct {
	// Name is the registered policy name (e.g. "allocation-rate", "warmup").
	Name string `json:"name"`
	// Weight scales the policy's Score contribution; default 1. Only
	// meaningful for policies that implement the Scorer interface.
	Weight int `json:"weight,omitempty"`
	// Arguments holds policy-specific arguments. minNodes/maxNodes are only
	// valid on the node-limit policy.
	Arguments map[string]interface{} `json:"arguments,omitempty"`
}

type SchedulerConfig struct {
	Name string
	Type string // "volcano" or "agent"

	// Policies is the per-scheduler policy chain. Filterers contribute to
	// filter (OR-union); Scorers to score (weighted sum). Empty means no
	// policy participation in those phases.
	Policies []PolicyRef

	// MinNodes and MaxNodes are common (non-policy-specific) bounds on the
	// number of nodes assigned to this scheduler. The sharding controller
	// clamps the policy output to this range; policies do not see them.
	MinNodes int
	MaxNodes int
}

type SchedulerConfigSpec struct {
	// Name is the scheduler name (must match the schedulerName field in NodeShard).
	Name string `json:"name"`
	// Type describes the workload class (e.g. "volcano", "agent").
	Type string `json:"type"`

	// Policies is the per-scheduler policy chain. When empty,
	// applyPolicyDefaults synthesizes a default chain from legacy fields.
	Policies []PolicySpec `json:"policies,omitempty"`
	// Arguments holds legacy single-policy arguments. Deprecated: use Policies.
	Arguments map[string]interface{} `json:"arguments,omitempty"`
	// CPUUtilizationMin is the lower bound (inclusive) of the CPU utilisation range
	// [0.0, 1.0] that makes a node eligible for this scheduler's shard.
	//
	// Deprecated: use Policies instead.
	CPUUtilizationMin float64 `json:"cpuUtilizationMin"`
	// CPUUtilizationMax is the upper bound (inclusive) of the CPU utilisation range.
	//
	// Deprecated: use Policies instead.
	CPUUtilizationMax float64 `json:"cpuUtilizationMax"`
	// PreferWarmupNodes indicates whether warmup nodes should be sorted before
	// regular nodes when selecting shard members.
	//
	// Deprecated: use Policies (add a "warmup" entry) instead.
	PreferWarmupNodes bool `json:"preferWarmupNodes"`

	// MinNodes is informational only: the framework cannot synthesize nodes
	// that don't exist. If the policy chain returns fewer than MinNodes, the
	// shortfall is logged but the result is not padded. Scheduler-level
	// scalar; not a per-policy setting.
	//
	// Deprecated: use Policies (add a "node-limit" entry) instead.
	MinNodes int `json:"minNodes"`
	// MaxNodes is a hard cap. The policy-selected node list is truncated to
	// at most MaxNodes by the framework. Scheduler-level scalar; not a
	// per-policy setting. MaxNodes <= 0 means "no upper bound".
	//
	// Deprecated: use Policies (add a "node-limit" entry) instead.
	MaxNodes int `json:"maxNodes"`
}

type ShardAssignment struct {
	SchedulerName string
	NodesDesired  []string
	Version       string
}

type ShardingConfig struct {
	// SchedulerConfigs holds the per-scheduler shard specifications.
	SchedulerConfigs []SchedulerConfigSpec `json:"schedulerConfigs"`
	// ShardSyncPeriod overrides the periodic sync interval when set.
	// Accepts Go duration strings such as "60s", "2m".
	ShardSyncPeriod string `json:"shardSyncPeriod,omitempty"`
	// EnableNodeEventTrigger controls event-driven shard updates.
	EnableNodeEventTrigger *bool `json:"enableNodeEventTrigger,omitempty"`
}

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

type ShardingControllerOptions struct {
	// SchedulerConfigsRaw holds the legacy colon-separated scheduler config
	// strings, provided via --scheduler-configs flag.
	SchedulerConfigsRaw []string
	// SchedulerConfigs is the parsed representation of SchedulerConfigsRaw.
	SchedulerConfigs []SchedulerConfigSpec
	// ShardSyncPeriod is the period between full shard reconciliations.
	ShardSyncPeriod time.Duration
	// EnableNodeEventTrigger controls whether node/pod events trigger immediate
	// shard reconciliation.
	EnableNodeEventTrigger bool
	// ConfigMapName is the name of the ConfigMap that holds the sharding
	// configuration.  When non-empty, the controller prefers ConfigMap-based
	// configuration over flag-based configuration and watches the ConfigMap
	// for live updates.
	ConfigMapName string
	// ConfigMapNamespace is the namespace of the sharding ConfigMap.
	ConfigMapNamespace string
}

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

type TestControllerOption struct {
	InitialObjects   []runtime.Object
	SchedulerConfigs []SchedulerConfigSpec
	ShardSyncPeriod  time.Duration
	StopCh           chan struct{}
	// SkipConfigMap, when true, omits the sharding ConfigMap from the fake
	// client so the controller exercises the flag-based fallback path.
	SkipConfigMap bool
}

type TestShardingController struct {
	Controller *ShardingController
	StopCh     chan struct{}
}