func (npa *NodePreferAvoidPod) CalculateNodePreferAvoidPodsPriority(pod *api.Pod, nodeNameToInfo map[string]*schedulercache.NodeInfo, nodes []*api.Node) (schedulerapi.HostPriorityList, error) { // TODO: Once we have ownerReference fully implemented, use it to find controller for the pod. rcs, _ := npa.controllerLister.GetPodControllers(pod) rss, _ := npa.replicaSetLister.GetPodReplicaSets(pod) if len(rcs) == 0 && len(rss) == 0 { result := make(schedulerapi.HostPriorityList, 0, len(nodes)) for _, node := range nodes { result = append(result, schedulerapi.HostPriority{Host: node.Name, Score: 10}) } return result, nil } avoidNodes := make(map[string]bool, len(nodes)) avoidNode := false for _, node := range nodes { avoids, err := api.GetAvoidPodsFromNodeAnnotations(node.Annotations) if err != nil { continue } avoidNode = false for i := range avoids.PreferAvoidPods { avoid := &avoids.PreferAvoidPods[i] // TODO: Once we have controllerRef implemented there will be at most one owner // of our pod. That said we won't even need loop theoretically. That said for // code simplicity, we can get rid of all breaks. // Also, we can simply compare fields from ownerRef with avoid. for _, rc := range rcs { if avoid.PodSignature.PodController.Kind == "ReplicationController" && avoid.PodSignature.PodController.UID == rc.UID { avoidNode = true } } for _, rs := range rss { if avoid.PodSignature.PodController.Kind == "ReplicaSet" && avoid.PodSignature.PodController.UID == rs.UID { avoidNode = true } } if avoidNode { // false is default value, so we don't even need to set it // to avoid unnecessary map operations. avoidNodes[node.Name] = true break } } } var score int result := make(schedulerapi.HostPriorityList, 0, len(nodes)) //score int - scale of 0-10 // 0 being the lowest priority and 10 being the highest for _, node := range nodes { if avoidNodes[node.Name] { score = 0 } else { score = 10 } result = append(result, schedulerapi.HostPriority{Host: node.Name, Score: score}) } return result, nil }
func CalculateNodePreferAvoidPodsPriorityMap(pod *api.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (schedulerapi.HostPriority, error) { node := nodeInfo.Node() if node == nil { return schedulerapi.HostPriority{}, fmt.Errorf("node not found") } controllerRef := priorityutil.GetControllerRef(pod) if controllerRef != nil { // Ignore pods that are owned by other controller than ReplicationController // or ReplicaSet. if controllerRef.Kind != "ReplicationController" && controllerRef.Kind != "ReplicaSet" { controllerRef = nil } } if controllerRef == nil { return schedulerapi.HostPriority{Host: node.Name, Score: 10}, nil } avoids, err := api.GetAvoidPodsFromNodeAnnotations(node.Annotations) if err != nil { // If we cannot get annotation, assume it's schedulable there. return schedulerapi.HostPriority{Host: node.Name, Score: 10}, nil } for i := range avoids.PreferAvoidPods { avoid := &avoids.PreferAvoidPods[i] if controllerRef != nil { if avoid.PodSignature.PodController.Kind == controllerRef.Kind && avoid.PodSignature.PodController.UID == controllerRef.UID { return schedulerapi.HostPriority{Host: node.Name, Score: 0}, nil } } } return schedulerapi.HostPriority{Host: node.Name, Score: 10}, nil }