lib

type APIMonitor struct {
	// A histogram to measure how long the API requests take to run.
	ApiRequestsTimer *prometheus.HistogramVec
}

type ActivationFunction struct{}

type BaseDetector[Opts DetectionStepOpts] struct {
	// Options to pass via yaml to this step.
	Options Opts
	// The kubernetes client to use.
	Client client.Client
}

type BaseFilter[RequestType FilterWeigherPipelineRequest, Opts FilterWeigherPipelineStepOpts] struct {
	BaseFilterWeigherPipelineStep[RequestType, Opts]
}

type BaseFilterWeigherPipelineStep[RequestType FilterWeigherPipelineRequest, Opts FilterWeigherPipelineStepOpts] struct {
	// Options to pass via yaml to this step.
	Options Opts
	// The activation function to use.
	ActivationFunction
	// The kubernetes client to use.
	Client client.Client
}

type BasePipelineController[PipelineType any] struct {
	// Initialized pipelines by their name.
	Pipelines map[string]PipelineType
	// The configured pipelines by their name.
	PipelineConfigs map[string]v1alpha1.Pipeline
	// Delegate to create pipelines.
	Initializer PipelineInitializer[PipelineType]
	// Kubernetes client to manage/fetch resources.
	client.Client
	// The scheduling domain to scope resources to.
	SchedulingDomain v1alpha1.SchedulingDomain
	// Manager for creating, updating, and deleting History CRDs.
	HistoryManager HistoryClient
}

type BaseWeigher[RequestType FilterWeigherPipelineRequest, Opts FilterWeigherPipelineStepOpts] struct {
	BaseFilterWeigherPipelineStep[RequestType, Opts]
}

type Detection interface {
	// Get the ID of the detected resource.
	GetResource() string
	// Get the host on which this resource is currently located.
	GetHost() string
	// Get the reason for the detection.
	GetReason() string
	// Set the reason for the detection.
	WithReason(reason string) Detection
}

type DetectionStepOpts interface {
	// Validate the options for this step.
	Validate() error
}

type Detector[DetectionType Detection] interface {
	// Detect resources such as VMs on their current hosts that should be
	// considered for descheduling.
	Run() ([]DetectionType, error)

	// Initialize the step.
	Init(ctx context.Context, client client.Client, step v1alpha1.DetectorSpec) error

	// Validate that the given config is valid for this step. This is used in
	// the pipeline validation to check if the pipeline configuration is valid
	// without actually initializing the step.
	Validate(ctx context.Context, params v1alpha1.Parameters) error
}

type DetectorCycleBreaker[DetectionType Detection] interface {
	// Filter descheduling decisions to avoid cycles.
	Filter(ctx context.Context, decisions []DetectionType) ([]DetectionType, error)
}

type DetectorMonitor[DetectionType Detection] struct {
	// contains filtered or unexported fields
}

type DetectorPipeline[DetectionType Detection] struct {
	// Kubernetes client to create descheduling resources.
	client.Client
	// Cycle detector to avoid cycles in descheduling.
	Breaker DetectorCycleBreaker[DetectionType]
	// Monitor to use for tracking the pipeline.
	Monitor DetectorPipelineMonitor
	// contains filtered or unexported fields
}

type DetectorPipelineMonitor struct {

	// The name of the pipeline being monitored.
	PipelineName string
	// contains filtered or unexported fields
}

type EmptyDetectionStepOpts struct{}

type EmptyFilterWeigherPipelineStepOpts struct{}

type Filter[RequestType FilterWeigherPipelineRequest] interface {
	FilterWeigherPipelineStep[RequestType]

	// Configure the filter and initialize things like a database connection.
	Init(ctx context.Context, client client.Client, step v1alpha1.FilterSpec) error

	// Validate the given config parameters for this filter.
	Validate(ctx context.Context, params v1alpha1.Parameters) error
}

type FilterMonitor[RequestType FilterWeigherPipelineRequest] struct {
	// contains filtered or unexported fields
}

type FilterValidator[RequestType FilterWeigherPipelineRequest] struct {
	// The wrapped filter to validate.
	Filter Filter[RequestType]
}

type FilterWeigherPipeline[RequestType FilterWeigherPipelineRequest] interface {
	// Run the scheduling pipeline with the given request.
	Run(request RequestType) (v1alpha1.DecisionResult, error)
}

type FilterWeigherPipelineMonitor struct {
	// The pipeline name is used to differentiate between different pipelines.
	PipelineName string
	// contains filtered or unexported fields
}

type FilterWeigherPipelineRequest interface {
	// Get the hosts that went in the pipeline.
	GetHosts() []string
	// This function can be used by the pipeline to obtain a mutated version
	// of the request with only the given hosts remaining. This is helpful
	// for steps that filter out hosts. Hosts not included in the map
	// are considered as filtered out, and won't be reconsidered in later steps.
	// This function should also update the weights of the remaining hosts
	// accordingly, so that the weights map always corresponds to the hosts
	// that are currently in the request.
	Filter(includedHosts map[string]float64) FilterWeigherPipelineRequest
	// Get the weights for the hosts.
	GetWeights() map[string]float64
	// Get logging args to be used in the step's trace log.
	// Usually, this will be the request context including the request ID.
	GetTraceLogArgs() []slog.Attr
}

