mirror of
https://github.com/optim-enterprises-bv/kubernetes.git
synced 2025-10-31 18:28:13 +00:00
343 lines
11 KiB
Go
343 lines
11 KiB
Go
/*
|
|
Copyright 2014 The Kubernetes Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package v1
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"k8s.io/apimachinery/pkg/api/resource"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/kubernetes/pkg/api"
|
|
)
|
|
|
|
// Returns string version of ResourceName.
|
|
func (self ResourceName) String() string {
|
|
return string(self)
|
|
}
|
|
|
|
// Returns the CPU limit if specified.
|
|
func (self *ResourceList) Cpu() *resource.Quantity {
|
|
if val, ok := (*self)[ResourceCPU]; ok {
|
|
return &val
|
|
}
|
|
return &resource.Quantity{Format: resource.DecimalSI}
|
|
}
|
|
|
|
// Returns the Memory limit if specified.
|
|
func (self *ResourceList) Memory() *resource.Quantity {
|
|
if val, ok := (*self)[ResourceMemory]; ok {
|
|
return &val
|
|
}
|
|
return &resource.Quantity{Format: resource.BinarySI}
|
|
}
|
|
|
|
func (self *ResourceList) Pods() *resource.Quantity {
|
|
if val, ok := (*self)[ResourcePods]; ok {
|
|
return &val
|
|
}
|
|
return &resource.Quantity{}
|
|
}
|
|
|
|
func (self *ResourceList) NvidiaGPU() *resource.Quantity {
|
|
if val, ok := (*self)[ResourceNvidiaGPU]; ok {
|
|
return &val
|
|
}
|
|
return &resource.Quantity{}
|
|
}
|
|
|
|
func GetContainerStatus(statuses []ContainerStatus, name string) (ContainerStatus, bool) {
|
|
for i := range statuses {
|
|
if statuses[i].Name == name {
|
|
return statuses[i], true
|
|
}
|
|
}
|
|
return ContainerStatus{}, false
|
|
}
|
|
|
|
func GetExistingContainerStatus(statuses []ContainerStatus, name string) ContainerStatus {
|
|
for i := range statuses {
|
|
if statuses[i].Name == name {
|
|
return statuses[i]
|
|
}
|
|
}
|
|
return ContainerStatus{}
|
|
}
|
|
|
|
// IsPodAvailable returns true if a pod is available; false otherwise.
|
|
// Precondition for an available pod is that it must be ready. On top
|
|
// of that, there are two cases when a pod can be considered available:
|
|
// 1. minReadySeconds == 0, or
|
|
// 2. LastTransitionTime (is set) + minReadySeconds < current time
|
|
func IsPodAvailable(pod *Pod, minReadySeconds int32, now metav1.Time) bool {
|
|
if !IsPodReady(pod) {
|
|
return false
|
|
}
|
|
|
|
c := GetPodReadyCondition(pod.Status)
|
|
minReadySecondsDuration := time.Duration(minReadySeconds) * time.Second
|
|
if minReadySeconds == 0 || !c.LastTransitionTime.IsZero() && c.LastTransitionTime.Add(minReadySecondsDuration).Before(now.Time) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// IsPodReady returns true if a pod is ready; false otherwise.
|
|
func IsPodReady(pod *Pod) bool {
|
|
return IsPodReadyConditionTrue(pod.Status)
|
|
}
|
|
|
|
// IsPodReady retruns true if a pod is ready; false otherwise.
|
|
func IsPodReadyConditionTrue(status PodStatus) bool {
|
|
condition := GetPodReadyCondition(status)
|
|
return condition != nil && condition.Status == ConditionTrue
|
|
}
|
|
|
|
// Extracts the pod ready condition from the given status and returns that.
|
|
// Returns nil if the condition is not present.
|
|
func GetPodReadyCondition(status PodStatus) *PodCondition {
|
|
_, condition := GetPodCondition(&status, PodReady)
|
|
return condition
|
|
}
|
|
|
|
// GetPodCondition extracts the provided condition from the given status and returns that.
|
|
// Returns nil and -1 if the condition is not present, and the index of the located condition.
|
|
func GetPodCondition(status *PodStatus, conditionType PodConditionType) (int, *PodCondition) {
|
|
if status == nil {
|
|
return -1, nil
|
|
}
|
|
for i := range status.Conditions {
|
|
if status.Conditions[i].Type == conditionType {
|
|
return i, &status.Conditions[i]
|
|
}
|
|
}
|
|
return -1, nil
|
|
}
|
|
|
|
// GetNodeCondition extracts the provided condition from the given status and returns that.
|
|
// Returns nil and -1 if the condition is not present, and the index of the located condition.
|
|
func GetNodeCondition(status *NodeStatus, conditionType NodeConditionType) (int, *NodeCondition) {
|
|
if status == nil {
|
|
return -1, nil
|
|
}
|
|
for i := range status.Conditions {
|
|
if status.Conditions[i].Type == conditionType {
|
|
return i, &status.Conditions[i]
|
|
}
|
|
}
|
|
return -1, nil
|
|
}
|
|
|
|
// Updates existing pod condition or creates a new one. Sets LastTransitionTime to now if the
|
|
// status has changed.
|
|
// Returns true if pod condition has changed or has been added.
|
|
func UpdatePodCondition(status *PodStatus, condition *PodCondition) bool {
|
|
condition.LastTransitionTime = metav1.Now()
|
|
// Try to find this pod condition.
|
|
conditionIndex, oldCondition := GetPodCondition(status, condition.Type)
|
|
|
|
if oldCondition == nil {
|
|
// We are adding new pod condition.
|
|
status.Conditions = append(status.Conditions, *condition)
|
|
return true
|
|
} else {
|
|
// We are updating an existing condition, so we need to check if it has changed.
|
|
if condition.Status == oldCondition.Status {
|
|
condition.LastTransitionTime = oldCondition.LastTransitionTime
|
|
}
|
|
|
|
isEqual := condition.Status == oldCondition.Status &&
|
|
condition.Reason == oldCondition.Reason &&
|
|
condition.Message == oldCondition.Message &&
|
|
condition.LastProbeTime.Equal(oldCondition.LastProbeTime) &&
|
|
condition.LastTransitionTime.Equal(oldCondition.LastTransitionTime)
|
|
|
|
status.Conditions[conditionIndex] = *condition
|
|
// Return true if one of the fields have changed.
|
|
return !isEqual
|
|
}
|
|
}
|
|
|
|
// IsNodeReady returns true if a node is ready; false otherwise.
|
|
func IsNodeReady(node *Node) bool {
|
|
for _, c := range node.Status.Conditions {
|
|
if c.Type == NodeReady {
|
|
return c.Status == ConditionTrue
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// PodRequestsAndLimits returns a dictionary of all defined resources summed up for all
|
|
// containers of the pod.
|
|
func PodRequestsAndLimits(pod *Pod) (reqs map[ResourceName]resource.Quantity, limits map[ResourceName]resource.Quantity, err error) {
|
|
reqs, limits = map[ResourceName]resource.Quantity{}, map[ResourceName]resource.Quantity{}
|
|
for _, container := range pod.Spec.Containers {
|
|
for name, quantity := range container.Resources.Requests {
|
|
if value, ok := reqs[name]; !ok {
|
|
reqs[name] = *quantity.Copy()
|
|
} else {
|
|
value.Add(quantity)
|
|
reqs[name] = value
|
|
}
|
|
}
|
|
for name, quantity := range container.Resources.Limits {
|
|
if value, ok := limits[name]; !ok {
|
|
limits[name] = *quantity.Copy()
|
|
} else {
|
|
value.Add(quantity)
|
|
limits[name] = value
|
|
}
|
|
}
|
|
}
|
|
// init containers define the minimum of any resource
|
|
for _, container := range pod.Spec.InitContainers {
|
|
for name, quantity := range container.Resources.Requests {
|
|
value, ok := reqs[name]
|
|
if !ok {
|
|
reqs[name] = *quantity.Copy()
|
|
continue
|
|
}
|
|
if quantity.Cmp(value) > 0 {
|
|
reqs[name] = *quantity.Copy()
|
|
}
|
|
}
|
|
for name, quantity := range container.Resources.Limits {
|
|
value, ok := limits[name]
|
|
if !ok {
|
|
limits[name] = *quantity.Copy()
|
|
continue
|
|
}
|
|
if quantity.Cmp(value) > 0 {
|
|
limits[name] = *quantity.Copy()
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// finds and returns the request for a specific resource.
|
|
func GetResourceRequest(pod *Pod, resource ResourceName) int64 {
|
|
if resource == ResourcePods {
|
|
return 1
|
|
}
|
|
totalResources := int64(0)
|
|
for _, container := range pod.Spec.Containers {
|
|
if rQuantity, ok := container.Resources.Requests[resource]; ok {
|
|
if resource == ResourceCPU {
|
|
totalResources += rQuantity.MilliValue()
|
|
} else {
|
|
totalResources += rQuantity.Value()
|
|
}
|
|
}
|
|
}
|
|
// take max_resource(sum_pod, any_init_container)
|
|
for _, container := range pod.Spec.InitContainers {
|
|
if rQuantity, ok := container.Resources.Requests[resource]; ok {
|
|
if resource == ResourceCPU && rQuantity.MilliValue() > totalResources {
|
|
totalResources = rQuantity.MilliValue()
|
|
} else if rQuantity.Value() > totalResources {
|
|
totalResources = rQuantity.Value()
|
|
}
|
|
}
|
|
}
|
|
return totalResources
|
|
}
|
|
|
|
// ExtractResourceValueByContainerName extracts the value of a resource
|
|
// by providing container name
|
|
func ExtractResourceValueByContainerName(fs *ResourceFieldSelector, pod *Pod, containerName string) (string, error) {
|
|
container, err := findContainerInPod(pod, containerName)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return ExtractContainerResourceValue(fs, container)
|
|
}
|
|
|
|
// ExtractResourceValueByContainerNameAndNodeAllocatable extracts the value of a resource
|
|
// by providing container name and node allocatable
|
|
func ExtractResourceValueByContainerNameAndNodeAllocatable(fs *ResourceFieldSelector, pod *Pod, containerName string, nodeAllocatable ResourceList) (string, error) {
|
|
realContainer, err := findContainerInPod(pod, containerName)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
containerCopy, err := api.Scheme.DeepCopy(realContainer)
|
|
if err != nil {
|
|
return "", fmt.Errorf("failed to perform a deep copy of container object: %v", err)
|
|
}
|
|
|
|
container, ok := containerCopy.(*Container)
|
|
if !ok {
|
|
return "", fmt.Errorf("unexpected type returned from deep copy of container object")
|
|
}
|
|
|
|
MergeContainerResourceLimits(container, nodeAllocatable)
|
|
|
|
return ExtractContainerResourceValue(fs, container)
|
|
}
|
|
|
|
// ExtractContainerResourceValue extracts the value of a resource
|
|
// in an already known container
|
|
func ExtractContainerResourceValue(fs *ResourceFieldSelector, container *Container) (string, error) {
|
|
divisor := resource.Quantity{}
|
|
if divisor.Cmp(fs.Divisor) == 0 {
|
|
divisor = resource.MustParse("1")
|
|
} else {
|
|
divisor = fs.Divisor
|
|
}
|
|
|
|
switch fs.Resource {
|
|
case "limits.cpu":
|
|
return api.ConvertResourceCPUToString(container.Resources.Limits.Cpu(), divisor)
|
|
case "limits.memory":
|
|
return api.ConvertResourceMemoryToString(container.Resources.Limits.Memory(), divisor)
|
|
case "requests.cpu":
|
|
return api.ConvertResourceCPUToString(container.Resources.Requests.Cpu(), divisor)
|
|
case "requests.memory":
|
|
return api.ConvertResourceMemoryToString(container.Resources.Requests.Memory(), divisor)
|
|
}
|
|
|
|
return "", fmt.Errorf("Unsupported container resource : %v", fs.Resource)
|
|
}
|
|
|
|
// findContainerInPod finds a container by its name in the provided pod
|
|
func findContainerInPod(pod *Pod, containerName string) (*Container, error) {
|
|
for _, container := range pod.Spec.Containers {
|
|
if container.Name == containerName {
|
|
return &container, nil
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("container %s not found", containerName)
|
|
}
|
|
|
|
// MergeContainerResourceLimits checks if a limit is applied for
|
|
// the container, and if not, it sets the limit to the passed resource list.
|
|
func MergeContainerResourceLimits(container *Container,
|
|
allocatable ResourceList) {
|
|
if container.Resources.Limits == nil {
|
|
container.Resources.Limits = make(ResourceList)
|
|
}
|
|
for _, resource := range []ResourceName{ResourceCPU, ResourceMemory} {
|
|
if quantity, exists := container.Resources.Limits[resource]; !exists || quantity.IsZero() {
|
|
if cap, exists := allocatable[resource]; exists {
|
|
container.Resources.Limits[resource] = *cap.Copy()
|
|
}
|
|
}
|
|
}
|
|
}
|