gen client

Signed-off-by: runzexia <runzexia@yunify.com>

vendor/k8s.io/kube-openapi/pkg/generators/api_linter.go

@@ -139,6 +139,7 @@ func newAPILinter() *apiLinter {
 		rules: []APIRule{
 			&rules.NamesMatch{},
 			&rules.OmitEmptyMatchCase{},
+			&rules.ListTypeMissing{},
 		},
 	}
 }

vendor/k8s.io/kube-openapi/pkg/generators/openapi.go

@@ -171,7 +171,7 @@ func (g *openAPIGen) Init(c *generator.Context, w io.Writer) error {
 	sw.Do("return map[string]$.OpenAPIDefinition|raw${\n", argsFromType(nil))
 
 	for _, t := range c.Order {
-		err := newOpenAPITypeWriter(sw).generateCall(t)
+		err := newOpenAPITypeWriter(sw, c).generateCall(t)
 		if err != nil {
 			return err
 		}
@@ -186,7 +186,7 @@ func (g *openAPIGen) Init(c *generator.Context, w io.Writer) error {
 func (g *openAPIGen) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
 	klog.V(5).Infof("generating for type %v", t)
 	sw := generator.NewSnippetWriter(w, c, "$", "$")
-	err := newOpenAPITypeWriter(sw).generate(t)
+	err := newOpenAPITypeWriter(sw, c).generate(t)
 	if err != nil {
 		return err
 	}
@@ -221,13 +221,15 @@ func shouldInlineMembers(m *types.Member) bool {
 
 type openAPITypeWriter struct {
 	*generator.SnippetWriter
+	context                *generator.Context
 	refTypes               map[string]*types.Type
 	GetDefinitionInterface *types.Type
 }
 
-func newOpenAPITypeWriter(sw *generator.SnippetWriter) openAPITypeWriter {
+func newOpenAPITypeWriter(sw *generator.SnippetWriter, c *generator.Context) openAPITypeWriter {
 	return openAPITypeWriter{
 		SnippetWriter: sw,
+		context:       c,
 		refTypes:      map[string]*types.Type{},
 	}
 }
@@ -336,12 +338,23 @@ func (g openAPITypeWriter) generate(t *types.Type) error {
 		}
 		g.Do("return $.OpenAPIDefinition|raw${\nSchema: spec.Schema{\nSchemaProps: spec.SchemaProps{\n", args)
 		g.generateDescription(t.CommentLines)
-		g.Do("Properties: map[string]$.SpecSchemaType|raw${\n", args)
-		required, err := g.generateMembers(t, []string{})
+		g.Do("Type: []string{\"object\"},\n", nil)
+
+		// write members into a temporary buffer, in order to postpone writing out the Properties field. We only do
+		// that if it is not empty.
+		propertiesBuf := bytes.Buffer{}
+		bsw := g
+		bsw.SnippetWriter = generator.NewSnippetWriter(&propertiesBuf, g.context, "$", "$")
+		required, err := bsw.generateMembers(t, []string{})
 		if err != nil {
 			return err
 		}
-		g.Do("},\n", nil)
+		if propertiesBuf.Len() > 0 {
+			g.Do("Properties: map[string]$.SpecSchemaType|raw${\n", args)
+			g.Do(strings.Replace(propertiesBuf.String(), "$", "$\"$\"$", -1), nil) // escape $ (used as delimiter of the templates)
+			g.Do("},\n", nil)
+		}
+
 		if len(required) > 0 {
 			g.Do("Required: []string{\"$.$\"},\n", strings.Join(required, "\",\""))
 		}
@@ -350,13 +363,14 @@ func (g openAPITypeWriter) generate(t *types.Type) error {
 			return err
 		}
 		g.Do("},\n", nil)
-		g.Do("Dependencies: []string{\n", args)
+
 		// Map order is undefined, sort them or we may get a different file generated each time.
 		keys := []string{}
 		for k := range g.refTypes {
 			keys = append(keys, k)
 		}
 		sort.Strings(keys)
+		deps := []string{}
 		for _, k := range keys {
 			v := g.refTypes[k]
 			if t, _ := openapi.GetOpenAPITypeFormat(v.String()); t != "" {
@@ -364,9 +378,16 @@ func (g openAPITypeWriter) generate(t *types.Type) error {
 				// Will eliminate special case of time.Time
 				continue
 			}
-			g.Do("\"$.$\",", k)
+			deps = append(deps, k)
 		}
-		g.Do("},\n}\n}\n\n", nil)
+		if len(deps) > 0 {
+			g.Do("Dependencies: []string{\n", args)
+			for _, k := range deps {
+				g.Do("\"$.$\",", k)
+			}
+			g.Do("},\n", nil)
+		}
+		g.Do("}\n}\n\n", nil)
 	}
 	return nil
 }
@@ -376,11 +397,18 @@ func (g openAPITypeWriter) generateStructExtensions(t *types.Type) error {
 	// Initially, we will only log struct extension errors.
 	if len(errors) > 0 {
 		for _, e := range errors {
-			klog.V(2).Infof("[%s]: %s\n", t.String(), e)
+			klog.Errorf("[%s]: %s\n", t.String(), e)
 		}
 	}
+	unions, errors := parseUnions(t)
+	if len(errors) > 0 {
+		for _, e := range errors {
+			klog.Errorf("[%s]: %s\n", t.String(), e)
+		}
+	}
+
 	// TODO(seans3): Validate struct extensions here.
-	g.emitExtensions(extensions)
+	g.emitExtensions(extensions, unions)
 	return nil
 }
 
@@ -395,20 +423,20 @@ func (g openAPITypeWriter) generateMemberExtensions(m *types.Member, parent *typ
 			klog.V(2).Infof("%s %s\n", errorPrefix, e)
 		}
 	}
-	g.emitExtensions(extensions)
+	g.emitExtensions(extensions, nil)
 	return nil
 }
 
-func (g openAPITypeWriter) emitExtensions(extensions []extension) {
+func (g openAPITypeWriter) emitExtensions(extensions []extension, unions []union) {
 	// If any extensions exist, then emit code to create them.
-	if len(extensions) == 0 {
+	if len(extensions) == 0 && len(unions) == 0 {
 		return
 	}
 	g.Do("VendorExtensible: spec.VendorExtensible{\nExtensions: spec.Extensions{\n", nil)
 	for _, extension := range extensions {
 		g.Do("\"$.$\": ", extension.xName)
 		if extension.hasMultipleValues() {
-			g.Do("[]string{\n", nil)
+			g.Do("[]interface{}{\n", nil)
 		}
 		for _, value := range extension.values {
 			g.Do("\"$.$\",\n", value)
@@ -417,6 +445,13 @@ func (g openAPITypeWriter) emitExtensions(extensions []extension) {
 			g.Do("},\n", nil)
 		}
 	}
+	if len(unions) > 0 {
+		g.Do("\"x-kubernetes-unions\": []interface{}{\n", nil)
+		for _, u := range unions {
+			u.emit(g)
+		}
+		g.Do("},\n", nil)
+	}
 	g.Do("},\n},\n", nil)
 }
 
@@ -561,7 +596,7 @@ func (g openAPITypeWriter) generateMapProperty(t *types.Type) error {
 		return fmt.Errorf("map with non-string keys are not supported by OpenAPI in %v", t)
 	}
 	g.Do("Type: []string{\"object\"},\n", nil)
-	g.Do("AdditionalProperties: &spec.SchemaOrBool{\nSchema: &spec.Schema{\nSchemaProps: spec.SchemaProps{\n", nil)
+	g.Do("AdditionalProperties: &spec.SchemaOrBool{\nAllows: true,\nSchema: &spec.Schema{\nSchemaProps: spec.SchemaProps{\n", nil)
 	typeString, format := openapi.GetOpenAPITypeFormat(elemType.String())
 	if typeString != "" {
 		g.generateSimpleProperty(typeString, format)

vendor/k8s.io/kube-openapi/pkg/generators/rules/idl_tag.go

@@ -0,0 +1,36 @@
+package rules
+
+import (
+	"k8s.io/gengo/types"
+)
+
+const ListTypeIDLTag = "listType"
+
+// ListTypeMissing implements APIRule interface.
+// A list type is required for inlined list.
+type ListTypeMissing struct{}
+
+// Name returns the name of APIRule
+func (l *ListTypeMissing) Name() string {
+	return "list_type_missing"
+}
+
+// Validate evaluates API rule on type t and returns a list of field names in
+// the type that violate the rule. Empty field name [""] implies the entire
+// type violates the rule.
+func (l *ListTypeMissing) Validate(t *types.Type) ([]string, error) {
+	fields := make([]string, 0)
+
+	switch t.Kind {
+	case types.Struct:
+		for _, m := range t.Members {
+			if m.Type.Kind == types.Slice && types.ExtractCommentTags("+", m.CommentLines)[ListTypeIDLTag] == nil {
+				fields = append(fields, m.Name)
+				continue
+			}
+		}
+	}
+
+	return fields, nil
+
+}

vendor/k8s.io/kube-openapi/pkg/generators/union.go

@@ -0,0 +1,207 @@
+/*
+Copyright 2016 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 generators
+
+import (
+	"fmt"
+	"sort"
+
+	"k8s.io/gengo/types"
+)
+
+const tagUnionMember = "union"
+const tagUnionDeprecated = "unionDeprecated"
+const tagUnionDiscriminator = "unionDiscriminator"
+
+type union struct {
+	discriminator         string
+	fieldsToDiscriminated map[string]string
+}
+
+// emit prints the union, can be called on a nil union (emits nothing)
+func (u *union) emit(g openAPITypeWriter) {
+	if u == nil {
+		return
+	}
+	g.Do("map[string]interface{}{\n", nil)
+	if u.discriminator != "" {
+		g.Do("\"discriminator\": \"$.$\",\n", u.discriminator)
+	}
+	g.Do("\"fields-to-discriminateBy\": map[string]interface{}{\n", nil)
+	keys := []string{}
+	for field := range u.fieldsToDiscriminated {
+		keys = append(keys, field)
+	}
+	sort.Strings(keys)
+	for _, field := range keys {
+		g.Do("\"$.$\": ", field)
+		g.Do("\"$.$\",\n", u.fieldsToDiscriminated[field])
+	}
+	g.Do("},\n", nil)
+	g.Do("},\n", nil)
+}
+
+// Sets the discriminator if it's not set yet, otherwise return an error
+func (u *union) setDiscriminator(value string) []error {
+	errors := []error{}
+	if u.discriminator != "" {
+		errors = append(errors, fmt.Errorf("at least two discriminators found: %v and %v", value, u.discriminator))
+	}
+	u.discriminator = value
+	return errors
+}
+
+// Add a new member to the union
+func (u *union) addMember(jsonName, variableName string) {
+	if _, ok := u.fieldsToDiscriminated[jsonName]; ok {
+		panic(fmt.Errorf("same field (%v) found multiple times", jsonName))
+	}
+	u.fieldsToDiscriminated[jsonName] = variableName
+}
+
+// Makes sure that the union is valid, specifically looking for re-used discriminated
+func (u *union) isValid() []error {
+	errors := []error{}
+	// Case 1: discriminator but no fields
+	if u.discriminator != "" && len(u.fieldsToDiscriminated) == 0 {
+		errors = append(errors, fmt.Errorf("discriminator set with no fields in union"))
+	}
+	// Case 2: two fields have the same discriminated value
+	discriminated := map[string]struct{}{}
+	for _, d := range u.fieldsToDiscriminated {
+		if _, ok := discriminated[d]; ok {
+			errors = append(errors, fmt.Errorf("discriminated value is used twice: %v", d))
+		}
+		discriminated[d] = struct{}{}
+	}
+	// Case 3: a field is both discriminator AND part of the union
+	if u.discriminator != "" {
+		if _, ok := u.fieldsToDiscriminated[u.discriminator]; ok {
+			errors = append(errors, fmt.Errorf("%v can't be both discriminator and part of the union", u.discriminator))
+		}
+	}
+	return errors
+}
+
+// Find unions either directly on the members (or inlined members, not
+// going across types) or on the type itself, or on embedded types.
+func parseUnions(t *types.Type) ([]union, []error) {
+	errors := []error{}
+	unions := []union{}
+	su, err := parseUnionStruct(t)
+	if su != nil {
+		unions = append(unions, *su)
+	}
+	errors = append(errors, err...)
+	eu, err := parseEmbeddedUnion(t)
+	unions = append(unions, eu...)
+	errors = append(errors, err...)
+	mu, err := parseUnionMembers(t)
+	if mu != nil {
+		unions = append(unions, *mu)
+	}
+	errors = append(errors, err...)
+	return unions, errors
+}
+
+// Find unions in embedded types, unions shouldn't go across types.
+func parseEmbeddedUnion(t *types.Type) ([]union, []error) {
+	errors := []error{}
+	unions := []union{}
+	for _, m := range t.Members {
+		if hasOpenAPITagValue(m.CommentLines, tagValueFalse) {
+			continue
+		}
+		if !shouldInlineMembers(&m) {
+			continue
+		}
+		u, err := parseUnions(m.Type)
+		unions = append(unions, u...)
+		errors = append(errors, err...)
+	}
+	return unions, errors
+}
+
+// Look for union tag on a struct, and then include all the fields
+// (except the discriminator if there is one). The struct shouldn't have
+// embedded types.
+func parseUnionStruct(t *types.Type) (*union, []error) {
+	errors := []error{}
+	if types.ExtractCommentTags("+", t.CommentLines)[tagUnionMember] == nil {
+		return nil, nil
+	}
+
+	u := &union{fieldsToDiscriminated: map[string]string{}}
+
+	for _, m := range t.Members {
+		jsonName := getReferableName(&m)
+		if jsonName == "" {
+			continue
+		}
+		if shouldInlineMembers(&m) {
+			errors = append(errors, fmt.Errorf("union structures can't have embedded fields: %v.%v", t.Name, m.Name))
+			continue
+		}
+		if types.ExtractCommentTags("+", m.CommentLines)[tagUnionDeprecated] != nil {
+			errors = append(errors, fmt.Errorf("union struct can't have unionDeprecated members: %v.%v", t.Name, m.Name))
+			continue
+		}
+		if types.ExtractCommentTags("+", m.CommentLines)[tagUnionDiscriminator] != nil {
+			errors = append(errors, u.setDiscriminator(jsonName)...)
+		} else {
+			if !hasOptionalTag(&m) {
+				errors = append(errors, fmt.Errorf("union members must be optional: %v.%v", t.Name, m.Name))
+			}
+			u.addMember(jsonName, m.Name)
+		}
+	}
+
+	return u, errors
+}
+
+// Find unions specifically on members.
+func parseUnionMembers(t *types.Type) (*union, []error) {
+	errors := []error{}
+	u := &union{fieldsToDiscriminated: map[string]string{}}
+
+	for _, m := range t.Members {
+		jsonName := getReferableName(&m)
+		if jsonName == "" {
+			continue
+		}
+		if shouldInlineMembers(&m) {
+			continue
+		}
+		if types.ExtractCommentTags("+", m.CommentLines)[tagUnionDiscriminator] != nil {
+			errors = append(errors, u.setDiscriminator(jsonName)...)
+		}
+		if types.ExtractCommentTags("+", m.CommentLines)[tagUnionMember] != nil {
+			errors = append(errors, fmt.Errorf("union tag is not accepted on struct members: %v.%v", t.Name, m.Name))
+			continue
+		}
+		if types.ExtractCommentTags("+", m.CommentLines)[tagUnionDeprecated] != nil {
+			if !hasOptionalTag(&m) {
+				errors = append(errors, fmt.Errorf("union members must be optional: %v.%v", t.Name, m.Name))
+			}
+			u.addMember(jsonName, m.Name)
+		}
+	}
+	if len(u.fieldsToDiscriminated) == 0 {
+		return nil, nil
+	}
+	return u, append(errors, u.isValid()...)
+}