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),
}
}