-
Notifications
You must be signed in to change notification settings - Fork 1
/
serutil.go
122 lines (110 loc) · 3.45 KB
/
serutil.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
package serutil
import (
"log/slog"
"os"
"strings"
gardencore "github.com/gardener/gardener/pkg/apis/core/v1beta1"
machinev1alpha1 "github.com/gardener/machine-controller-manager/pkg/apis/machine/v1alpha1"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/runtime/serializer"
"k8s.io/apimachinery/pkg/runtime/serializer/json"
utilruntime "k8s.io/apimachinery/pkg/util/runtime"
)
var codec runtime.Codec
var workingDir string
func init() {
configScheme := runtime.NewScheme()
utilruntime.Must(gardencore.AddToScheme(configScheme))
utilruntime.Must(corev1.AddToScheme(configScheme))
utilruntime.Must(machinev1alpha1.AddToScheme(configScheme))
ser := json.NewSerializerWithOptions(json.DefaultMetaFactory, configScheme, configScheme, json.SerializerOptions{
Yaml: true,
Pretty: false,
Strict: false,
})
versions := schema.GroupVersions([]schema.GroupVersion{
gardencore.SchemeGroupVersion,
corev1.SchemeGroupVersion,
machinev1alpha1.SchemeGroupVersion,
})
codec = serializer.NewCodecFactory(configScheme).CodecForVersions(ser, ser, versions, versions)
workingDir, err := os.Getwd()
if err != nil {
slog.Error("no working dir found", "error", err)
os.Exit(9)
}
slog.Info("working dir", "workingDir", workingDir)
}
// ConstructK8sObject reads a yaml file from given relative Path containing k8s resources and creates objects
func ConstructK8sObject(projRelPath string) ([]runtime.Object, error) {
workingDir, _ := os.Getwd() // FIXME: package var not accessible for some reason.
path := workingDir + "/" + projRelPath
bytes, err := os.ReadFile(path)
if err != nil {
return nil, err
}
stringFromBytes := string(bytes)
var ObjectList []runtime.Object
for _, podSpec := range strings.Split(stringFromBytes, "---") {
if len(podSpec) == 0 {
continue
}
obj, err := runtime.Decode(codec, []byte(podSpec))
if err != nil {
slog.Error("cannot decode object", "error", err)
return nil, err
}
ObjectList = append(ObjectList, obj)
}
return ObjectList, nil
}
// DecodeShoot unmarshalls the given byte slice as a garden shoot obj . TODO: Fix this to use generics later
func DecodeShoot(bytes []byte) (*gardencore.Shoot, error) {
obj, err := runtime.Decode(codec, bytes)
if err != nil {
slog.Error("cannot decode as shoot obj", "error", err)
return nil, err
}
var shoot = obj.(*gardencore.Shoot)
return shoot, nil
}
func DecodeList[T runtime.Object](bytes []byte) ([]T, error) { //TODO: this is inefficient, fix later.
obj, err := runtime.Decode(codec, bytes)
if err != nil {
slog.Error("cannot decode as list", "error", err)
return nil, err
}
var list *corev1.List
var items []T
list = obj.(*corev1.List)
for _, item := range list.Items {
var itemObj T
bytes := item.Raw
decodedObj, err := runtime.Decode(codec, bytes)
if err != nil {
slog.Error("cannot decode node", "error", err)
return nil, err
}
itemObj = decodedObj.(T)
items = append(items, itemObj)
}
return items, nil
}
func ReadPod(projRelPath string) (corev1.Pod, error) {
workingDir, _ := os.Getwd() // FIXME: package var not accessible for some reason.
path := workingDir + "/" + projRelPath
bytes, err := os.ReadFile(path)
if err != nil {
return corev1.Pod{}, err
}
pod := corev1.Pod{}
obj, err := runtime.Decode(codec, bytes)
if err != nil {
slog.Error("cannot decode pod object", "error", err)
return corev1.Pod{}, err
}
pod = *(obj.(*corev1.Pod))
return pod, nil
}