type FilterWeigherPipelineStep[RequestType FilterWeigherPipelineRequest] interface {
	// Run this step in the scheduling pipeline.
	//
	// The request is immutable and modifications are stored in the result.
	// This allows steps to be run in parallel (e.g. weighers) without passing
	// mutable state around.
	//
	// All hosts that should not be filtered out must be included in the returned
	// map of activations. I.e., filters implementing this interface should
	// remove activations by omitting them from the returned map.
	//
	// Filters implementing this interface should adjust activation
	// values in the returned map, including all hosts from the request.
	//
	// A traceLog is provided that contains the global request id and should
	// be used to log the step's execution.
	Run(traceLog *slog.Logger, request RequestType) (*FilterWeigherPipelineStepResult, error)
}

type FilterWeigherPipelineStepMonitor[RequestType FilterWeigherPipelineRequest] struct {
	// Mixin that can be embedded in a step to provide some activation function tooling.
	ActivationFunction
	// contains filtered or unexported fields
}

type FilterWeigherPipelineStepOpts interface {
	// Validate the options for this step.
	Validate() error
}

type FilterWeigherPipelineStepResult struct {
	// The activations calculated by this step.
	Activations map[string]float64

	// Step statistics like:
	//
	//	{
	//	  "max cpu contention": {
	//	     "unit": "cpu contention [%]",
	//	     "hosts": { "host 1": 10, "host 2": 10 }
	//	   },
	//	  "noisy projects": {
	//	     "unit": "vms of this project running on host [#]",
	//	     "hosts": { "host 1": 1, "host 2": 0 }
	//	   }
	//	}
	//
	// These statistics are used to display the step's effect on the hosts.
	// For example: max cpu contention: before [ 100%, 50%, 40% ], after [ 40%, 50%, 100% ]
	Statistics map[string]FilterWeigherPipelineStepStatistics
}

type FilterWeigherPipelineStepStatistics struct {
	// The unit of the statistic.
	Unit string
	// The hosts and their values.
	Hosts map[string]float64
}

type HistoryClient struct {
	Client   client.Client
	Recorder events.EventRecorder
}

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

type PipelineAdmissionWebhook struct {
	// The scheduling domain this webhook handles (e.g., nova, cinder, manila).
	SchedulingDomain v1alpha1.SchedulingDomain
	// ValidatableFilters maps filter names to validatable filter instances.
	ValidatableFilters map[string]Validatable
	// ValidatableWeighers maps weigher names to validatable weigher instances.
	ValidatableWeighers map[string]Validatable
	// ValidatableDetectors maps detector names to validatable detector instances.
	ValidatableDetectors map[string]Validatable
}

type PipelineInitResult[PipelineType any] struct {
	// The pipeline, if successfully created.
	Pipeline PipelineType

	// Errors for filters, if any, by their name.
	FilterErrors map[string]error
	// Unknown filters that were referenced but not found in the index, by their name.
	UnknownFilters []string
	// Errors for weighers, if any, by their name.
	WeigherErrors map[string]error
	// Unknown weighers that were referenced but not found in the index, by their name.
	UnknownWeighers []string
	// Errors for detectors, if any, by their name.
	DetectorErrors map[string]error
	// Unknown detectors that were referenced but not found in the index, by their name.
	UnknownDetectors []string
}

type PipelineInitializer[PipelineType any] interface {
	// Initialize a new pipeline with the given steps.
	//
	// This method is delegated to the parent controller, when a pipeline needs
	// to be newly initialized or re-initialized to update it in the pipeline
	// map.
	InitPipeline(ctx context.Context, p v1alpha1.Pipeline) PipelineInitResult[PipelineType]

	// Get the accepted pipeline type for this controller.
	//
	// This is used to filter pipelines when listing existing pipelines on
	// startup or when reacting to pipeline events.
	PipelineType() v1alpha1.PipelineType
}

type Validatable interface {
	// Validate checks if the given parameters are valid for this step.
	Validate(ctx context.Context, params v1alpha1.Parameters) error
}

type Weigher[RequestType FilterWeigherPipelineRequest] interface {
	FilterWeigherPipelineStep[RequestType]

	// Configure the step and initialize things like a database connection.
	Init(ctx context.Context, client client.Client, step v1alpha1.WeigherSpec) error

	// Validate the given config parameters for this weigher.
	Validate(ctx context.Context, params v1alpha1.Parameters) error
}

type WeigherMonitor[RequestType FilterWeigherPipelineRequest] struct {
	// contains filtered or unexported fields
}

type WeigherValidator[RequestType FilterWeigherPipelineRequest] struct {
	// The wrapped weigher to validate.
	Weigher Weigher[RequestType]
}