kubelatte-ce

1
/*
2
 * Copyright (c) 2020, salesforce.com, inc.
3
 * All rights reserved.
4
 * SPDX-License-Identifier: BSD-3-Clause
5
 * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
6
 */
7

8
package util
9

10
import (
11
	"errors"
12
	"fmt"
13
	"gitverse.ru/synapse/kubelatte/pkg/api/v1alpha1"
14
	"gitverse.ru/synapse/kubelatte/pkg/util/env"
15
	corev1 "k8s.io/api/core/v1"
16
	"reflect"
17
	"runtime"
18
	"strings"
19
)
20

21
var ErrUnmarshalling = errors.New("unmarshalling error")
22

23
type ConditionStatus string
24

25
type RenderItem struct {
26
	Template             v1alpha1.Template
27
	Render               string
28
	Action               string
29
	CreationIsUniqueName bool
30
}
31

32
// GetAnnotation formats a fully qualified annotation  from a prefix and a name.
33
// For example, with prefix "annotation.io" and name "key", it returns "annotation.io/key".
34
func GetAnnotation(prefix, name string) string {
35
	// See https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/.
36
	return fmt.Sprintf("%s/%s", prefix, name)
37
}
38

39
func GetFunctionName(i interface{}) string {
40
	return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
41
}
42

43
// MergeVolumes merges target with added, but only if a Volume does not exist in target.
44
func MergeVolumes(target, added []corev1.Volume) []corev1.Volume {
45
	return append(target, DeDuplicateVolumes(target, added)...)
46
}
47

48
// MergeVolumeMounts merges target with added, but only if a Volume does not exist in target.
49
func MergeVolumeMounts(target, added []corev1.VolumeMount) []corev1.VolumeMount {
50
	return append(target, DeDuplicateVolumeMounts(target, added)...)
51
}
52

53
// DeDuplicateVolumes returns all or some of added only if they do not already exist in target
54
func DeDuplicateVolumes(target, added []corev1.Volume) []corev1.Volume {
55
	var uniqueVolumes []corev1.Volume
56
	targetNames := map[string]bool{}
57
	for _, v := range target {
58
		targetNames[v.Name] = true
59
	}
60
	for _, add := range added {
61
		if _, exists := targetNames[add.Name]; !exists {
62
			uniqueVolumes = append(uniqueVolumes, add)
63
		}
64
	}
65
	return uniqueVolumes
66
}
67

68
func GetLogLevel() string {
69
	return env.LogLevel
70
}
71

72
// DeDuplicateVolumes returns all or some of added only if they do not already exist in target
73
func DeDuplicateContainers(target, added []corev1.Container) []corev1.Container {
74
	var uniqueContainers []corev1.Container
75
	targetNames := map[string]bool{}
76
	for _, v := range target {
77
		targetNames[v.Name] = true
78
	}
79
	for _, add := range added {
80
		if _, exists := targetNames[add.Name]; !exists {
81
			uniqueContainers = append(uniqueContainers, add)
82
		}
83
	}
84
	return uniqueContainers
85
}
86

87
// DeDuplicateVolumeMounts returns all or some of added only if they do not already exist in target
88
func DeDuplicateVolumeMounts(target, added []corev1.VolumeMount) []corev1.VolumeMount {
89
	var uniqueVolumeMounts []corev1.VolumeMount
90
	targetNames := map[string]bool{}
91
	for _, vm := range target {
92
		targetNames[vm.Name] = true
93
	}
94
	for _, add := range added {
95
		if _, exists := targetNames[add.Name]; !exists {
96
			uniqueVolumeMounts = append(uniqueVolumeMounts, add)
97
		}
98
	}
99
	return uniqueVolumeMounts
100
}
101

