-
Notifications
You must be signed in to change notification settings - Fork 810
/
analysisrun_info.go
113 lines (101 loc) · 3.31 KB
/
analysisrun_info.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package info
import (
"sort"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
"github.com/argoproj/argo-rollouts/metricproviders/job"
"github.com/argoproj/argo-rollouts/pkg/apiclient/rollout"
"github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1"
analysisutil "github.com/argoproj/argo-rollouts/utils/analysis"
)
func getAnalysisRunInfo(ownerUID types.UID, allAnalysisRuns []*v1alpha1.AnalysisRun) []*rollout.AnalysisRunInfo {
var arInfos []*rollout.AnalysisRunInfo
for _, run := range allAnalysisRuns {
if ownerRef(run.OwnerReferences, []types.UID{ownerUID}) == nil {
continue
}
arInfo := rollout.AnalysisRunInfo{
ObjectMeta: &v1.ObjectMeta{
Name: run.Name,
Namespace: run.Namespace,
CreationTimestamp: run.CreationTimestamp,
UID: run.UID,
},
}
arInfo.SpecAndStatus = &rollout.AnalysisRunSpecAndStatus{
Spec: &run.Spec,
Status: &run.Status,
}
if run.Spec.Metrics != nil {
for _, metric := range run.Spec.Metrics {
metrics := rollout.Metrics{
Name: metric.Name,
SuccessCondition: metric.SuccessCondition,
}
if metric.InconclusiveLimit != nil {
metrics.InconclusiveLimit = metric.InconclusiveLimit.IntVal
} else {
metrics.InconclusiveLimit = 0
}
if metric.Count != nil {
metrics.Count = metric.Count.IntVal
} else {
metrics.Count = 0
}
if metric.FailureLimit != nil {
metrics.FailureLimit = metric.FailureLimit.IntVal
} else {
metrics.FailureLimit = 0
}
arInfo.Metrics = append(arInfo.Metrics, &metrics)
}
}
arInfo.Status = string(run.Status.Phase)
for _, mr := range run.Status.MetricResults {
arInfo.Successful += mr.Successful
arInfo.Failed += mr.Failed
arInfo.Inconclusive += mr.Inconclusive
arInfo.Error += mr.Error
for _, measurement := range analysisutil.ArrayMeasurement(run, mr.Name) {
if measurement.Metadata != nil {
if jobName, ok := measurement.Metadata[job.JobNameKey]; ok {
jobInfo := rollout.JobInfo{
ObjectMeta: &v1.ObjectMeta{
Name: jobName,
},
Icon: analysisIcon(measurement.Phase),
Status: string(measurement.Phase),
StartedAt: measurement.StartedAt,
MetricName: mr.Name,
}
if measurement.StartedAt != nil {
jobInfo.ObjectMeta.CreationTimestamp = *measurement.StartedAt
}
arInfo.Jobs = append(arInfo.Jobs, &jobInfo)
}
} else {
nonJobInfo := rollout.NonJobInfo{
Value: measurement.Value,
Status: string(measurement.Phase),
StartedAt: measurement.StartedAt,
MetricName: mr.Name,
}
arInfo.NonJobInfo = append(arInfo.NonJobInfo, &nonJobInfo)
}
}
}
arInfo.Icon = analysisIcon(run.Status.Phase)
arInfo.Revision = int64(parseRevision(run.ObjectMeta.Annotations))
arInfos = append(arInfos, &arInfo)
}
sort.Slice(arInfos[:], func(i, j int) bool {
if arInfos[i].Revision != arInfos[j].Revision {
return arInfos[i].Revision > arInfos[j].Revision
}
if arInfos[i].ObjectMeta.CreationTimestamp != arInfos[j].ObjectMeta.CreationTimestamp {
return arInfos[i].ObjectMeta.CreationTimestamp.Before(&arInfos[j].ObjectMeta.CreationTimestamp)
}
return arInfos[i].ObjectMeta.Name > arInfos[j].ObjectMeta.Name
})
return arInfos
}