From b06406f226484edef9847cdfc9ddeb254228fc5b Mon Sep 17 00:00:00 2001 From: rcernich Date: Mon, 21 Jan 2019 09:48:00 -0700 Subject: [PATCH 1/2] create tool for generating k8s types wrapping istio types Signed-off-by: rcernich --- Gopkg.lock | 37 +++++ Gopkg.toml | 4 + cmd/kubetype-gen/README.md | 139 ++++++++++++++++ cmd/kubetype-gen/boilerplate.go.txt | 13 ++ cmd/kubetype-gen/generators/naming.go | 19 +++ cmd/kubetype-gen/generators/package.go | 38 +++++ cmd/kubetype-gen/generators/register.go | 95 +++++++++++ cmd/kubetype-gen/generators/types.go | 87 ++++++++++ cmd/kubetype-gen/main.go | 46 +++++ cmd/kubetype-gen/metadata/metadata.go | 212 ++++++++++++++++++++++++ cmd/kubetype-gen/scanner/scanner.go | 206 +++++++++++++++++++++++ 11 files changed, 896 insertions(+) create mode 100644 cmd/kubetype-gen/README.md create mode 100644 cmd/kubetype-gen/boilerplate.go.txt create mode 100644 cmd/kubetype-gen/generators/naming.go create mode 100644 cmd/kubetype-gen/generators/package.go create mode 100644 cmd/kubetype-gen/generators/register.go create mode 100644 cmd/kubetype-gen/generators/types.go create mode 100644 cmd/kubetype-gen/main.go create mode 100644 cmd/kubetype-gen/metadata/metadata.go create mode 100644 cmd/kubetype-gen/scanner/scanner.go diff --git a/Gopkg.lock b/Gopkg.lock index 75f42f605c..09bc431695 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -318,6 +318,17 @@ pruneopts = "UT" revision = "85acf8d2951cb2a3bde7632f9ff273ef0379bcbd" +[[projects]] + branch = "release-branch.go1.4" + digest = "1:44bb3ffab3f70125dbb5df260754c435d3c2fdecdfa670895f94c545ea7c9337" + name = "golang.org/x/tools" + packages = [ + "astutil", + "imports", + ] + pruneopts = "UT" + revision = "abf43428cc239218424c7a44dc9b5987cd351c3e" + [[projects]] digest = "1:2d1fbdc6777e5408cabeb02bf336305e724b925ff4546ded0fa8715a7267922a" name = "gopkg.in/inf.v0" @@ -495,6 +506,19 @@ revision = "7d04d0e2a0a1a4d4a1cd6baa432a2301492e4e65" version = "v8.0.0" +[[projects]] + digest = "1:28a32d7ac148ae6f81d5903f6455ae6530c19ba48708d0366263d61679945b13" + name = "k8s.io/gengo" + packages = [ + "args", + "generator", + "namer", + "parser", + "types", + ] + pruneopts = "UT" + revision = "f8a0810f38afb8478882b3835a615aebfda39afa" + [[projects]] digest = "1:303f22e5b5ab305620ce5bdf7d47c3b8524c97b883e245339b99781aebee306e" name = "k8s.io/helm" @@ -506,6 +530,14 @@ revision = "d325d2a9c179b33af1a024cdb5a4472b6288016a" version = "v2.12.0" +[[projects]] + digest = "1:e2999bf1bb6eddc2a6aa03fe5e6629120a53088926520ca3b4765f77d7ff7eab" + name = "k8s.io/klog" + packages = ["."] + pruneopts = "UT" + revision = "a5bc97fbc634d635061f3146511332c7e313a55a" + version = "v0.1.0" + [solve-meta] analyzer-name = "dep" analyzer-version = 1 @@ -527,10 +559,15 @@ "k8s.io/api/core/v1", "k8s.io/apimachinery/pkg/apis/meta/v1", "k8s.io/apimachinery/pkg/labels", + "k8s.io/apimachinery/pkg/runtime/schema", "k8s.io/client-go/kubernetes", "k8s.io/client-go/rest", "k8s.io/client-go/tools/clientcmd", "k8s.io/client-go/util/retry", + "k8s.io/gengo/args", + "k8s.io/gengo/generator", + "k8s.io/gengo/namer", + "k8s.io/gengo/types", "k8s.io/helm/pkg/proto/hapi/chart", "k8s.io/helm/pkg/proto/hapi/release", ] diff --git a/Gopkg.toml b/Gopkg.toml index 9eea831efb..0fcc9dcbde 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -37,6 +37,10 @@ name = "github.com/google/uuid" version = "1.1.0" +[[override]] + name = "k8s.io/gengo" + revision = "f8a0810f38afb8478882b3835a615aebfda39afa" + [prune] go-tests = true unused-packages = true diff --git a/cmd/kubetype-gen/README.md b/cmd/kubetype-gen/README.md new file mode 100644 index 0000000000..5b56f72e9d --- /dev/null +++ b/cmd/kubetype-gen/README.md @@ -0,0 +1,139 @@ +# kubetype-gen + +`kubetype-gen` is a utility for generating Kubernetes type wrappers (`types.go`) +and registration code (`register.go`) for existing types that need to be used +within Kubernetes (e.g. a Custom Resource Definition based on an existing type). + +The type definitions take the form: + +```go +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type SomeType struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // Spec defines the implementation of this definition. + // +optional + Spec pkg.SomeType `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` +} +``` + +The `register.go` file takes the standard form, including all the generated +types, as well as their corresponding `List` types. + +## Usage + +The generator is enabled by applying comment tags (`+tagName`) to types and +packages. + +The general command line usage: + +`${GOPATH}/bin/kubetype-gen -i -p ` + +For example: + +`${GOPATH}/bin/kubetype-gen -i istio.io/api/authentication/... -p istio.io/api/kube/apis` + +The tool can also be used with `go run`, e.g. `go run vendor/istio.io/tools/cmd/kubetype-gen/main.go ...` + +### Package Tags + +The generator is enabled for a source package by adding tags to the package +comments in its `doc.go` file. The following tags are required: + +**+kubetype-gen:groupVersion=group/version** +> Tells the code generator that the types should be registered with the +> *group/version*. The generated types will be emitted into the package, +> *.../group/version*. + +Note, the same *groupVersion* values may be used in multiple packages, resulting +in the types from all those packages being generated into the same output +package and registered with the same *group/version*. + +Example `doc.go`: +```go +// Package v1alpha1 tags supporting code generate +//+kubetype-gen:groupVersion=authentication.istio.io/v1alpha1 +package v1alpha1 + +``` + +### Type Tags + +The generator is enabled for a specific type by adding tags to the type's +comments. The following tags are available: + +**+kubetype-gen** +> Generate a Kubernetes type for this type. + +**+kubetype-gen:groupVersion=\** +> Tells the code generator that the type should be registered with the +> *group/version*. The generated type will be emitted into the package, +> *.../group/version*. + +**+kubetype-gen:kubeType=\** +> The generated Kubenetes type should use the specified *name*. If this tag is +> not specified, the generated type will use the same name as the type. This +> tag may be specified multiple times, which will result in a generated type for +> each specified *name*. + +**+kubetype-gen:\:tag=\** +> The generated Kubenetes type named *name* should have the specified *tag* +> added to its generated comments. The tag should not include the leading `+` +> as this will be added by the generator. This may be specified multiple times, +> once for each *tag* that should be added to the generated type. + +Example type comments: +```go +// +kubetype-gen +// +kubetype-gen:groupVersion=authentication.istio.io/v1alpha1 +// +kubetype-gen:kubeType=Policy +// +kubetype-gen:kubeType=MeshPolicy +// +kubetype-gen:MeshPolicy:tag=genclient:nonNamespaced +type Policy struct { +``` + +### Other Considerations + +#### Tags For Other Kubernetes Code Generators + +In addition to adding `kubetype-gen` tags to types, you should consider adding +tags used by other Kubernetes code generators. The comments from the source +types will be copied over directly to the generated Kubernetes types, allowing +you to run other code generators on the generated types (e.g. to generate +clientsets, informers, etc.). This allows you to control what gets generated +from the other generators. Note, the generator adds the +`+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object` tag to the +generated types. + +#### Generating `DeepCopy()` Functions + +If you are using your types in Kubernetes, you will most likely need to be able +to copy them. This will require you to use `deepcopy-gen` on your source types. +This can be problematic depending on how your types are structured, meaning you +may have to manually implement functions for some types. You will also want to +run the generator manually so you have direct control over the input packages, +e.g. + +``` +${GOPATH}/bin/deepcopy-gen -i istio.io/api/authentication/... -O zz_generated.deepcopy -h vendor/istio.io/tools/cmd/kubetype-gen/boilerplate.go.txt +``` + +#### Protobuf Serializers #### + +If using protobuf for the source types, you will need to ensure that the +packages for the source types include a `generated.proto` file. The Kubernetes +`go-to-protobuf` tool looks for these files in the source packages. If you are +not using this mechanism, a simple work around is to use +`import public "package/to/some_existing.proto";` statements to include the +upstream `.proto` files for the generated types. Also be aware that the + `go-to-protobuf` generator assumes imports use full import path, e.g. + `istio.io/api/authentication/v1alpha1/policy.proto` vs. something like + `authentication/v1alpha1/policy.proto`. + +When running `go-to-protobuf`, add the packages for the existing types to the +`--apimachinery-packages` using the `-` prefix. This tells the code generator +to look for `generated.proto` files in those packages, but do not generate +code for the types within them. This will limit `go-to-protobuf` to generating +code only for the types generated by `kubetype-gen`. \ No newline at end of file diff --git a/cmd/kubetype-gen/boilerplate.go.txt b/cmd/kubetype-gen/boilerplate.go.txt new file mode 100644 index 0000000000..1f51ec620c --- /dev/null +++ b/cmd/kubetype-gen/boilerplate.go.txt @@ -0,0 +1,13 @@ +// Copyright 2019 Istio 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. diff --git a/cmd/kubetype-gen/generators/naming.go b/cmd/kubetype-gen/generators/naming.go new file mode 100644 index 0000000000..636a84acaa --- /dev/null +++ b/cmd/kubetype-gen/generators/naming.go @@ -0,0 +1,19 @@ +package generators + +import ( + "k8s.io/gengo/namer" +) + +// NameSystems used by the kubetype generator +func NameSystems(generatedPackage string, tracker namer.ImportTracker) namer.NameSystems { + return namer.NameSystems{ + "public": namer.NewPublicNamer(0), + "raw": namer.NewRawNamer(generatedPackage, tracker), + "publicPlural": namer.NewPublicPluralNamer(map[string]string{}), + } +} + +// DefaultNameSystem to use if none is specified +func DefaultNameSystem() string { + return "public" +} diff --git a/cmd/kubetype-gen/generators/package.go b/cmd/kubetype-gen/generators/package.go new file mode 100644 index 0000000000..3b77cde59a --- /dev/null +++ b/cmd/kubetype-gen/generators/package.go @@ -0,0 +1,38 @@ +package generators + +import ( + "istio.io/tools/cmd/kubetype-gen/metadata" + "k8s.io/gengo/generator" + "k8s.io/gengo/types" +) + +// NewPackageGenerator generates source for a scanned package, specifically k8s styled doc.go, types.go and register.go files +func NewPackageGenerator(source metadata.PackageMetadata, boilerplate []byte) generator.Package { + return &generator.DefaultPackage{ + PackageName: source.TargetPackage().Name, + PackagePath: source.TargetPackage().Path, + HeaderText: boilerplate, + PackageDocumentation: []byte(` +// Package has auto-generated kube type wrappers for raw types. +// +k8s:openapi-gen=true +// +k8s:deepcopy-gen=package +`), + FilterFunc: func(c *generator.Context, t *types.Type) bool { + for _, it := range source.RawTypes() { + if t == it { + return true + } + } + return false + }, + GeneratorList: []generator.Generator{ + // generate types.go + NewTypesGenerator(source), + // generate register.go + NewRegisterGenerator(source), + generator.DefaultGen{ + OptionalName: "doc", + }, + }, + } +} diff --git a/cmd/kubetype-gen/generators/register.go b/cmd/kubetype-gen/generators/register.go new file mode 100644 index 0000000000..ad5d298b93 --- /dev/null +++ b/cmd/kubetype-gen/generators/register.go @@ -0,0 +1,95 @@ +package generators + +import ( + "bufio" + "bytes" + "fmt" + "io" + + "istio.io/tools/cmd/kubetype-gen/metadata" + + "k8s.io/gengo/generator" + "k8s.io/gengo/namer" + "k8s.io/gengo/types" +) + +type registerGenerator struct { + generator.DefaultGen + source metadata.PackageMetadata + imports namer.ImportTracker +} + +// NewRegisterGenerator creates a new generator for creating k8s style register.go files +func NewRegisterGenerator(source metadata.PackageMetadata) generator.Generator { + return ®isterGenerator{ + DefaultGen: generator.DefaultGen{ + OptionalName: "register", + }, + source: source, + imports: generator.NewImportTracker(), + } +} + +func (g *registerGenerator) Namers(c *generator.Context) namer.NameSystems { + return NameSystems(g.source.TargetPackage().Path, g.imports) +} + +func (g *registerGenerator) PackageConsts(c *generator.Context) []string { + return []string{ + fmt.Sprintf("GroupName = \"%s\"", g.source.GroupVersion().Group), + } +} + +func (g *registerGenerator) PackageVars(c *generator.Context) []string { + schemeBuilder := bytes.Buffer{} + w := bufio.NewWriter(&schemeBuilder) + sw := generator.NewSnippetWriter(w, c, "$", "$") + m := map[string]interface{}{ + "NewSchemeBuilder": c.Universe.Function(types.Name{Name: "NewSchemeBuilder", Package: "k8s.io/apimachinery/pkg/runtime"}), + } + sw.Do("SchemeBuilder = $.NewSchemeBuilder|raw$(addKnownTypes)", m) + w.Flush() + return []string{ + fmt.Sprintf("SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: \"%s\"}", g.source.GroupVersion().Version), + schemeBuilder.String(), + "localSchemeBuilder = &SchemeBuilder", + "AddToScheme = localSchemeBuilder.AddToScheme", + } +} + +func (g *registerGenerator) Imports(c *generator.Context) []string { + return g.imports.ImportLines() +} + +func (g registerGenerator) Finalize(c *generator.Context, w io.Writer) error { + sw := generator.NewSnippetWriter(w, c, "$", "$") + m := map[string]interface{}{ + "GroupResource": c.Universe.Type(types.Name{Name: "GroupResource", Package: "k8s.io/apimachinery/pkg/runtime/schema"}), + "Scheme": c.Universe.Type(types.Name{Name: "Scheme", Package: "k8s.io/apimachinery/pkg/runtime"}), + "AddToGroupVersion": c.Universe.Function(types.Name{Name: "AddToGroupVersion", Package: "k8s.io/apimachinery/pkg/apis/meta/v1"}), + "KubeTypes": g.source.AllKubeTypes(), + } + sw.Do(resourceFuncTemplate, m) + sw.Do(addKnownTypesFuncTemplate, m) + + return sw.Error() +} + +const resourceFuncTemplate = ` +func Resource(resource string) $.GroupResource|raw$ { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} +` + +const addKnownTypesFuncTemplate = ` +func addKnownTypes(scheme *$.Scheme|raw$) error { + scheme.AddKnownTypes(SchemeGroupVersion, + $- range .KubeTypes $ + &$ .Type|raw ${}, + &$ .Type|raw $List{}, + $- end $ + ) + $.AddToGroupVersion|raw$(scheme, SchemeGroupVersion) + return nil +} +` diff --git a/cmd/kubetype-gen/generators/types.go b/cmd/kubetype-gen/generators/types.go new file mode 100644 index 0000000000..16e6c8bd64 --- /dev/null +++ b/cmd/kubetype-gen/generators/types.go @@ -0,0 +1,87 @@ +package generators + +import ( + "io" + + "istio.io/tools/cmd/kubetype-gen/metadata" + + "k8s.io/gengo/generator" + "k8s.io/gengo/namer" + "k8s.io/gengo/types" +) + +type typesGenerator struct { + generator.DefaultGen + source metadata.PackageMetadata + imports namer.ImportTracker +} + +// NewTypesGenerator creates a new generator for creating k8s style types.go files +func NewTypesGenerator(source metadata.PackageMetadata) generator.Generator { + return &typesGenerator{ + DefaultGen: generator.DefaultGen{ + OptionalName: "types", + }, + source: source, + imports: generator.NewImportTracker(), + } +} + +func (g *typesGenerator) Namers(c *generator.Context) namer.NameSystems { + return NameSystems(g.source.TargetPackage().Path, g.imports) +} + +func (g *typesGenerator) Imports(c *generator.Context) []string { + return g.imports.ImportLines() +} + +func (g *typesGenerator) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error { + kubeTypes := g.source.KubeTypes(t) + sw := generator.NewSnippetWriter(w, c, "$", "$") + m := map[string]interface{}{ + "KubeType": nil, + "RawType": t, + "TypeMeta": c.Universe.Type(types.Name{Name: "TypeMeta", Package: "k8s.io/apimachinery/pkg/apis/meta/v1"}), + "ObjectMeta": c.Universe.Type(types.Name{Name: "ObjectMeta", Package: "k8s.io/apimachinery/pkg/apis/meta/v1"}), + "ListMeta": c.Universe.Type(types.Name{Name: "ListMeta", Package: "k8s.io/apimachinery/pkg/apis/meta/v1"}), + } + for _, kubeType := range kubeTypes { + m["KubeType"] = kubeType + sw.Do(kubeTypeTemplate, m) + } + return sw.Error() +} + +const kubeTypeTemplate = ` +$- range .RawType.SecondClosestCommentLines $ +// $ . $ +$- end $ +$- range .KubeType.Tags $ +// +$ . $ +$- end $ +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +$ range .RawType.CommentLines $ +// $ . $ +$- end $ +type $.KubeType.Type|public$ struct { + $.TypeMeta|raw$ ` + "`" + `json:",inline"` + "`" + ` + // +optional + $.ObjectMeta|raw$ ` + "`" + `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + "`" + ` + + // Spec defines the implementation of this definition. + // +optional + Spec $.RawType|raw$ ` + "`" + `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` + "`" + ` + +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// $.KubeType.Type|public$List is a collection of $.KubeType.Type|publicPlural$. +type $.KubeType.Type|public$List struct { + $.TypeMeta|raw$ ` + "`" + `json:",inline"` + "`" + ` + // +optional + $.ListMeta|raw$ ` + "`" + `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + "`" + ` + Items []$.KubeType.Type|raw$ ` + "`" + `json:"items" protobuf:"bytes,2,rep,name=items"` + "`" + ` +} +` diff --git a/cmd/kubetype-gen/main.go b/cmd/kubetype-gen/main.go new file mode 100644 index 0000000000..e4f1b46015 --- /dev/null +++ b/cmd/kubetype-gen/main.go @@ -0,0 +1,46 @@ +// Copyright 2019 Istio 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 main + +import ( + "os" + + "github.com/golang/glog" + + "istio.io/tools/cmd/kubetype-gen/generators" + "istio.io/tools/cmd/kubetype-gen/scanner" + + "k8s.io/gengo/args" +) + +func main() { + arguments := args.Default() + + arguments.GeneratedByCommentTemplate = "// Code generated by kubetype-gen. DO NOT EDIT." + + // Don't default the file header + // arguments.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), "istio.io/tools/cmd/kubetype-gen/boilerplate.go.txt") + + scanner := scanner.Scanner{} + + if err := arguments.Execute( + generators.NameSystems("", nil), + generators.DefaultNameSystem(), + scanner.Scan, + ); err != nil { + glog.Errorf("Error: %v", err) + os.Exit(1) + } + glog.V(2).Info("Completed successfully.") +} diff --git a/cmd/kubetype-gen/metadata/metadata.go b/cmd/kubetype-gen/metadata/metadata.go new file mode 100644 index 0000000000..8ac3b3710b --- /dev/null +++ b/cmd/kubetype-gen/metadata/metadata.go @@ -0,0 +1,212 @@ +package metadata + +import ( + "fmt" + "path/filepath" + "sort" + "strings" + + "github.com/golang/glog" + + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/gengo/types" +) + +// KubeType is the interface representing a type to be generated. +type KubeType interface { + RawType() *types.Type + Type() *types.Type + Tags() []string +} + +// PackageMetadata is the interface used to provide source data used by the package generators. +type PackageMetadata interface { + // GroupVersion is the k8s Group/Version to use for the generated types. + GroupVersion() *schema.GroupVersion + + // TargetPackage is the package into which the k8s types will be generated. + TargetPackage() *types.Package + + // RawTypes is the list of types for which k8s types should be generated. + RawTypes() []*types.Type + + // KubeTypes is the list of k8s types to be generated for the given rawType. + KubeTypes(rawType *types.Type) []KubeType + + // AllKubeTypes is the list of all k8s types to be generated + AllKubeTypes() []KubeType + + // AddMetadata is used to add metadata collected by the scanner. + AddMetadataForType(rawType *types.Type, kubeTypes ...KubeType) error + + // Validate is used to validate the metadata prior to generation + Validate() []error +} + +// Store is used to store/access the source metadata collected by the scanner +type Store interface { + + // MetadataForGV returns the package metadata associated with the Group/Version + MetadataForGV(gv *schema.GroupVersion) PackageMetadata + + // AllMetadata returns the source metadata. + AllMetadata() []PackageMetadata + + // Validate is used to validate the metadata prior to generation + Validate() []error +} + +type kubeTypeMetadata struct { + rawType *types.Type + kubeType *types.Type + tags []string +} + +type packageMetadata struct { + groupVersion *schema.GroupVersion + targetPackage *types.Package + rawTypes []*types.Type + allKubeTypes []KubeType + kubeTypesForRawType map[*types.Type][]KubeType +} + +type metadataStore struct { + baseOutputPackage *types.Package + universe *types.Universe + metadataForGV map[string]PackageMetadata + metadata []PackageMetadata +} + +// NewMetadataStore returns a new store used for collecting source metadata used by the generator. +func NewMetadataStore(baseOutputPackage *types.Package, universe *types.Universe) Store { + return &metadataStore{ + baseOutputPackage: baseOutputPackage, + universe: universe, + metadataForGV: map[string]PackageMetadata{}, + metadata: []PackageMetadata{}, + } +} + +func (s *metadataStore) MetadataForGV(gv *schema.GroupVersion) PackageMetadata { + simpleGV := schema.GroupVersion{Group: strings.SplitN(gv.Group, ".", 2)[0], Version: gv.Version} + existing := s.metadataForGV[simpleGV.String()] + if existing == nil { + glog.V(5).Infof("Creating new PackageMetadata for Group/Version %s", gv) + existing = &packageMetadata{ + groupVersion: gv, + targetPackage: s.createTargetPackage(gv), + rawTypes: []*types.Type{}, + allKubeTypes: []KubeType{}, + kubeTypesForRawType: map[*types.Type][]KubeType{}, + } + s.metadataForGV[simpleGV.String()] = existing + s.metadata = append(s.metadata, existing) + } else if gv.Group != existing.GroupVersion().Group { + glog.Errorf("Overlapping packages for Group/Versions %s and %s", gv, existing.GroupVersion()) + return nil + } + return existing +} + +func (s *metadataStore) AllMetadata() []PackageMetadata { + return s.metadata +} + +func (s *metadataStore) Validate() []error { + errorSlice := []error{} + for _, pm := range s.metadata { + errorSlice = append(errorSlice, pm.Validate()...) + } + return errorSlice +} + +func (s *metadataStore) createTargetPackage(gv *schema.GroupVersion) *types.Package { + groupPath := strings.SplitN(gv.Group, ".", 2) + targetPackage := s.universe.Package(filepath.Join(s.baseOutputPackage.Path, groupPath[0], gv.Version)) + targetPackage.Name = gv.Version + return targetPackage +} + +func (m *packageMetadata) GroupVersion() *schema.GroupVersion { + return m.groupVersion +} + +func (m *packageMetadata) TargetPackage() *types.Package { + return m.targetPackage +} + +func (m *packageMetadata) RawTypes() []*types.Type { + return m.rawTypes +} + +func (m *packageMetadata) KubeTypes(rawType *types.Type) []KubeType { + return m.kubeTypesForRawType[rawType] +} + +func (m *packageMetadata) AllKubeTypes() []KubeType { + return m.allKubeTypes +} + +func (m *packageMetadata) AddMetadataForType(rawType *types.Type, kubeTypes ...KubeType) error { + if _, exists := m.kubeTypesForRawType[rawType]; exists { + // we should never get here. this means we've scanned a type twice + return fmt.Errorf("type %s already added to scanned metadata", rawType) + } + + m.rawTypes = append(m.rawTypes, rawType) + m.kubeTypesForRawType[rawType] = append(kubeTypes) + m.allKubeTypes = append(m.allKubeTypes, kubeTypes...) + + return nil +} + +func (m *packageMetadata) Validate() []error { + duplicates := map[*types.Type][]*types.Type{} + + // check for duplicates + sort.Slice(m.allKubeTypes, func(i, j int) bool { + comp := strings.Compare(m.allKubeTypes[i].Type().Name.Name, m.allKubeTypes[j].Type().Name.Name) + if comp == 0 { + if sources, exists := duplicates[m.allKubeTypes[i].Type()]; exists { + duplicates[m.allKubeTypes[i].Type()] = append(sources, m.allKubeTypes[i].RawType()) + } else { + duplicates[m.allKubeTypes[i].Type()] = []*types.Type{m.allKubeTypes[j].RawType(), m.allKubeTypes[i].RawType()} + } + return false + } + return comp < 0 + }) + if len(duplicates) > 0 { + errorSlice := make([]error, 0, len(duplicates)) + for kubeType, rawTypes := range duplicates { + errorSlice = append(errorSlice, fmt.Errorf("duplicate kube types specified for %s. duplicated by: %v", kubeType, rawTypes)) + } + return errorSlice + } + return []error{} +} + +// NewKubeType returns a new KubeType object representing the source type, the target type and its comment tags +func NewKubeType(rawType *types.Type, kubeType *types.Type, tags []string) KubeType { + return &kubeTypeMetadata{ + rawType: rawType, + kubeType: kubeType, + tags: tags, + } +} + +func (k *kubeTypeMetadata) RawType() *types.Type { + return k.rawType +} + +func (k *kubeTypeMetadata) Type() *types.Type { + return k.kubeType +} + +func (k *kubeTypeMetadata) Tags() []string { + return k.tags +} + +func (k *kubeTypeMetadata) String() string { + return fmt.Sprintf("%s => %s%s", k.rawType, k.kubeType, k.tags) +} diff --git a/cmd/kubetype-gen/scanner/scanner.go b/cmd/kubetype-gen/scanner/scanner.go new file mode 100644 index 0000000000..27346625be --- /dev/null +++ b/cmd/kubetype-gen/scanner/scanner.go @@ -0,0 +1,206 @@ +package scanner + +import ( + "fmt" + "strings" + + "istio.io/tools/cmd/kubetype-gen/generators" + "istio.io/tools/cmd/kubetype-gen/metadata" + + "github.com/golang/glog" + + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/gengo/args" + "k8s.io/gengo/generator" + "k8s.io/gengo/types" +) + +const ( + // enabledTagName is the root tag used to identify types that need a corresponding kube type generated + enabledTagName = "kubetype-gen" + + // groupVersionTagName is the tag used to identify the k8s group/version associated with the generated types. + groupVersionTagName = enabledTagName + ":groupVersion" + + // kubeTypeTagName is used to identify the name(s) of the types to be generated from the type with this tag. + // If this tag is not present, the k8s type will have the same name as the source type. If this tag is specified + // multiple times, a k8s type will be generated for each value. + kubeTypeTagName = enabledTagName + ":kubeType" + + // kubeTagsTagTemplate is used to identify a comment tag that should be added to the generated kubeType. This + // allows different sets of tags to be used when a single type is the source for multiple kube types (e.g. where one + // is namespaced and another is not). The tag should not be prefixed with '+', as this will be added by the + // generator. This may be specified multiple times, once for each tag to be added to the generated type. + kubeTagsTagTemplate = enabledTagName + ":%s:tag" +) + +// Scanner is used to scan input packages for types with kubetype-gen tags +type Scanner struct { + arguments *args.GeneratorArgs + context *generator.Context +} + +// Scan the input packages for types with kubetype-gen tags +func (s *Scanner) Scan(c *generator.Context, arguments *args.GeneratorArgs) generator.Packages { + s.arguments = arguments + s.context = c + + boilerplate, err := arguments.LoadGoBoilerplate() + if err != nil { + glog.Fatalf("Failed loading boilerplate: %v", err) + } + + // scan input packages for kubetype-gen + metadataStore := metadata.NewMetadataStore(s.getBaseOutputPackage(), &c.Universe) + fail := false + + glog.V(5).Info("Scanning input packages") + for _, input := range c.Inputs { + glog.V(5).Infof("Scanning package %s", input) + pkg := c.Universe[input] + if pkg == nil { + glog.Warningf("Package not found: %s", input) + continue + } + if strings.HasPrefix(arguments.OutputPackagePath, pkg.Path) { + glog.Warningf("Ignoring package %s as it is located in the output package %s", pkg.Path, arguments.OutputPackagePath) + continue + } + + pkgTags := types.ExtractCommentTags("+", pkg.DocComments) + + // group/version for generated types from this package + defaultGV, err := s.getGroupVersion(pkgTags, nil) + if err != nil { + glog.Errorf("Could not calculate Group/Version for package %s: %v", pkg.Path, err) + fail = true + } else if defaultGV != nil { + if len(defaultGV.Group) == 0 { + glog.Errorf("Invalid Group/Version for package %s, Group not specified for Group/Version: %v", pkg.Path, defaultGV) + fail = true + } else { + glog.V(5).Infof("Default Group/Version for package: %s", defaultGV) + } + } + + // scan package for types that need kube types generated + for _, t := range pkg.Types { + comments := make([]string, 0, len(t.CommentLines)+len(t.SecondClosestCommentLines)) + comments = append(comments, t.CommentLines...) + comments = append(comments, t.SecondClosestCommentLines...) + typeTags := types.ExtractCommentTags("+", comments) + if _, exists := typeTags[enabledTagName]; exists { + var gv *schema.GroupVersion + gv, err = s.getGroupVersion(typeTags, defaultGV) + if err != nil { + glog.Errorf("Could not calculate Group/Version for type %s: %v", t, err) + fail = true + continue + } else if gv == nil || len(gv.Group) == 0 { + glog.Errorf("Invalid Group/Version for type %s: %s", t, gv) + fail = true + continue + } + + packageMetadata := metadataStore.MetadataForGV(gv) + if packageMetadata == nil { + glog.Errorf("Could not create metadata for type: %s", t) + fail = true + continue + } + + kubeTypes := s.createKubeTypesForType(t, packageMetadata.TargetPackage()) + glog.V(5).Infof("Kube types %v will be generated with Group/Version %s, for raw type in %s", kubeTypes, gv, t) + err = packageMetadata.AddMetadataForType(t, kubeTypes...) + if err != nil { + glog.Errorf("Error adding metadata source for %s: %v", t, err) + fail = true + } + } + } + } + + glog.V(5).Info("Finished scanning input packages") + + validationErrors := metadataStore.Validate() + if len(validationErrors) > 0 { + for _, validationErr := range validationErrors { + glog.Error(validationErr) + } + fail = true + } + if fail { + glog.Exit("Errors occurred while scanning input. See previous output for details.") + } + + generatorPackages := []generator.Package{} + for _, source := range metadataStore.AllMetadata() { + if len(source.RawTypes()) == 0 { + glog.Warningf("Skipping generation of %s, no types to generate", source.GroupVersion()) + continue + } + glog.V(2).Infof("Adding package generator for %s.", source.GroupVersion()) + generatorPackages = append(generatorPackages, generators.NewPackageGenerator(source, boilerplate)) + } + return generatorPackages +} + +func (s *Scanner) getGroupVersion(tags map[string][]string, defaultGV *schema.GroupVersion) (*schema.GroupVersion, error) { + if value, exists := tags[groupVersionTagName]; exists && len(value) > 0 { + gv, err := schema.ParseGroupVersion(value[0]) + if err == nil { + return &gv, nil + } + return nil, fmt.Errorf("invalid group version '%s' specified: %v", value[0], err) + } + return defaultGV, nil +} + +func (s *Scanner) getBaseOutputPackage() *types.Package { + return s.context.Universe.Package(s.arguments.OutputPackagePath) +} + +func (s *Scanner) createKubeTypesForType(t *types.Type, outputPackage *types.Package) []metadata.KubeType { + namesForType := s.kubeTypeNamesForType(t) + newKubeTypes := make([]metadata.KubeType, 0, len(namesForType)) + for _, name := range namesForType { + tags := s.getTagsForKubeType(t, name) + newKubeTypes = append(newKubeTypes, metadata.NewKubeType(t, s.context.Universe.Type(types.Name{Name: name, Package: outputPackage.Path}), tags)) + } + return newKubeTypes +} + +func (s *Scanner) kubeTypeNamesForType(t *types.Type) []string { + names := []string{} + comments := make([]string, 0, len(t.CommentLines)+len(t.SecondClosestCommentLines)) + comments = append(comments, t.CommentLines...) + comments = append(comments, t.SecondClosestCommentLines...) + tags := types.ExtractCommentTags("+", comments) + if value, exists := tags[kubeTypeTagName]; exists { + if len(value) == 0 || len(value[0]) == 0 { + glog.Errorf("Invalid value specified for +%s in type %s. Using default name %s.", kubeTypeTagName, t, t.Name.Name) + names = append(names, t.Name.Name) + } else { + for _, name := range value { + if len(name) > 0 { + names = append(names, name) + } + } + } + } else { + names = append(names, t.Name.Name) + } + return names +} + +func (s *Scanner) getTagsForKubeType(t *types.Type, name string) []string { + tagName := fmt.Sprintf(kubeTagsTagTemplate, name) + comments := make([]string, 0, len(t.CommentLines)+len(t.SecondClosestCommentLines)) + comments = append(comments, t.CommentLines...) + comments = append(comments, t.SecondClosestCommentLines...) + tags := types.ExtractCommentTags("+", comments) + if value, exists := tags[tagName]; exists { + return value + } + return []string{} +} From 6d3d060b0750ca1b63015c23a81676205931ba35 Mon Sep 17 00:00:00 2001 From: rcernich Date: Fri, 25 Jan 2019 12:19:48 -0700 Subject: [PATCH 2/2] add tests for kubetype-gen Signed-off-by: rcernich --- cmd/kubetype-gen/Makefile | 59 ++++++ .../negative/defaults/emptygroup/doc.go | 4 + .../negative/defaults/emptygroup/type.go | 7 + .../defaults/invalidgroupversion/doc.go | 4 + .../defaults/invalidgroupversion/type.go | 7 + .../test_input/negative/types/type.go | 57 ++++++ .../test_input/positive/defaults/doc.go | 4 + .../test_input/positive/defaults/type.go | 20 ++ .../test_input/positive/types/type.go | 50 +++++ .../test_output/defaults/group/version/doc.go | 20 ++ .../defaults/group/version/register.go | 49 +++++ .../defaults/group/version/types.go | 47 +++++ .../defaults/group2/version2/doc.go | 20 ++ .../defaults/group2/version2/register.go | 49 +++++ .../defaults/group2/version2/types.go | 49 +++++ .../test_output/types/group/version/doc.go | 20 ++ .../types/group/version/register.go | 59 ++++++ .../test_output/types/group/version/types.go | 186 ++++++++++++++++++ .../test_output/types/group2/version/doc.go | 20 ++ .../types/group2/version/register.go | 49 +++++ .../test_output/types/group2/version/types.go | 49 +++++ 21 files changed, 829 insertions(+) create mode 100644 cmd/kubetype-gen/Makefile create mode 100644 cmd/kubetype-gen/testdata/test_input/negative/defaults/emptygroup/doc.go create mode 100644 cmd/kubetype-gen/testdata/test_input/negative/defaults/emptygroup/type.go create mode 100644 cmd/kubetype-gen/testdata/test_input/negative/defaults/invalidgroupversion/doc.go create mode 100644 cmd/kubetype-gen/testdata/test_input/negative/defaults/invalidgroupversion/type.go create mode 100644 cmd/kubetype-gen/testdata/test_input/negative/types/type.go create mode 100644 cmd/kubetype-gen/testdata/test_input/positive/defaults/doc.go create mode 100644 cmd/kubetype-gen/testdata/test_input/positive/defaults/type.go create mode 100644 cmd/kubetype-gen/testdata/test_input/positive/types/type.go create mode 100644 cmd/kubetype-gen/testdata/test_output/defaults/group/version/doc.go create mode 100644 cmd/kubetype-gen/testdata/test_output/defaults/group/version/register.go create mode 100644 cmd/kubetype-gen/testdata/test_output/defaults/group/version/types.go create mode 100644 cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/doc.go create mode 100644 cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/register.go create mode 100644 cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/types.go create mode 100644 cmd/kubetype-gen/testdata/test_output/types/group/version/doc.go create mode 100644 cmd/kubetype-gen/testdata/test_output/types/group/version/register.go create mode 100644 cmd/kubetype-gen/testdata/test_output/types/group/version/types.go create mode 100644 cmd/kubetype-gen/testdata/test_output/types/group2/version/doc.go create mode 100644 cmd/kubetype-gen/testdata/test_output/types/group2/version/register.go create mode 100644 cmd/kubetype-gen/testdata/test_output/types/group2/version/types.go diff --git a/cmd/kubetype-gen/Makefile b/cmd/kubetype-gen/Makefile new file mode 100644 index 0000000000..8cdce60c31 --- /dev/null +++ b/cmd/kubetype-gen/Makefile @@ -0,0 +1,59 @@ + +define kubetype-gen = +$(shell go run ./main.go -i $$(go list ${1}) -p "$$(go list .)/testdata/test_output/${2}" 2>&1) +endef + +test: run-negative-tests run-positive-tests + +check-env: + @if ! git diff --quiet HEAD -- tests; then \ + echo "FAIL: tests contain uncommitted changes. Please commit changes in ./testdata."; \ + false; \ + fi + +run-positive-tests: run-positive-defaults-test run-positive-types-test + +run-positive-defaults-test: check-env + @echo "Running $@" + $(eval $@_output = $(call kubetype-gen,./testdata/test_input/positive/defaults,defaults)) + @echo "${$@_output}" | grep -q "Errors occurred while scanning input. See previous output for details."; test $$? || (echo "kubetype-gen command failed" && echo "${$@_output}" && false) + @if ! git diff --quiet HEAD -- tests || [ -n "$$(git ls-files -o -- tests)" ]; then \ + echo "FAIL: output files have changed"; \ + false; \ + fi + +run-positive-types-test: check-env + @echo "Running $@" + $(eval $@_output = $(call kubetype-gen,./testdata/test_input/positive/types,types)) + @echo "${$@_output}" | grep -q "Errors occurred while scanning input. See previous output for details."; test $$? || (echo "kubetype-gen command failed" && echo "${$@_output}" && false) + @echo "${$@_output}" | grep -q "Invalid value specified for +kubetype-gen:kubeType in .*/test_input/positive/types.EmptyKubeType. Using default name EmptyKubeType." || (echo "Missing warning for types.EmptyKubeType" && echo "${$@_output}" && false) + @if ! git diff --quiet HEAD -- tests || [ -n "$$(git ls-files -o -- tests)" ]; then \ + echo "FAIL: output files have changed"; \ + false; \ + fi + + +run-negative-tests: run-negative-defaults-empty-group-test run-negative-defaults-invalid-group-version-test run-negative-types-test + +run-negative-defaults-empty-group-test: check-env + @echo "Running $@" + $(eval $@_output = $(call kubetype-gen,./testdata/test_input/negative/defaults/emptygroup,fail)) + @echo "${$@_output}" | grep -q "Errors occurred while scanning input. See previous output for details." || (echo "kubetype-gen command should have failed" && echo "${$@_output}" && false) + @echo "${$@_output}" | grep -q "Invalid Group/Version for package .*/test_input/negative/defaults/emptygroup, Group not specified for Group/Version: groupversion" || (echo "negative/defaults/emptygroup test failed" && echo "${$@_output}" && false) + +run-negative-defaults-invalid-group-version-test: check-env + @echo "Running $@" + $(eval $@_output = $(call kubetype-gen,./testdata/test_input/negative/defaults/invalidgroupversion,fail)) + @echo "${$@_output}" | grep -q "Errors occurred while scanning input. See previous output for details." || (echo "kubetype-gen command should have failed" && echo "${$@_output}" && false) + @echo "${$@_output}" | grep -q "Could not calculate Group/Version for package .*/test_input/negative/defaults/invalidgroupversion: invalid group version 'group/version/version' specified: unexpected GroupVersion string: group/version/version" || (echo "negative/defaults/invalidgroupversion test failed" && echo "${$@_output}" && false) + +run-negative-types-test: check-env + @echo "Running $@" + $(eval $@_output = $(call kubetype-gen,./testdata/test_input/negative/types,fail)) + @echo "${$@_output}" | grep -q "Errors occurred while scanning input. See previous output for details." || (echo "kubetype-gen command should have failed" && echo "${$@_output}" && false) + @echo "${$@_output}" | grep -qE "duplicate kube types specified for istio.io/tools/cmd/kubetype-gen/testdata/test_output/fail/group/version.AGoodType. duplicated by: \[istio.io/tools/cmd/kubetype-gen/testdata/test_input/negative/types.(AGoodType|DuplicateKubeType) istio.io/tools/cmd/kubetype-gen/testdata/test_input/negative/types.(AGoodType|DuplicateKubeType)\]" || (echo "types.DuplicateKubeType test failed" && echo "${$@_output}" && false) + @echo "${$@_output}" | grep -q "Invalid Group/Version for type .*/test_input/negative/types.EmptyGroup: groupversion" || (echo "types.EmptyGroup test failed" && echo "${$@_output}" && false) + @echo "${$@_output}" | grep -q "Could not calculate Group/Version for type .*/test_input/negative/types.InvalidGroupVersion: invalid group version 'group/version/version' specified" || (echo "types.InvalidGroupVersion test failed" && echo "${$@_output}" && false) + @echo "${$@_output}" | grep -q "Invalid Group/Version for type .*/test_input/negative/types.NoGroupVersion: " || (echo "types.NoGroupVersion test failed" && echo "${$@_output}" && false) + @echo "${$@_output}" | grep -qE "Overlapping packages for Group/Versions group2(.name.io)?/version and group2(.name.io)?/version" || (echo "types.OverlappingPackageGroupType test failed" && echo "${$@_output}" && false) + @echo "${$@_output}" | grep -q "Could not create metadata for type: .*/test_input/negative/types.OverlappingPackageGroupType." || (echo "types.OverlappingPackageGroupType test failed" && echo "${$@_output}" && false) diff --git a/cmd/kubetype-gen/testdata/test_input/negative/defaults/emptygroup/doc.go b/cmd/kubetype-gen/testdata/test_input/negative/defaults/emptygroup/doc.go new file mode 100644 index 0000000000..0ca9bb2e51 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_input/negative/defaults/emptygroup/doc.go @@ -0,0 +1,4 @@ +// Package emptygroup is for test +// test should fail because the group in group/version is missing +// +kubetype-gen:groupVersion=groupversion +package emptygroup diff --git a/cmd/kubetype-gen/testdata/test_input/negative/defaults/emptygroup/type.go b/cmd/kubetype-gen/testdata/test_input/negative/defaults/emptygroup/type.go new file mode 100644 index 0000000000..1c19f454a9 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_input/negative/defaults/emptygroup/type.go @@ -0,0 +1,7 @@ +package emptygroup + +// Test is for test +// +kubetype-gen +type Test struct { + Field string +} diff --git a/cmd/kubetype-gen/testdata/test_input/negative/defaults/invalidgroupversion/doc.go b/cmd/kubetype-gen/testdata/test_input/negative/defaults/invalidgroupversion/doc.go new file mode 100644 index 0000000000..1c6518e295 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_input/negative/defaults/invalidgroupversion/doc.go @@ -0,0 +1,4 @@ +// Package invalidgroupversion is for test +// test should fail because the group/version is invalid (schema.ParseGroupVersion() error) +// +kubetype-gen:groupVersion=group/version/version +package invalidgroupversion diff --git a/cmd/kubetype-gen/testdata/test_input/negative/defaults/invalidgroupversion/type.go b/cmd/kubetype-gen/testdata/test_input/negative/defaults/invalidgroupversion/type.go new file mode 100644 index 0000000000..80a50dd577 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_input/negative/defaults/invalidgroupversion/type.go @@ -0,0 +1,7 @@ +package invalidgroupversion + +// Test is for test +// +kubetype-gen +type Test struct { + Field string +} diff --git a/cmd/kubetype-gen/testdata/test_input/negative/types/type.go b/cmd/kubetype-gen/testdata/test_input/negative/types/type.go new file mode 100644 index 0000000000..db4abeab88 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_input/negative/types/type.go @@ -0,0 +1,57 @@ +package types + +// NoGroupVersion is for test +// test should fail because kubetype-gen:groupVersion is missing +// +kubetype-gen +type NoGroupVersion struct { + Field string +} + +// InvalidGroupVersion is for test +// test should fail because kubetype-gen:groupVersion is invalid (schema.ParseGroupVersion() error) +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version/version +type InvalidGroupVersion struct { + Field string +} + +// EmptyGroup is for test +// test should fail because group/version is missing group +// +kubetype-gen +// +kubetype-gen:groupVersion=groupversion +type EmptyGroup struct { + Field string +} + +// AGoodType is for test +// a good type used for other failures +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +type AGoodType struct { + Field string +} + +// DuplicateKubeType is for test +// this test should fail because it specifies a kubeType name that is used for another type +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +// +kubetype-gen:kubeType=AGoodType +type DuplicateKubeType struct { + Field string +} + +// OverlappingPackageGroupType1 is for test +// this test should fail because the target package for the group conflicts with another group (group2.name.io same package as group2) +// +kubetype-gen +// +kubetype-gen:groupVersion=group2.name.io/version +type OverlappingPackageGroupType1 struct { + Field string +} + +// OverlappingPackageGroupType2 is for test +// this test should fail because the target package for the group conflicts with another group (group2.name.io same package as group2) +// +kubetype-gen +// +kubetype-gen:groupVersion=group2/version +type OverlappingPackageGroupType2 struct { + Field string +} diff --git a/cmd/kubetype-gen/testdata/test_input/positive/defaults/doc.go b/cmd/kubetype-gen/testdata/test_input/positive/defaults/doc.go new file mode 100644 index 0000000000..eff0b61739 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_input/positive/defaults/doc.go @@ -0,0 +1,4 @@ +// Package defaults is for test +// +kubetype-gen:package=success/defaults +// +kubetype-gen:groupVersion=group/version +package defaults diff --git a/cmd/kubetype-gen/testdata/test_input/positive/defaults/type.go b/cmd/kubetype-gen/testdata/test_input/positive/defaults/type.go new file mode 100644 index 0000000000..3f419ec9e6 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_input/positive/defaults/type.go @@ -0,0 +1,20 @@ +package defaults + +// AllOverridden is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group2/version2 +// +kubetype-gen:package=success/defaults/override +type AllOverridden struct { + Field string +} + +// Defaulted is for test +// +kubetype-gen +type Defaulted struct { + Field string +} + +// NotGenerated is for test +type NotGenerated struct { + Field string +} diff --git a/cmd/kubetype-gen/testdata/test_input/positive/types/type.go b/cmd/kubetype-gen/testdata/test_input/positive/types/type.go new file mode 100644 index 0000000000..f38332c2af --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_input/positive/types/type.go @@ -0,0 +1,50 @@ +package types + +// Type1 is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +type Type1 struct { + Field string +} + +// NameOverride is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +// +kubetype-gen:kubeType=Type2 +type NameOverride struct { + Field string +} + +// MultipleNames is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +// +kubetype-gen:kubeType=Type3 +// +kubetype-gen:kubeType=Type4 +// +kubetype-gen:Type4:tag=sometag=somevalue +type MultipleNames struct { + Field string +} + +// EmptyKubeType is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +// +kubetype-gen:kubeType +type EmptyKubeType struct { + Field string +} + +// ComplexGroupVersionKubeType is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group2.test.io/version +// +kubetype-gen:kubeType +type ComplexGroupVersionKubeType struct { + Field string +} + +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version + +// SecondCommentsKubeType is for test +type SecondCommentsKubeType struct { + Field string +} diff --git a/cmd/kubetype-gen/testdata/test_output/defaults/group/version/doc.go b/cmd/kubetype-gen/testdata/test_output/defaults/group/version/doc.go new file mode 100644 index 0000000000..b10ed8f39b --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/defaults/group/version/doc.go @@ -0,0 +1,20 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +// Package has auto-generated kube type wrappers for raw types. +// +k8s:openapi-gen=true +// +k8s:deepcopy-gen=package +package version diff --git a/cmd/kubetype-gen/testdata/test_output/defaults/group/version/register.go b/cmd/kubetype-gen/testdata/test_output/defaults/group/version/register.go new file mode 100644 index 0000000000..3364dbe777 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/defaults/group/version/register.go @@ -0,0 +1,49 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +package version + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + schema "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + // Package-wide variables from generator "register". + SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "version"} + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + localSchemeBuilder = &SchemeBuilder + AddToScheme = localSchemeBuilder.AddToScheme +) + +const ( + // Package-wide consts from generator "register". + GroupName = "group" +) + +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &Defaulted{}, + &DefaultedList{}, + ) + v1.AddToGroupVersion(scheme, SchemeGroupVersion) + return nil +} diff --git a/cmd/kubetype-gen/testdata/test_output/defaults/group/version/types.go b/cmd/kubetype-gen/testdata/test_output/defaults/group/version/types.go new file mode 100644 index 0000000000..75859bc56a --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/defaults/group/version/types.go @@ -0,0 +1,47 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +package version + +import ( + defaults "istio.io/tools/cmd/kubetype-gen/tests/test_input/positive/defaults" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// Defaulted is for test +// +kubetype-gen +type Defaulted struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // Spec defines the implementation of this definition. + // +optional + Spec defaults.Defaulted `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// DefaultedList is a collection of Defaulteds. +type DefaultedList struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + Items []Defaulted `json:"items" protobuf:"bytes,2,rep,name=items"` +} diff --git a/cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/doc.go b/cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/doc.go new file mode 100644 index 0000000000..af05d9bc08 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/doc.go @@ -0,0 +1,20 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +// Package has auto-generated kube type wrappers for raw types. +// +k8s:openapi-gen=true +// +k8s:deepcopy-gen=package +package version2 diff --git a/cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/register.go b/cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/register.go new file mode 100644 index 0000000000..ba2b4b8be2 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/register.go @@ -0,0 +1,49 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +package version2 + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + schema "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + // Package-wide variables from generator "register". + SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "version2"} + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + localSchemeBuilder = &SchemeBuilder + AddToScheme = localSchemeBuilder.AddToScheme +) + +const ( + // Package-wide consts from generator "register". + GroupName = "group2" +) + +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &AllOverridden{}, + &AllOverriddenList{}, + ) + v1.AddToGroupVersion(scheme, SchemeGroupVersion) + return nil +} diff --git a/cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/types.go b/cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/types.go new file mode 100644 index 0000000000..5398ec5b9e --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/defaults/group2/version2/types.go @@ -0,0 +1,49 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +package version2 + +import ( + defaults "istio.io/tools/cmd/kubetype-gen/tests/test_input/positive/defaults" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// AllOverridden is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group2/version2 +// +kubetype-gen:package=success/defaults/override +type AllOverridden struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // Spec defines the implementation of this definition. + // +optional + Spec defaults.AllOverridden `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// AllOverriddenList is a collection of AllOverriddens. +type AllOverriddenList struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + Items []AllOverridden `json:"items" protobuf:"bytes,2,rep,name=items"` +} diff --git a/cmd/kubetype-gen/testdata/test_output/types/group/version/doc.go b/cmd/kubetype-gen/testdata/test_output/types/group/version/doc.go new file mode 100644 index 0000000000..b10ed8f39b --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/types/group/version/doc.go @@ -0,0 +1,20 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +// Package has auto-generated kube type wrappers for raw types. +// +k8s:openapi-gen=true +// +k8s:deepcopy-gen=package +package version diff --git a/cmd/kubetype-gen/testdata/test_output/types/group/version/register.go b/cmd/kubetype-gen/testdata/test_output/types/group/version/register.go new file mode 100644 index 0000000000..f36f63aa0d --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/types/group/version/register.go @@ -0,0 +1,59 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +package version + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + schema "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + // Package-wide variables from generator "register". + SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "version"} + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + localSchemeBuilder = &SchemeBuilder + AddToScheme = localSchemeBuilder.AddToScheme +) + +const ( + // Package-wide consts from generator "register". + GroupName = "group" +) + +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &EmptyKubeType{}, + &EmptyKubeTypeList{}, + &SecondCommentsKubeType{}, + &SecondCommentsKubeTypeList{}, + &Type1{}, + &Type1List{}, + &Type2{}, + &Type2List{}, + &Type3{}, + &Type3List{}, + &Type4{}, + &Type4List{}, + ) + v1.AddToGroupVersion(scheme, SchemeGroupVersion) + return nil +} diff --git a/cmd/kubetype-gen/testdata/test_output/types/group/version/types.go b/cmd/kubetype-gen/testdata/test_output/types/group/version/types.go new file mode 100644 index 0000000000..7757045e25 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/types/group/version/types.go @@ -0,0 +1,186 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +package version + +import ( + types "istio.io/tools/cmd/kubetype-gen/tests/test_input/positive/types" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// EmptyKubeType is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +// +kubetype-gen:kubeType +type EmptyKubeType struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // Spec defines the implementation of this definition. + // +optional + Spec types.EmptyKubeType `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// EmptyKubeTypeList is a collection of EmptyKubeTypes. +type EmptyKubeTypeList struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + Items []EmptyKubeType `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +// +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// MultipleNames is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +// +kubetype-gen:kubeType=Type3 +// +kubetype-gen:kubeType=Type4 +// +kubetype-gen:Type4:tag=sometag=somevalue +type Type3 struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // Spec defines the implementation of this definition. + // +optional + Spec types.MultipleNames `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// Type3List is a collection of Type3s. +type Type3List struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + Items []Type3 `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +// +// +sometag=somevalue +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// MultipleNames is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +// +kubetype-gen:kubeType=Type3 +// +kubetype-gen:kubeType=Type4 +// +kubetype-gen:Type4:tag=sometag=somevalue +type Type4 struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // Spec defines the implementation of this definition. + // +optional + Spec types.MultipleNames `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// Type4List is a collection of Type4s. +type Type4List struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + Items []Type4 `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +// +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// NameOverride is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +// +kubetype-gen:kubeType=Type2 +type Type2 struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // Spec defines the implementation of this definition. + // +optional + Spec types.NameOverride `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// Type2List is a collection of Type2s. +type Type2List struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + Items []Type2 `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// SecondCommentsKubeType is for test +type SecondCommentsKubeType struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // Spec defines the implementation of this definition. + // +optional + Spec types.SecondCommentsKubeType `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// SecondCommentsKubeTypeList is a collection of SecondCommentsKubeTypes. +type SecondCommentsKubeTypeList struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + Items []SecondCommentsKubeType `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +// +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// Type1 is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group/version +type Type1 struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // Spec defines the implementation of this definition. + // +optional + Spec types.Type1 `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// Type1List is a collection of Type1s. +type Type1List struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + Items []Type1 `json:"items" protobuf:"bytes,2,rep,name=items"` +} diff --git a/cmd/kubetype-gen/testdata/test_output/types/group2/version/doc.go b/cmd/kubetype-gen/testdata/test_output/types/group2/version/doc.go new file mode 100644 index 0000000000..b10ed8f39b --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/types/group2/version/doc.go @@ -0,0 +1,20 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +// Package has auto-generated kube type wrappers for raw types. +// +k8s:openapi-gen=true +// +k8s:deepcopy-gen=package +package version diff --git a/cmd/kubetype-gen/testdata/test_output/types/group2/version/register.go b/cmd/kubetype-gen/testdata/test_output/types/group2/version/register.go new file mode 100644 index 0000000000..8f5b096345 --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/types/group2/version/register.go @@ -0,0 +1,49 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +package version + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + schema "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + // Package-wide variables from generator "register". + SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "version"} + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + localSchemeBuilder = &SchemeBuilder + AddToScheme = localSchemeBuilder.AddToScheme +) + +const ( + // Package-wide consts from generator "register". + GroupName = "group2.test.io" +) + +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &ComplexGroupVersionKubeType{}, + &ComplexGroupVersionKubeTypeList{}, + ) + v1.AddToGroupVersion(scheme, SchemeGroupVersion) + return nil +} diff --git a/cmd/kubetype-gen/testdata/test_output/types/group2/version/types.go b/cmd/kubetype-gen/testdata/test_output/types/group2/version/types.go new file mode 100644 index 0000000000..48ae67be2f --- /dev/null +++ b/cmd/kubetype-gen/testdata/test_output/types/group2/version/types.go @@ -0,0 +1,49 @@ +// Copyright 2019 Istio 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. + +// Code generated by kubetype-gen. DO NOT EDIT. + +package version + +import ( + types "istio.io/tools/cmd/kubetype-gen/tests/test_input/positive/types" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// ComplexGroupVersionKubeType is for test +// +kubetype-gen +// +kubetype-gen:groupVersion=group2.test.io/version +// +kubetype-gen:kubeType +type ComplexGroupVersionKubeType struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // Spec defines the implementation of this definition. + // +optional + Spec types.ComplexGroupVersionKubeType `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// ComplexGroupVersionKubeTypeList is a collection of ComplexGroupVersionKubeTypes. +type ComplexGroupVersionKubeTypeList struct { + v1.TypeMeta `json:",inline"` + // +optional + v1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + Items []ComplexGroupVersionKubeType `json:"items" protobuf:"bytes,2,rep,name=items"` +}