102
func MergeSliceWithoutDuplicate(aT, aS []interface{}) []interface{} {
103
	for _, item := range aS {
104
		found := false
105
		if reflect.TypeOf(item).Kind() == reflect.Map {
106
			name, ok := item.(map[string]interface{})["name"]
107
			if ok {
108
				for i, origItem := range aT {
109
					if reflect.TypeOf(origItem).Kind() == reflect.Map {
110
						origName, ok := origItem.(map[string]interface{})["name"]
111
						if ok {
112
							if name == origName {
113
								found = true
114
								aT[i] = MergeStruct(origItem.(map[string]interface{}), item.(map[string]interface{}), true)
115
							}
116
						}
117
					}
118
				}
119
				if !found {
120
					aT = append(aT, item)
121
				}
122
			} else {
123
				aT = append(aT, item)
124
			}
125
		} else {
126
			if !contains(aT, item) {
127
				aT = append(aT, item)
128
			}
129
		}
130
	}
131

132
	return aT
133
}
134

135
func contains(s []interface{}, e interface{}) bool {
136
	for _, a := range s {
137
		if a == e {
138
			return true
139
		}
140
	}
141
	return false
142
}
143

144
func MergeSliceCommon(aT []interface{}, aS []interface{}, dupl bool) []interface{} {
145
	if dupl {
146
		return MergeSliceWithoutDuplicate(aT, aS)
147
	} else {
148
		MergeSlice(aT, aS)
149
	}
150
	return nil
151
}
152

153
func MergeSlice(aT []interface{}, aS []interface{}) []interface{} {
154
	for _, item := range aS {
155
		found := false
156
		if item == nil {
157
			aT = append(aT, nil)
158
		}
159
		if reflect.TypeOf(item).Kind() == reflect.Map {
160
			name, ok := item.(map[string]interface{})["name"]
161
			if ok {
162
				for i, origItem := range aT {
163
					if reflect.TypeOf(origItem).Kind() == reflect.Map {
164
						origName, ok := origItem.(map[string]interface{})["name"]
165
						if ok {
166
							if name == origName {
167
								found = true
168
								aT[i] = MergeStruct(origItem.(map[string]interface{}), item.(map[string]interface{}), false)
169
							}
170
						}
171
					}
172
				}
173
				if !found {
174
					aT = append(aT, item)
175
				}
176
			} else {
177
				aT = append(aT, item)
178
			}
179
		} else {
180
			aT = append(aT, item)
181
		}
182
	}
183

184
	return aT
185
}
186

187
func MergeStruct(aT map[string]interface{}, aS map[string]interface{}, dupl bool) map[string]interface{} {
188
	for k, item := range aS {
189
		if item == nil {
190
			aT[k] = nil
191
			continue
192
		}
193
		if reflect.TypeOf(item).Kind() == reflect.Map {
194
			val, ok := aT[k]
195
			if ok {
196
				aT[k] = MergeStruct(val.(map[string]interface{}), item.(map[string]interface{}), dupl)
197
			} else {
198
				aT[k] = item
199
			}
200
		} else if reflect.TypeOf(item).Kind() == reflect.Slice {
201
			_, ok := aT[k]
202
			if ok {
203
				aT[k] = MergeSliceCommon(aT[k].([]interface{}), item.([]interface{}), dupl)
204
			} else {
205
				aT[k] = item
206
			}
207
		} else {
208
			aT[k] = item
209
		}
210
	}
211
	return aT
212
}
213

214
func WrapString(field, render string) string {
215
	return field + ": " + render
216
}
217

218
func WrapList(field, render string) string {
219
	if strings.Index(render, "-") < strings.Index(render, "\n") {
220
		render = strings.Replace(render, "-", "\n-", 1)
221
	}
222
	render = strings.ReplaceAll(render, "\n", "\n  ")
223
	render = field + ":\n" + render
224
	return render
225
}
226

227
type Patch struct {
228
	Op       string      `json:"op"`
229
	From     string      `json:"from,omitempty"`
230
	Path     string      `json:"path"`
231
	OldValue interface{} `json:"-"`
232
	Value    interface{} `json:"value,omitempty"`
233
}
234

235
func IsCreationInClusterMode() bool {
236
	return env.CreationMode == "cluster"
237
}
238

239
func IsFullRole() bool {
240
	if env.KbltMutator && env.KbltValidator {
241
		return true
242
	}
243
	return false
244
}
245

246
func IsCreatorOnlyRole() bool {
247
	if env.KbltCreator && !env.KbltSideEffect && !env.KbltMutator && !env.KbltValidator {
248
		return true
249
	}
250
	return false
251
}
252