core

type Candidater interface {
	// IndexKey return candidate cache item's ident, usually host ID
	IndexKey() string
	// Get return candidate cache item's value by key
	Get(key string) interface{}
	// XGet return candidate cache item's value by key and kind
	XGet(key string, kind Kind) interface{}
	Type() int

	GetAggregates() []*models.Aggregate
	GetHostAggregates() []*models.Aggregate
}

type Capacity struct {
	Values   map[string]Counter
	MinValue int64
}

type Counter interface {
	GetCount() int64
}

type CounterManager struct {
	Counters map[string]Counter
	// contains filtered or unexported fields
}

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

type DefaultResAlgorithm struct{}

type FailedCandidate struct {
	Stage     string
	Candidate Candidater
	Reasons   []PredicateFailureReason
}

type FailedCandidates struct {
	Candidates []FailedCandidate
}

type FailedPredicateMap map[string][]PredicateFailureReason

type FitError struct {
	Unit               *Unit
	FailedCandidateMap map[string]*FailedCandidates
}

type FitPredicate interface {
	// Get filter's name
	Name() string
	Clone() FitPredicate
	PreExecute(*Unit, []Candidater) (bool, error)
	Execute(*Unit, Candidater) (bool, []PredicateFailureReason, error)
}

type GenericScheduler struct {
	Scheduler
	// contains filtered or unexported fields
}

type HostPriority struct {
	// Name of the host
	Host string
	// Score associated with the host
	Score int
	// Resource wraps Candidate host info
	Candidate Candidater
}

type HostPriorityList []HostPriority

type Kind int

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

type MultiCounter interface {
	Counter
	Add(counter Counter)
}

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

type NormalCounter struct {
	Value int64
}

type PredicateFailureReason interface {
	GetReason() string
}

type Priority interface {
	Name() string
	Clone() Priority
	Map(*Unit, Candidater) (HostPriority, error)
	Reduce(*Unit, []Candidater, HostPriorityList) error
	PreExecute(*Unit, []Candidater) (bool, []PredicateFailureReason, error)
}

type PriorityConfig struct {
	Name   string
	Pre    PriorityPreFunction
	Map    PriorityMapFunction
	Reduce PriorityReduceFunction
	Weight int
}

type PriorityMapFunction func(*Unit, Candidater) (HostPriority, error)

type PriorityPreFunction func(*Unit, []Candidater) (bool, []PredicateFailureReason, error)

type PriorityReduceFunction func(*Unit, []Candidater, HostPriorityList) error

type ResourceAlgorithm interface {
	Sum(values []value_t) value_t
	Sub(sum value_t, reserved value_t) value_t
}

type SchedContextDataItem struct {
	Networks sync.Map
	Data     map[string]interface{}
}

type SchedLog struct {
	Candidate string
	Action    string
	Message   string
}

type SchedLogList []SchedLog

type SchedLogManager struct {
	Logs SchedLogList
	// contains filtered or unexported fields
}

type SchedResultItem struct {
	ID       string                 `json:"id"`
	Name     string                 `json:"name"`
	Count    int64                  `json:"count"`
	Data     map[string]interface{} `json:"data"`
	Capacity int64                  `json:"capacity"`
	Score    int                    `json:"score"`

	CapacityDetails map[string]int64 `json:"capacity_details"`
	ScoreDetails    map[string]int   `json:"score_details"`
}

type SchedResultItemList struct {
	Unit *Unit
	Data []*SchedResultItem
}

type Scheduler interface {
	BeforePredicate() error
	Predicates() (map[string]FitPredicate, error)
	PriorityConfigs() ([]PriorityConfig, error)

	// mark already selected candidates dirty that
	// can't be use again until cleanup them
	DirtySelectedCandidates([]*SelectedCandidate)
}

type Score struct {
	Values map[string]int
	Sum    int
}

type SelectPlugin interface {
	OnSelect(*Unit, Candidater) bool
	OnSelectEnd(u *Unit, c Candidater, count int64)
}

type SelectedCandidate struct {
	Count     int64
	Candidate Candidater
}

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

type Unit struct {
	SchedInfo             *api.SchedInfo
	CapacityMap           map[string]*Capacity
	ScoreMap              map[string]Score
	DataMap               map[string]*SchedContextDataItem
	SharedResourceManager *SharedResourceManager
	CounterManager        *CounterManager

	FailedCandidateMap map[string]*FailedCandidates

	SchedulerManager interface{}

	LogManager *SchedLogManager
	// contains filtered or unexported fields
}

type WaitGroupWrapper struct {
	sync.WaitGroup
}