/
generator.go
128 lines (108 loc) · 3.98 KB
/
generator.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
/*
Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package run
import (
"github.com/golang/glog"
"github.com/spf13/pflag"
"k8s.io/gengo/args"
"k8s.io/gengo/generator"
"sigs.k8s.io/kubebuilder/cmd/internal/codegen/parse"
"sigs.k8s.io/kubebuilder/cmd/kubebuilder-gen/codegen"
)
// CodeGenerator generates code for Kubernetes resources and controllers
type CodeGenerator struct {
resourceGenerators []codegen.ResourceGenerator
controllerGenerators []codegen.ControllerGenerator
// OutputFileBaseName is the base name used for output files
OutputFileBaseName string
}
// AddControllerGenerator adds a controller generator that will be called with parsed controllers
func (g *CodeGenerator) AddControllerGenerator(generator codegen.ControllerGenerator) *CodeGenerator {
g.controllerGenerators = append(g.controllerGenerators, generator)
return g
}
// AddResourceGenerator adds a resource generator that will be called with parsed resources
func (g *CodeGenerator) AddResourceGenerator(generator codegen.ResourceGenerator) *CodeGenerator {
g.resourceGenerators = append(g.resourceGenerators, generator)
return g
}
// Execute parses packages and executes the code generators against the resource and controller packages
func (g *CodeGenerator) Execute() error {
arguments := args.Default()
// Custom args.
customArgs := &parse.ParseOptions{}
pflag.CommandLine.BoolVar(&customArgs.SkipMapValidation, "skip-map-validation", true,
"if set to true, skip generating validation schema for map type in CRD.")
pflag.CommandLine.BoolVar(&customArgs.SkipRBACValidation, "skip-rbac-validation", false,
"if set to true, skip validation for RBAC annotations for the controller.")
arguments.CustomArgs = customArgs
arguments.OutputFileBaseName = g.OutputFileBaseName
err := arguments.Execute(parse.NameSystems(), parse.DefaultNameSystem(), g.packages)
if err != nil {
glog.Fatalf("Error: %v", err)
}
return nil
}
// packages parses the observed packages and creates code generators
func (g *CodeGenerator) packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages {
p := packages{}
b := parse.NewAPIs(context, arguments)
// Add resource generators
for _, apigroup := range b.APIs.Groups {
for _, apiversion := range apigroup.Versions {
// Do the versioned resource packages
for _, r := range g.resourceGenerators {
g := r.GenerateVersionedResource(apiversion, apigroup, arguments.OutputFileBaseName)
if g != nil {
p.add(apiversion.Pkg.Path, g)
}
}
}
// Do the unversioned packages
//for _, r := range g.resourceGenerators {
// g := r.GenerateUnversionedResource(apigroup, arguments.OutputFileBaseName)
// if g != nil {
// p.add(apigroup.Pkg.Path, g)
// }
//}
//// Do the install generators
//for _, r := range g.resourceGenerators {
// g := r.GenerateInstall(apigroup, arguments.OutputFileBaseName)
// if g != nil {
// p.add(filepath.Join(apigroup.Pkg.Path, "install"), g)
// }
//}
}
// Do apis package
//for _, r := range g.resourceGenerators {
// g := r.GenerateAPIs(b.APIs, arguments.OutputFileBaseName)
// if g != nil {
// p.add(b.APIs.Pkg.Path, g)
// }
//}
// Find the repo
repo := ""
for _, c := range b.Controllers {
repo = c.Repo
}
// Do inject package
if len(b.Controllers) > 0 {
for _, cg := range g.controllerGenerators {
g := cg.GenerateInject(b.Controllers, b.APIs, arguments.OutputFileBaseName)
if g != nil {
p.add(context.Universe[repo+"/pkg/inject"].Path, g)
}
}
}
return p.value
}