func GetPodResource()

in pkg/common/resource.go [56:109]
32 lines of code
9 McCabe index (conditional complexity)

func GetPodResource(pod *v1.Pod) (resource *si.Resource) {
	podResource := &si.Resource{
		Resources: map[string]*si.Quantity{"pods": {Value: 1}},
	}

	// Init container statuses and pod statuses are reported in separate places, so build a fixed map here to make
	// this easier to compute. This is ever so slightly more resource-intensive than computing inline, but is far more
	// readable and less error prone. Since resource calculation is only done once per pod update, this overhead is
	// negligible.
	containerStatuses := make(map[string]*v1.ContainerStatus, len(pod.Status.ContainerStatuses)+len(pod.Status.InitContainerStatuses))
	for idx := range pod.Status.ContainerStatuses {
		containerStatuses[pod.Status.ContainerStatuses[idx].Name] = &pod.Status.ContainerStatuses[idx]
	}
	for idx := range pod.Status.InitContainerStatuses {
		containerStatuses[pod.Status.InitContainerStatuses[idx].Name] = &pod.Status.InitContainerStatuses[idx]
	}

	// Add usage for each container
	for _, container := range pod.Spec.Containers {
		podResource = Add(podResource, computeContainerResource(pod, &container, containerStatuses))
	}

	// each resource compare between initcontainer and sum of containers
	// InitContainers(i) requirement=sum(Sidecar requirement i-1)+InitContainer(i) request
	// max(sum(Containers requirement)+sum(Sidecar requirement), InitContainer(i) requirement)
	if len(pod.Spec.InitContainers) > 0 {
		podResource = checkInitContainerRequest(pod, podResource, containerStatuses)
	}

	// PodLevelResources feature:
	// alpha: v1.32
	// beta: v1.33
	if pod.Spec.Resources != nil && len(pod.Spec.Resources.Requests) > 0 {
		// pod-level resources, if present, override sum of container-level resources
		// only memory and cpu are supported
		for name, value := range getPodLevelResource(pod.Spec.Resources.Requests).GetResources() {
			podResource.Resources[name] = value
		}
	}

	// K8s EnableOverHead feature:
	// Enables PodOverhead, for accounting pod overheads which are specific to a given RuntimeClass
	if pod.Spec.Overhead != nil {
		podOverHeadResource := getResource(pod.Spec.Overhead)
		podResource = Add(podResource, podOverHeadResource)
		// Logging the overall pod size and pod overhead
		log.Log(log.ShimResources).Debug("Pod overhead specified, overall pod size adjusted",
			zap.String("taskID", string(pod.UID)),
			zap.Stringer("overallSize", podResource),
			zap.Stringer("overheadSize", podOverHeadResource))
	}

	return podResource
}