func genOneEvent(ev *api.Event) page.Event { return page.Event{ FirstSeen: kube.TranslateTimestamp(ev.FirstTimestamp), LastSeen: kube.TranslateTimestamp(ev.LastTimestamp), Count: ev.Count, FromComponent: ev.Source.Component, FromHost: ev.Source.Host, SubobjectName: ev.InvolvedObject.Name, SubobjectKind: ev.InvolvedObject.Kind, SubobjectPath: ev.InvolvedObject.FieldPath, Reason: ev.Reason, Message: ev.Message, } }
func genOneEndpoint(ep *api.Endpoints) page.Endpoint { return page.Endpoint{ Name: ep.Name, Age: kube.TranslateTimestamp(ep.CreationTimestamp), Endpoints: kube.FormatEndpoints(ep, nil), } }
func genOneReplicationController(rc *api.ReplicationController) page.ReplicationController { result := page.ReplicationController{ Name: rc.Name, DesiredReplicas: rc.Spec.Replicas, CurrentReplicas: rc.Status.Replicas, Age: kube.TranslateTimestamp(rc.CreationTimestamp), Selector: rc.Spec.Selector, } for k, v := range result.Selector { result.SelectorString += fmt.Sprintf("%s=%s,", k, v) } result.SelectorString = strings.TrimSuffix(result.SelectorString, ",") result.TemplateImages = populatePodImages(rc.Spec.Template.Spec.Containers) return result }
func genOneNode(node *api.Node, allPods []*api.Pod) page.Node { conditionMap := make(map[api.NodeConditionType]*api.NodeCondition) NodeAllConditions := []api.NodeConditionType{api.NodeReady} for i := range node.Status.Conditions { cond := node.Status.Conditions[i] conditionMap[cond.Type] = &cond } var status []string for _, validCondition := range NodeAllConditions { if condition, ok := conditionMap[validCondition]; ok { if condition.Status == api.ConditionTrue { status = append(status, string(condition.Type)) } else { status = append(status, "Not"+string(condition.Type)) } } } if len(status) == 0 { status = append(status, "Unknown") } if node.Spec.Unschedulable { status = append(status, "SchedulingDisabled") } labels := make(map[string]string) for k, v := range node.Labels { if !strings.HasPrefix(k, "kubernetes.io") { labels[k] = v } } pods := kube.FilterNodePods(allPods, node) terminated, nonTerminated := kube.FilterTerminatedPods(pods) allocated, _ := computeNodeResources(nonTerminated, node) return page.Node{ Name: node.Name, Status: status, Age: kube.TranslateTimestamp(node.CreationTimestamp), Labels: labels, Capacity: kube.TranslateResourseList(node.Status.Capacity), Pods: pods, TerminatedPods: terminated, NonTerminatedPods: nonTerminated, AllocatedResources: allocated, FractionPods: int64(float64(len(pods)) / float64(node.Status.Capacity.Pods().Value()) * 100), } }
func genOneService(svc *api.Service) page.Service { internalIP := svc.Spec.ClusterIP externalIP := kube.GetServiceExternalIP(svc) result := page.Service{ Name: svc.Name, InternalIP: internalIP, ExternalIP: externalIP, Ports: kube.MakePorts(svc.Spec.Ports), Age: kube.TranslateTimestamp(svc.CreationTimestamp), Selector: svc.Spec.Selector, } for k, v := range result.Selector { result.SelectorString += fmt.Sprintf("%s=%s,", k, v) } result.SelectorString = strings.TrimSuffix(result.SelectorString, ",") return result }
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), } }