mirror of
https://github.com/k3s-io/kubernetes.git
synced 2025-11-04 07:49:35 +00:00
125 lines
4.0 KiB
Go
125 lines
4.0 KiB
Go
/*
|
|
Copyright 2015 The Kubernetes Authors All rights reserved.
|
|
|
|
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 fieldpath
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"k8s.io/kubernetes/pkg/api"
|
|
"k8s.io/kubernetes/pkg/api/meta"
|
|
"k8s.io/kubernetes/pkg/api/resource"
|
|
)
|
|
|
|
// formatMap formats map[string]string to a string.
|
|
func FormatMap(m map[string]string) (fmtStr string) {
|
|
for key, value := range m {
|
|
fmtStr += fmt.Sprintf("%v=%q\n", key, value)
|
|
}
|
|
fmtStr = strings.TrimSuffix(fmtStr, "\n")
|
|
|
|
return
|
|
}
|
|
|
|
// ExtractFieldPathAsString extracts the field from the given object
|
|
// and returns it as a string. The object must be a pointer to an
|
|
// API type.
|
|
//
|
|
// Currently, this API is limited to supporting the fieldpaths:
|
|
//
|
|
// 1. metadata.name - The name of an API object
|
|
// 2. metadata.namespace - The namespace of an API object
|
|
func ExtractFieldPathAsString(obj interface{}, fieldPath string) (string, error) {
|
|
accessor, err := meta.Accessor(obj)
|
|
if err != nil {
|
|
return "", nil
|
|
}
|
|
|
|
switch fieldPath {
|
|
case "metadata.annotations":
|
|
return FormatMap(accessor.GetAnnotations()), nil
|
|
case "metadata.labels":
|
|
return FormatMap(accessor.GetLabels()), nil
|
|
case "metadata.name":
|
|
return accessor.GetName(), nil
|
|
case "metadata.namespace":
|
|
return accessor.GetNamespace(), nil
|
|
}
|
|
|
|
return "", fmt.Errorf("Unsupported fieldPath: %v", fieldPath)
|
|
}
|
|
|
|
// ExtractResourceValueByContainerName extracts the value of a resource
|
|
// by providing container name
|
|
func ExtractResourceValueByContainerName(fs *api.ResourceFieldSelector, pod *api.Pod, containerName string) (string, error) {
|
|
container, err := findContainerInPod(pod, containerName)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return ExtractContainerResourceValue(fs, container)
|
|
}
|
|
|
|
// ExtractContainerResourceValue extracts the value of a resource
|
|
// in an already known container
|
|
func ExtractContainerResourceValue(fs *api.ResourceFieldSelector, container *api.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 convertResourceCPUToString(container.Resources.Limits.Cpu(), divisor)
|
|
case "limits.memory":
|
|
return convertResourceMemoryToString(container.Resources.Limits.Memory(), divisor)
|
|
case "requests.cpu":
|
|
return convertResourceCPUToString(container.Resources.Requests.Cpu(), divisor)
|
|
case "requests.memory":
|
|
return 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 *api.Pod, containerName string) (*api.Container, error) {
|
|
for _, container := range pod.Spec.Containers {
|
|
if container.Name == containerName {
|
|
return &container, nil
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("container %s not found", containerName)
|
|
}
|
|
|
|
// convertResourceCPUTOString converts cpu value to the format of divisor and returns
|
|
// ceiling of the value.
|
|
func convertResourceCPUToString(cpu *resource.Quantity, divisor resource.Quantity) (string, error) {
|
|
c := int64(math.Ceil(float64(cpu.MilliValue()) / float64(divisor.MilliValue())))
|
|
return strconv.FormatInt(c, 10), nil
|
|
}
|
|
|
|
// convertResourceMemoryToString converts memory value to the format of divisor and returns
|
|
// ceiling of the value.
|
|
func convertResourceMemoryToString(memory *resource.Quantity, divisor resource.Quantity) (string, error) {
|
|
m := int64(math.Ceil(float64(memory.Value()) / float64(divisor.Value())))
|
|
return strconv.FormatInt(m, 10), nil
|
|
}
|