1 package mapper
2
3 import (
4 "fmt"
5
6 v1 "k8s.io/api/apps/v1"
7 corev1 "k8s.io/api/core/v1"
8 "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
9 "k8s.io/apimachinery/pkg/runtime"
10
11 "edge-infra.dev/pkg/edge/api/graph/model"
12 )
13
14 func DeploymentToLivenessReadinessResponse(pods *corev1.PodList, deployment *v1.Deployment) *model.LivenessReadinessResponse {
15 resp := model.LivenessReadinessResponse{}
16 resp.PodStatus = PodListToModel(pods)
17 for _, container := range deployment.Spec.Template.Spec.Containers {
18 if container.LivenessProbe != nil {
19 resp.LivenessProbe = ProbeToProbeModel(container.LivenessProbe)
20 }
21 if container.ReadinessProbe != nil {
22 resp.ReadinessProbe = ProbeToProbeModel(container.ReadinessProbe)
23 }
24 }
25 return &resp
26 }
27
28 func StatefulSetToLivenessReadinessResponse(pods *corev1.PodList, ss *v1.StatefulSet) *model.LivenessReadinessResponse {
29 resp := model.LivenessReadinessResponse{}
30 resp.PodStatus = PodListToModel(pods)
31 for _, container := range ss.Spec.Template.Spec.Containers {
32 if container.LivenessProbe != nil {
33 resp.LivenessProbe = ProbeToProbeModel(container.LivenessProbe)
34 }
35 if container.ReadinessProbe != nil {
36 resp.ReadinessProbe = ProbeToProbeModel(container.ReadinessProbe)
37 }
38 }
39 return &resp
40 }
41
42 func DaemonSetToLivenessReadinessResponse(pods *corev1.PodList, ds *v1.DaemonSet) *model.LivenessReadinessResponse {
43 resp := model.LivenessReadinessResponse{}
44 resp.PodStatus = PodListToModel(pods)
45 for _, container := range ds.Spec.Template.Spec.Containers {
46 if container.LivenessProbe != nil {
47 resp.LivenessProbe = ProbeToProbeModel(container.LivenessProbe)
48 }
49 if container.ReadinessProbe != nil {
50 resp.ReadinessProbe = ProbeToProbeModel(container.ReadinessProbe)
51 }
52 }
53 return &resp
54 }
55
56 func UnstructuredToPodsList(resources *unstructured.UnstructuredList) (*corev1.PodList, error) {
57 resp := make([]corev1.Pod, 0)
58 for _, item := range resources.Items {
59 converted := &corev1.Pod{}
60 err := runtime.DefaultUnstructuredConverter.
61 FromUnstructured(item.UnstructuredContent(), &converted)
62 if err != nil {
63 return nil, err
64 }
65 resp = append(resp, *converted)
66 }
67 return &corev1.PodList{Items: resp}, nil
68 }
69
70 func UnstructuredToObject(resources *unstructured.UnstructuredList, object interface{}) error {
71 for _, item := range resources.Items {
72 err := runtime.DefaultUnstructuredConverter.
73 FromUnstructured(item.UnstructuredContent(), object)
74 if err != nil {
75 return err
76 }
77 return nil
78 }
79 return nil
80 }
81
82 func UnstructuredToDeploymentList(resources *unstructured.UnstructuredList) (*v1.DeploymentList, error) {
83 resp := make([]v1.Deployment, 0)
84 for _, item := range resources.Items {
85 converted := &v1.Deployment{}
86 err := runtime.DefaultUnstructuredConverter.
87 FromUnstructured(item.UnstructuredContent(), &converted)
88 if err != nil {
89 return nil, err
90 }
91 resp = append(resp, *converted)
92 }
93 return &v1.DeploymentList{Items: resp}, nil
94 }
95
96 func UnstructuredToStatefulSetList(resources *unstructured.UnstructuredList) (*v1.StatefulSetList, error) {
97 resp := make([]v1.StatefulSet, 0)
98 for _, item := range resources.Items {
99 converted := &v1.StatefulSet{}
100 err := runtime.DefaultUnstructuredConverter.
101 FromUnstructured(item.UnstructuredContent(), &converted)
102 if err != nil {
103 return nil, err
104 }
105 resp = append(resp, *converted)
106 }
107 return &v1.StatefulSetList{Items: resp}, nil
108 }
109
110 func UnstructuredToDaemonSetList(resources *unstructured.UnstructuredList) (*v1.DaemonSetList, error) {
111 resp := make([]v1.DaemonSet, 0)
112 for _, item := range resources.Items {
113 converted := &v1.DaemonSet{}
114 err := runtime.DefaultUnstructuredConverter.
115 FromUnstructured(item.UnstructuredContent(), &converted)
116 if err != nil {
117 return nil, err
118 }
119 resp = append(resp, *converted)
120 }
121 return &v1.DaemonSetList{Items: resp}, nil
122 }
123
124 func PodListToModel(pods *corev1.PodList) []*model.PodStatus {
125 var models []*model.PodStatus
126 for _, pod := range pods.Items {
127 models = append(models, PodToStatusModel(pod))
128 }
129 return models
130 }
131
132 func PodToStatusModel(pod corev1.Pod) *model.PodStatus {
133 modelPod := model.PodStatus{}
134 modelPod.Name = pod.Name
135 for _, container := range pod.Status.ContainerStatuses {
136 modelPod.RestartCount = int(container.RestartCount)
137 modelPod.Started = *container.Started
138 modelPod.Ready = container.Ready
139 }
140 modelPod.Conditions = PodConditionsToModel(pod.Status.Conditions)
141 return &modelPod
142 }
143
144 func PodConditionsToModel(conditions []corev1.PodCondition) []*model.PodCondition {
145 var modelConditions []*model.PodCondition
146 for _, condition := range conditions {
147 modelConditions = append(modelConditions, PodConditionToModel(condition))
148 }
149 return modelConditions
150 }
151
152 func PodConditionToModel(condition corev1.PodCondition) *model.PodCondition {
153 var lastProbeTime *string
154 if !condition.LastProbeTime.IsZero() {
155 probeTime := condition.LastProbeTime.Time.Format(TimeFormat)
156 lastProbeTime = &probeTime
157 }
158 return &model.PodCondition{
159 LastProbeTime: lastProbeTime,
160 LastTransitionTime: condition.LastTransitionTime.Time.Format(TimeFormat),
161 Status: string(condition.Status),
162 Type: string(condition.Type),
163 }
164 }
165
166 func ProbeToProbeModel(probe *corev1.Probe) *model.Probe {
167 return &model.Probe{
168 FailureThreshold: fmt.Sprint(probe.FailureThreshold),
169 HTTPGet: HTTPGetToModel(probe.HTTPGet),
170 PeriodSeconds: int(probe.PeriodSeconds),
171 SuccessThreshold: int(probe.SuccessThreshold),
172 TimeoutSeconds: int(probe.TimeoutSeconds),
173 }
174 }
175
176 func HTTPGetToModel(httpGet *corev1.HTTPGetAction) *model.HTTPGet {
177 if httpGet != nil {
178 return &model.HTTPGet{
179 Path: httpGet.Path,
180 Port: int(httpGet.Port.IntVal),
181 Scheme: string(httpGet.Scheme),
182 }
183 }
184 return nil
185 }
186
View as plain text