/
utils.go
134 lines (120 loc) · 3.61 KB
/
utils.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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
package rollouts
import (
"context"
"errors"
"fmt"
"os"
"sort"
"strings"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
"sigs.k8s.io/controller-runtime/pkg/client"
)
func setRolloutsLabels(obj *metav1.ObjectMeta) {
obj.Labels = map[string]string{}
obj.Labels["app.kubernetes.io/name"] = DefaultArgoRolloutsResourceName
obj.Labels["app.kubernetes.io/part-of"] = DefaultArgoRolloutsResourceName
obj.Labels["app.kubernetes.io/component"] = DefaultArgoRolloutsResourceName
}
// fetchObject will retrieve the object with the given namespace and name using the Kubernetes API.
// The result will be stored in the given object.
func fetchObject(ctx context.Context, client client.Client, namespace string, name string, obj client.Object) error {
return client.Get(ctx, types.NamespacedName{Namespace: namespace, Name: name}, obj)
}
// Appends the map `add` to the given map `src` and return the result.
func appendStringMap(src map[string]string, add map[string]string) map[string]string {
res := src
if len(src) <= 0 {
res = make(map[string]string, len(add))
}
for key, val := range add {
res[key] = val
}
return res
}
// Merges two slices of EnvVar entries into a single one. If existing
// has an EnvVar with same Name attribute as one in merge, the EnvVar is not
// merged unless override is set to true.
func envMerge(existing []corev1.EnvVar, merge []corev1.EnvVar, override bool) []corev1.EnvVar {
ret := []corev1.EnvVar{}
final := map[string]corev1.EnvVar{}
for _, e := range existing {
final[e.Name] = e
}
for _, m := range merge {
if _, ok := final[m.Name]; ok {
if override {
final[m.Name] = m
}
} else {
final[m.Name] = m
}
}
for _, v := range final {
ret = append(ret, v)
}
// sort result slice by env name
sort.SliceStable(ret,
func(i, j int) bool {
return ret[i].Name < ret[j].Name
})
return ret
}
func caseInsensitiveGetenv(s string) (string, string) {
if v := os.Getenv(s); v != "" {
return s, v
}
ls := strings.ToLower(s)
if v := os.Getenv(ls); v != "" {
return ls, v
}
return "", ""
}
func proxyEnvVars(vars ...corev1.EnvVar) []corev1.EnvVar {
result := []corev1.EnvVar{}
result = append(result, vars...)
proxyKeys := []string{"HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY"}
for _, p := range proxyKeys {
if k, v := caseInsensitiveGetenv(p); k != "" {
result = append(result, corev1.EnvVar{Name: k, Value: v})
}
}
return result
}
// Returns the combined image and tag in the proper format for tags and digests.
// If the provided tag is a SHA Digest, return the combinedImageTag in format `image@SHA:245344..`.
// Whereas if the provided tag is a version, return the combinedImageTag in format `image:vx.y.z`.
func combineImageTag(img string, tag string) string {
if strings.Contains(tag, ":") {
return fmt.Sprintf("%s@%s", img, tag)
} else if len(tag) > 0 {
return fmt.Sprintf("%s:%s", img, tag)
}
// No tag provided, use the default
return img
}
// contains returns true if a string is part of the given slice.
func contains(s []string, g string) bool {
for _, a := range s {
if a == g {
return true
}
}
return false
}
// isMergable returns error if any of the extraArgs is already part of the default command Arguments.
func isMergable(extraArgs []string, cmd []string) error {
if len(extraArgs) > 0 {
for _, arg := range extraArgs {
if len(arg) > 2 && arg[:2] == "--" {
if ok := contains(cmd, arg); ok {
err := errors.New("duplicate argument error")
log.Error(err, fmt.Sprintf("Arg %s is already part of the default command arguments", arg))
return err
}
}
}
}
return nil
}