/
main.go
160 lines (139 loc) · 3.69 KB
/
main.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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
// Copyright 2019 The Kubernetes Authors.
// SPDX-License-Identifier: Apache-2.0
// Package main implements adding an Application CR to a group of resources and
// is run with `kustomize fn run -- DIR/`.
package main
import (
"fmt"
"os"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime/schema"
"sigs.k8s.io/application/api/v1beta1"
yaml2 "sigs.k8s.io/yaml"
"sigs.k8s.io/kustomize/kyaml/kio"
"sigs.k8s.io/kustomize/kyaml/yaml"
)
func appCR() error {
rw := &kio.ByteReadWriter{
Reader: os.Stdin,
Writer: os.Stdout,
OmitReaderAnnotations: true,
KeepReaderAnnotations: true,
}
p := kio.Pipeline{
Inputs: []kio.Reader{rw}, // read the inputs into a slice
Filters: []kio.Filter{appCRFilter{rw: rw}},
Outputs: []kio.Writer{rw}, // copy the inputs to the output
}
if err := p.Execute(); err != nil {
return err
}
return nil
}
func main() {
if err := appCR(); err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
os.Exit(1)
}
}
// appCRFilter implements kio.Filter
type appCRFilter struct {
rw *kio.ByteReadWriter
}
// define the input API schema as a struct
type API struct {
Spec struct {
ManagedBy string `yaml:"managedBy"`
Name string `yaml:"name"`
Namespace string `yaml:"namespace"`
Descriptor v1beta1.Descriptor `yaml:"descriptor,omitempty"`
} `yaml:"spec"`
}
// Filter checks each resource for validity, otherwise returning an error.
func (f appCRFilter) Filter(in []*yaml.RNode) ([]*yaml.RNode, error) {
api := f.parseAPI()
groupKinds, err := getGroupKinds(in)
if err != nil {
return nil, err
}
app, err := addApplicationCR(api, groupKinds)
if err != nil {
return nil, err
}
err = addApplicationLabel(api.Spec.Name, in)
if err != nil {
return nil, err
}
if app != nil {
return append(in, app), nil
}
return in, nil
}
// parseAPI parses the functionConfig into an API struct.
func (f *appCRFilter) parseAPI() API {
// parse the input function config -- TODO: simplify this
var api API
if err := yaml.Unmarshal([]byte(f.rw.FunctionConfig.MustString()), &api); err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
os.Exit(1)
}
return api
}
func getGroupKinds(in []*yaml.RNode) ([]metav1.GroupKind, error) {
var groupKinds []metav1.GroupKind
for _, r := range in {
meta, err := r.GetMeta()
if err != nil {
return nil, err
}
gvk := schema.FromAPIVersionAndKind(meta.APIVersion, meta.Kind)
found := false
for _, gk := range groupKinds {
if gk.Group == gvk.Group && gk.Kind == gvk.Kind {
found = true
break
}
}
if !found {
groupKinds = append(groupKinds, metav1.GroupKind{
Group: gvk.Group,
Kind: gvk.Kind,
})
}
}
return groupKinds, nil
}
func addApplicationCR(api API, groupKinds []metav1.GroupKind) (*yaml.RNode, error) {
app := v1beta1.Application{
TypeMeta: metav1.TypeMeta{
APIVersion: "app.k8s.io/v1beta1",
Kind: "Application",
},
ObjectMeta: metav1.ObjectMeta{
Namespace: api.Spec.Namespace,
Name: api.Spec.Name,
Labels: map[string]string{"app.kubernetes.io/name": api.Spec.Name},
Annotations: map[string]string{"app.kubernetes.io/managed-by": api.Spec.ManagedBy},
},
Spec: v1beta1.ApplicationSpec{
ComponentGroupKinds: groupKinds,
Descriptor: api.Spec.Descriptor,
Selector: &metav1.LabelSelector{
MatchLabels: map[string]string{"app.kubernetes.io/name": api.Spec.Name},
},
},
}
data, err := yaml2.Marshal(app)
if err != nil {
return nil, err
}
return yaml.Parse(string(data))
}
func addApplicationLabel(name string, in []*yaml.RNode) error {
for _, r := range in {
if _, err := r.Pipe(yaml.SetLabel("app.kubernetes.io/name", name)); err != nil {
return err
}
}
return nil
}