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/ktrntrsv/kubelatte-ce/pkg/api/v1alpha1"
14
	"gitverse.ru/ktrntrsv/kubelatte-ce/pkg/util/env"
15
	corev1 "k8s.io/api/core/v1"
16
	"reflect"
17
	"strings"
18
)
19

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

22
type ConditionStatus string
23

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

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

38
// MergeVolumes merges target with added, but only if a Volume does not exist in target.
39
func MergeVolumes(target, added []corev1.Volume) []corev1.Volume {
40
	return append(target, DeDuplicateVolumes(target, added)...)
41
}
42

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

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

63
func GetLogLevel() string {
64
	return env.LogLevel
65
}
66

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

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

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

127
	return aT
128
}
129

130
func contains(s []interface{}, e interface{}) bool {
131
	for _, a := range s {
132
		if a == e {
133
			return true
134
		}
135
	}
136
	return false
137
}
138

139
func MergeSliceCommon(aT []interface{}, aS []interface{}, dupl bool) []interface{} {
140
	if dupl {
141
		return MergeSliceWithoutDuplicate(aT, aS)
142
	} else {
143
		MergeSlice(aT, aS)
144
	}
145
	return nil
146
}
147

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

179
	return aT
180
}
181

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

209
func WrapString(field, render string) string {
210
	return field + ": " + render
211
}
212

213
func WrapList(field, render string) string {
214
	if strings.Index(render, "-") < strings.Index(render, "\n") {
215
		render = strings.Replace(render, "-", "\n-", 1)
216
	}
217
	render = strings.ReplaceAll(render, "\n", "\n  ")
218
	render = field + ":\n" + render
219
	return render
220
}
221

222
type Patch struct {
223
	Op       string      `json:"op"`
224
	From     string      `json:"from,omitempty"`
225
	Path     string      `json:"path"`
226
	OldValue interface{} `json:"-"`
227
	Value    interface{} `json:"value,omitempty"`
228
}
229

230
func IsCreationInClusterMode() bool {
231
	return env.CreationMode == "cluster"
232
}
233

234
func IsFullRole() bool {
235
	if env.KbltMutator && env.KbltValidator {
236
		return true
237
	}
238
	return false
239
}
240

241
func IsCreatorOnlyRole() bool {
242
	if env.KbltCreator && !env.KbltSideEffect && !env.KbltMutator && !env.KbltValidator {
243
		return true
244
	}
245
	return false
246
}
247