recover kube-open version

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

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

@@ -139,7 +139,6 @@ 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, c).generateCall(t)
+		err := newOpenAPITypeWriter(sw).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, c).generate(t)
+	err := newOpenAPITypeWriter(sw).generate(t)
 	if err != nil {
 		return err
 	}
@@ -221,15 +221,13 @@ 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, c *generator.Context) openAPITypeWriter {
+func newOpenAPITypeWriter(sw *generator.SnippetWriter) openAPITypeWriter {
 	return openAPITypeWriter{
 		SnippetWriter: sw,
-		context:       c,
 		refTypes:      map[string]*types.Type{},
 	}
 }
@@ -338,23 +336,12 @@ 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("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{})
+		g.Do("Properties: map[string]$.SpecSchemaType|raw${\n", args)
+		required, err := g.generateMembers(t, []string{})
 		if err != nil {
 			return err
 		}
-		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)
-		}
-
+		g.Do("},\n", nil)
 		if len(required) > 0 {
 			g.Do("Required: []string{\"$.$\"},\n", strings.Join(required, "\",\""))
 		}
@@ -363,14 +350,13 @@ 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 != "" {
@@ -378,16 +364,9 @@ func (g openAPITypeWriter) generate(t *types.Type) error {
 				// Will eliminate special case of time.Time
 				continue
 			}
-			deps = append(deps, k)
+			g.Do("\"$.$\",", k)
 		}
-		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)
+		g.Do("},\n}\n}\n\n", nil)
 	}
 	return nil
 }
@@ -397,18 +376,11 @@ 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.Errorf("[%s]: %s\n", t.String(), e)
+			klog.V(2).Infof("[%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, unions)
+	g.emitExtensions(extensions)
 	return nil
 }
 
@@ -423,20 +395,20 @@ func (g openAPITypeWriter) generateMemberExtensions(m *types.Member, parent *typ
 			klog.V(2).Infof("%s %s\n", errorPrefix, e)
 		}
 	}
-	g.emitExtensions(extensions, nil)
+	g.emitExtensions(extensions)
 	return nil
 }
 
-func (g openAPITypeWriter) emitExtensions(extensions []extension, unions []union) {
+func (g openAPITypeWriter) emitExtensions(extensions []extension) {
 	// If any extensions exist, then emit code to create them.
-	if len(extensions) == 0 && len(unions) == 0 {
+	if len(extensions) == 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("[]interface{}{\n", nil)
+			g.Do("[]string{\n", nil)
 		}
 		for _, value := range extension.values {
 			g.Do("\"$.$\",\n", value)
@@ -445,13 +417,6 @@ func (g openAPITypeWriter) emitExtensions(extensions []extension, unions []union
 			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)
 }
 
@@ -596,7 +561,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{\nAllows: true,\nSchema: &spec.Schema{\nSchemaProps: spec.SchemaProps{\n", nil)
+	g.Do("AdditionalProperties: &spec.SchemaOrBool{\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

@@ -1,36 +0,0 @@
-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

@@ -1,207 +0,0 @@
-/*
-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()...)
-}