func computePodResources(pod *api.Pod, node *api.Node) (page.Resources, error) {
req, limit, err := kube.GetSinglePodTotalRequestsAndLimits(pod)
if err != nil {
return page.Resources{}, err
}
cpuReq, cpuLimit, memoryReq, memoryLimit := req[api.ResourceCPU], limit[api.ResourceCPU], req[api.ResourceMemory], limit[api.ResourceMemory]
fractionCpuReq := float64(cpuReq.MilliValue()) / float64(node.Status.Capacity.Cpu().MilliValue()) * 100
fractionCpuLimit := float64(cpuLimit.MilliValue()) / float64(node.Status.Capacity.Cpu().MilliValue()) * 100
fractionMemoryReq := float64(memoryReq.MilliValue()) / float64(node.Status.Capacity.Memory().MilliValue()) * 100
fractionMemoryLimit := float64(memoryLimit.MilliValue()) / float64(node.Status.Capacity.Memory().MilliValue()) * 100
return page.Resources{
Namespace: pod.Namespace,
Name: pod.Name,
CpuRequest: cpuReq.String(),
CpuLimit: cpuLimit.String(),
MemoryRequest: memoryReq.String(),
MemoryLimit: memoryLimit.String(),
FractionCpuRequest: int64(fractionCpuReq),
FractionCpuLimit: int64(fractionCpuLimit),
FractionMemoryRequest: int64(fractionMemoryReq),
FractionMemoryLimit: int64(fractionMemoryLimit),
}, nil
}
func genOnePod(pod *api.Pod) page.Pod {
var containerBirth unversioned.Time
restarts := 0
totalContainers := len(pod.Spec.Containers)
readyContainers := 0
reason := string(pod.Status.Phase)
conditionMap := make(map[api.PodConditionType]*api.PodCondition)
PodAllConditions := []api.PodConditionType{api.PodReady}
for i := range pod.Status.Conditions {
cond := pod.Status.Conditions[i]
conditionMap[cond.Type] = &cond
}
for _, validCondition := range PodAllConditions {
if condition, ok := conditionMap[validCondition]; ok {
if condition.Status != api.ConditionTrue {
reason = "Not" + string(condition.Type)
}
}
}
if pod.Status.Reason != "" {
reason = pod.Status.Reason
}
for i := len(pod.Status.ContainerStatuses) - 1; i >= 0; i-- {
container := pod.Status.ContainerStatuses[i]
restarts += container.RestartCount
if container.State.Waiting != nil && container.State.Waiting.Reason != "" {
reason = container.State.Waiting.Reason
} else if container.State.Terminated != nil && container.State.Terminated.Reason != "" {
reason = container.State.Terminated.Reason
} else if container.State.Terminated != nil && container.State.Terminated.Reason == "" {
if container.State.Terminated.Signal != 0 {
reason = fmt.Sprintf("Signal:%d", container.State.Terminated.Signal)
} else {
reason = fmt.Sprintf("ExitCode:%d", container.State.Terminated.ExitCode)
}
} else if container.Ready && container.State.Running != nil {
readyContainers++
if containerBirth.Before(container.State.Running.StartedAt) {
containerBirth = container.State.Running.StartedAt
}
if container.Image == PauseImage {
reason = "Stopped"
}
}
}
if pod.DeletionTimestamp != nil {
reason = "Terminating"
}
podIP := ""
portString := ""
if pod.Spec.HostNetwork {
podIP = ""
for i := range pod.Spec.Containers {
for j := range pod.Spec.Containers[i].Ports {
port := pod.Spec.Containers[i].Ports[j]
portString += fmt.Sprintf("%d/%s,", port.HostPort, port.Protocol)
}
}
portString = strings.TrimSuffix(portString, ",")
} else {
podIP = pod.Status.PodIP
matches := portMapping.FindStringSubmatch(pod.Status.Message)
if len(matches) > 1 {
portString = matches[1]
}
}
var ports []string
for _, p := range strings.Split(portString, ",") {
ports = append(ports, strings.TrimSuffix(p, "/TCP"))
}
req, limit, _ := kube.GetSinglePodTotalRequestsAndLimits(pod)
return page.Pod{
Namespace: pod.Namespace,
Name: pod.Name,
Images: populatePodImages(pod.Spec.Containers),
TotalContainers: totalContainers,
ReadyContainers: readyContainers,
Status: reason,
Restarts: restarts,
Age: kube.TranslateTimestamp(pod.CreationTimestamp),
ContainerAge: kube.TranslateTimestamp(containerBirth),
ContainerBirth: containerBirth.Time,
HostNetwork: pod.Spec.HostNetwork,
HostIP: pod.Spec.NodeName,
PodIP: podIP,
Ports: ports,
Requests: kube.TranslateResourseList(req),
Limits: kube.TranslateResourseList(limit),
}
}
