recover kube-open version

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

vendor/k8s.io/kube-openapi/cmd/openapi-gen/args/args.go

@@ -18,7 +18,6 @@ package args
 
 import (
 	"fmt"
-	"path/filepath"
 
 	"github.com/spf13/pflag"
 	"k8s.io/gengo/args"
@@ -39,8 +38,6 @@ func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
 	// WithoutDefaultFlagParsing() disables implicit addition of command line flags and parsing,
 	// which allows registering custom arguments afterwards
 	genericArgs := args.Default().WithoutDefaultFlagParsing()
-	genericArgs.GoHeaderFilePath = filepath.Join(args.DefaultSourceTree(), "k8s.io/kube-openapi/boilerplate/boilerplate.go.txt")
-
 	customArgs := &CustomArgs{}
 	genericArgs.CustomArgs = customArgs
 

vendor/k8s.io/kube-openapi/cmd/openapi-gen/openapi-gen.go

@@ -54,4 +54,5 @@ func main() {
 	); err != nil {
 		log.Fatalf("OpenAPI code generation error: %v", err)
 	}
+	log.Println("Code for OpenAPI definitions generated")
 }

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()...)
-}

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

@@ -20,21 +20,24 @@ import (
 	"bytes"
 	"compress/gzip"
 	"crypto/sha512"
+	"encoding/json"
 	"fmt"
 	"mime"
 	"net/http"
+	"strings"
 	"sync"
 	"time"
 
+	"bitbucket.org/ww/goautoneg"
+
+	yaml "gopkg.in/yaml.v2"
+
 	"github.com/NYTimes/gziphandler"
-	"github.com/emicklei/go-restful"
+	restful "github.com/emicklei/go-restful"
 	"github.com/go-openapi/spec"
 	"github.com/golang/protobuf/proto"
-	"github.com/googleapis/gnostic/OpenAPIv2"
+	openapi_v2 "github.com/googleapis/gnostic/OpenAPIv2"
 	"github.com/googleapis/gnostic/compiler"
-	"github.com/json-iterator/go"
-	"github.com/munnerz/goautoneg"
-	"gopkg.in/yaml.v2"
 
 	"k8s.io/kube-openapi/pkg/builder"
 	"k8s.io/kube-openapi/pkg/common"
@@ -76,13 +79,66 @@ func computeETag(data []byte) string {
 	return fmt.Sprintf("\"%X\"", sha512.Sum512(data))
 }
 
-// NewOpenAPIService builds an OpenAPIService starting with the given spec.
-func NewOpenAPIService(spec *spec.Swagger) (*OpenAPIService, error) {
-	o := &OpenAPIService{}
-	if err := o.UpdateSpec(spec); err != nil {
+// NOTE: [DEPRECATION] We will announce deprecation for format-separated endpoints for OpenAPI spec,
+// and switch to a single /openapi/v2 endpoint in Kubernetes 1.10. The design doc and deprecation process
+// are tracked at: https://docs.google.com/document/d/19lEqE9lc4yHJ3WJAJxS_G7TcORIJXGHyq3wpwcH28nU.
+//
+// BuildAndRegisterOpenAPIService builds the spec and registers a handler to provide access to it.
+// Use this method if your OpenAPI spec is static. If you want to update the spec, use BuildOpenAPISpec then RegisterOpenAPIService.
+func BuildAndRegisterOpenAPIService(servePath string, webServices []*restful.WebService, config *common.Config, handler common.PathHandler) (*OpenAPIService, error) {
+	spec, err := builder.BuildOpenAPISpec(webServices, config)
+	if err != nil {
 		return nil, err
 	}
-	return o, nil
+	return RegisterOpenAPIService(spec, servePath, handler)
+}
+
+// NOTE: [DEPRECATION] We will announce deprecation for format-separated endpoints for OpenAPI spec,
+// and switch to a single /openapi/v2 endpoint in Kubernetes 1.10. The design doc and deprecation process
+// are tracked at: https://docs.google.com/document/d/19lEqE9lc4yHJ3WJAJxS_G7TcORIJXGHyq3wpwcH28nU.
+//
+// RegisterOpenAPIService registers a handler to provide access to provided swagger spec.
+// Note: servePath should end with ".json" as the RegisterOpenAPIService assume it is serving a
+// json file and will also serve .pb and .gz files.
+func RegisterOpenAPIService(openapiSpec *spec.Swagger, servePath string, handler common.PathHandler) (*OpenAPIService, error) {
+	if !strings.HasSuffix(servePath, jsonExt) {
+		return nil, fmt.Errorf("serving path must end with \"%s\"", jsonExt)
+	}
+
+	servePathBase := strings.TrimSuffix(servePath, jsonExt)
+
+	o := OpenAPIService{}
+	if err := o.UpdateSpec(openapiSpec); err != nil {
+		return nil, err
+	}
+
+	type fileInfo struct {
+		ext            string
+		getDataAndETag func() ([]byte, string, time.Time)
+	}
+
+	files := []fileInfo{
+		{".json", o.getSwaggerBytes},
+		{"-2.0.0.json", o.getSwaggerBytes},
+		{"-2.0.0.pb-v1", o.getSwaggerPbBytes},
+		{"-2.0.0.pb-v1.gz", o.getSwaggerPbGzBytes},
+	}
+
+	for _, file := range files {
+		path := servePathBase + file.ext
+		getDataAndETag := file.getDataAndETag
+		handler.Handle(path, gziphandler.GzipHandler(http.HandlerFunc(
+			func(w http.ResponseWriter, r *http.Request) {
+				data, etag, lastModified := getDataAndETag()
+				w.Header().Set("Etag", etag)
+
+				// ServeContent will take care of caching using eTag.
+				http.ServeContent(w, r, path, lastModified, bytes.NewReader(data))
+			}),
+		))
+	}
+
+	return &o, nil
 }
 
 func (o *OpenAPIService) getSwaggerBytes() ([]byte, string, time.Time) {
@@ -104,15 +160,11 @@ func (o *OpenAPIService) getSwaggerPbGzBytes() ([]byte, string, time.Time) {
 }
 
 func (o *OpenAPIService) UpdateSpec(openapiSpec *spec.Swagger) (err error) {
-	specBytes, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(openapiSpec)
+	specBytes, err := json.MarshalIndent(openapiSpec, " ", " ")
 	if err != nil {
 		return err
 	}
-	var json map[string]interface{}
-	if err := jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(specBytes, &json); err != nil {
-		return err
-	}
-	specPb, err := ToProtoBinary(json)
+	specPb, err := toProtoBinary(specBytes)
 	if err != nil {
 		return err
 	}
@@ -138,50 +190,13 @@ func (o *OpenAPIService) UpdateSpec(openapiSpec *spec.Swagger) (err error) {
 	return nil
 }
 
-func jsonToYAML(j map[string]interface{}) yaml.MapSlice {
-	if j == nil {
-		return nil
+func toProtoBinary(spec []byte) ([]byte, error) {
+	var info yaml.MapSlice
+	err := yaml.Unmarshal(spec, &info)
+	if err != nil {
+		return nil, err
 	}
-	ret := make(yaml.MapSlice, 0, len(j))
-	for k, v := range j {
-		ret = append(ret, yaml.MapItem{k, jsonToYAMLValue(v)})
-	}
-	return ret
-}
-
-func jsonToYAMLValue(j interface{}) interface{} {
-	switch j := j.(type) {
-	case map[string]interface{}:
-		return jsonToYAML(j)
-	case []interface{}:
-		ret := make([]interface{}, len(j))
-		for i := range j {
-			ret[i] = jsonToYAMLValue(j[i])
-		}
-		return ret
-	case float64:
-		// replicate the logic in https://github.com/go-yaml/yaml/blob/51d6538a90f86fe93ac480b35f37b2be17fef232/resolve.go#L151
-		if i64 := int64(j); j == float64(i64) {
-			if i := int(i64); i64 == int64(i) {
-				return i
-			}
-			return i64
-		}
-		if ui64 := uint64(j); j == float64(ui64) {
-			return ui64
-		}
-		return j
-	case int64:
-		if i := int(j); j == int64(i) {
-			return i
-		}
-		return j
-	}
-	return j
-}
-
-func ToProtoBinary(json map[string]interface{}) ([]byte, error) {
-	document, err := openapi_v2.NewDocument(jsonToYAML(json), compiler.NewContext("$root", nil))
+	document, err := openapi_v2.NewDocument(info, compiler.NewContext("$root", nil))
 	if err != nil {
 		return nil, err
 	}
@@ -197,18 +212,12 @@ func toGzip(data []byte) []byte {
 }
 
 // RegisterOpenAPIVersionedService registers a handler to provide access to provided swagger spec.
-//
-// Deprecated: use OpenAPIService.RegisterOpenAPIVersionedService instead.
-func RegisterOpenAPIVersionedService(spec *spec.Swagger, servePath string, handler common.PathHandler) (*OpenAPIService, error) {
-	o, err := NewOpenAPIService(spec)
-	if err != nil {
+func RegisterOpenAPIVersionedService(openapiSpec *spec.Swagger, servePath string, handler common.PathHandler) (*OpenAPIService, error) {
+	o := OpenAPIService{}
+	if err := o.UpdateSpec(openapiSpec); err != nil {
 		return nil, err
 	}
-	return o, o.RegisterOpenAPIVersionedService(servePath, handler)
-}
 
-// RegisterOpenAPIVersionedService registers a handler to provide access to provided swagger spec.
-func (o *OpenAPIService) RegisterOpenAPIVersionedService(servePath string, handler common.PathHandler) error {
 	accepted := []struct {
 		Type           string
 		SubType        string
@@ -249,7 +258,7 @@ func (o *OpenAPIService) RegisterOpenAPIVersionedService(servePath string, handl
 		}),
 	))
 
-	return nil
+	return &o, nil
 }
 
 // BuildAndRegisterOpenAPIVersionedService builds the spec and registers a handler to provide access to it.
@@ -259,9 +268,5 @@ func BuildAndRegisterOpenAPIVersionedService(servePath string, webServices []*re
 	if err != nil {
 		return nil, err
 	}
-	o, err := NewOpenAPIService(spec)
-	if err != nil {
-		return nil, err
-	}
-	return o, o.RegisterOpenAPIVersionedService(servePath, handler)
+	return RegisterOpenAPIVersionedService(spec, servePath, handler)
 }

vendor/k8s.io/kube-openapi/pkg/util/proto/OWNERS

@@ -1,2 +0,0 @@
-approvers:
-- apelisse

vendor/k8s.io/kube-openapi/pkg/util/proto/document.go

@@ -92,16 +92,13 @@ func NewOpenAPIData(doc *openapi_v2.Document) (Models, error) {
 // We believe the schema is a reference, verify that and returns a new
 // Schema
 func (d *Definitions) parseReference(s *openapi_v2.Schema, path *Path) (Schema, error) {
-	// TODO(wrong): a schema with a $ref can have properties. We can ignore them (would be incomplete), but we cannot return an error.
 	if len(s.GetProperties().GetAdditionalProperties()) > 0 {
 		return nil, newSchemaError(path, "unallowed embedded type definition")
 	}
-	// TODO(wrong): a schema with a $ref can have a type. We can ignore it (would be incomplete), but we cannot return an error.
 	if len(s.GetType().GetValue()) > 0 {
 		return nil, newSchemaError(path, "definition reference can't have a type")
 	}
 
-	// TODO(wrong): $refs outside of the definitions are completely valid. We can ignore them (would be incomplete), but we cannot return an error.
 	if !strings.HasPrefix(s.GetXRef(), "#/definitions/") {
 		return nil, newSchemaError(path, "unallowed reference to non-definition %q", s.GetXRef())
 	}
@@ -130,7 +127,6 @@ func (d *Definitions) parseMap(s *openapi_v2.Schema, path *Path) (Schema, error)
 		return nil, newSchemaError(path, "invalid object type")
 	}
 	var sub Schema
-	// TODO(incomplete): this misses the boolean case as AdditionalProperties is a bool+schema sum type.
 	if s.GetAdditionalProperties().GetSchema() == nil {
 		sub = &Arbitrary{
 			BaseSchema: d.parseBaseSchema(s, path),
@@ -161,7 +157,6 @@ func (d *Definitions) parsePrimitive(s *openapi_v2.Schema, path *Path) (Schema,
 	case Number: // do nothing
 	case Integer: // do nothing
 	case Boolean: // do nothing
-	// TODO(wrong): this misses "null". Would skip the null case (would be incomplete), but we cannot return an error.
 	default:
 		return nil, newSchemaError(path, "Unknown primitive type: %q", t)
 	}
@@ -180,8 +175,6 @@ func (d *Definitions) parseArray(s *openapi_v2.Schema, path *Path) (Schema, erro
 		return nil, newSchemaError(path, `array should have type "array"`)
 	}
 	if len(s.GetItems().GetSchema()) != 1 {
-		// TODO(wrong): Items can have multiple elements. We can ignore Items then (would be incomplete), but we cannot return an error.
-		// TODO(wrong): "type: array" witohut any items at all is completely valid.
 		return nil, newSchemaError(path, "array should have exactly one sub-item")
 	}
 	sub, err := d.ParseSchema(s.GetItems().GetSchema()[0], path)
@@ -234,8 +227,6 @@ func (d *Definitions) parseArbitrary(s *openapi_v2.Schema, path *Path) (Schema,
 // this function is public, it doesn't leak through the interface.
 func (d *Definitions) ParseSchema(s *openapi_v2.Schema, path *Path) (Schema, error) {
 	if s.GetXRef() != "" {
-		// TODO(incomplete): ignoring the rest of s is wrong. As long as there are no conflict, everything from s must be considered
-		// Reference: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#path-item-object
 		return d.parseReference(s, path)
 	}
 	objectTypes := s.GetType().GetValue()
@@ -243,15 +234,11 @@ func (d *Definitions) ParseSchema(s *openapi_v2.Schema, path *Path) (Schema, err
 	case 0:
 		// in the OpenAPI schema served by older k8s versions, object definitions created from structs did not include
 		// the type:object property (they only included the "properties" property), so we need to handle this case
-		// TODO: validate that we ever published empty, non-nil properties. JSON roundtripping nils them.
 		if s.GetProperties() != nil {
-			// TODO(wrong): when verifying a non-object later against this, it will be rejected as invalid type.
-			// TODO(CRD validation schema publishing): we have to filter properties (empty or not) if type=object is not given
 			return d.parseKind(s, path)
 		} else {
 			// Definition has no type and no properties. Treat it as an arbitrary value
-			// TODO(incomplete): what if it has additionalProperties=false or patternProperties?
-			// ANSWER: parseArbitrary is less strict than it has to be with patternProperties (which is ignored). So this is correct (of course not complete).
+			// TODO: what if it has additionalProperties or patternProperties?
 			return d.parseArbitrary(s, path)
 		}
 	case 1:
@@ -269,8 +256,6 @@ func (d *Definitions) ParseSchema(s *openapi_v2.Schema, path *Path) (Schema, err
 		return d.parsePrimitive(s, path)
 	default:
 		// the OpenAPI generator never generates (nor it ever did in the past) OpenAPI type definitions with multiple types
-		// TODO(wrong): this is rejecting a completely valid OpenAPI spec
-		// TODO(CRD validation schema publishing): filter these out
 		return nil, newSchemaError(path, "definitions with multiple types aren't supported")
 	}
 }

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

@@ -21,39 +21,14 @@ import (
 	"strings"
 )
 
-// [DEPRECATED] ToCanonicalName converts Golang package/type canonical name into REST friendly OpenAPI name.
-// This method is deprecated because it has a misleading name. Please use ToRESTFriendlyName
-// instead
-//
-// NOTE: actually the "canonical name" in this method should be named "REST friendly OpenAPI name",
-// which is different from "canonical name" defined in GetCanonicalTypeName. The "canonical name" defined
-// in GetCanonicalTypeName means Go type names with full package path.
-//
-// Examples of REST friendly OpenAPI name:
+// ToCanonicalName converts Golang package/type name into canonical OpenAPI name.
+// Examples:
 //	Input:  k8s.io/api/core/v1.Pod
 //	Output: io.k8s.api.core.v1.Pod
 //
 //	Input:  k8s.io/api/core/v1
 //	Output: io.k8s.api.core.v1
-//
-//	Input:  csi.storage.k8s.io/v1alpha1.CSINodeInfo
-//	Output: io.k8s.storage.csi.v1alpha1.CSINodeInfo
 func ToCanonicalName(name string) string {
-	return ToRESTFriendlyName(name)
-}
-
-// ToRESTFriendlyName converts Golang package/type canonical name into REST friendly OpenAPI name.
-//
-// Examples of REST friendly OpenAPI name:
-//	Input:  k8s.io/api/core/v1.Pod
-//	Output: io.k8s.api.core.v1.Pod
-//
-//	Input:  k8s.io/api/core/v1
-//	Output: io.k8s.api.core.v1
-//
-//	Input:  csi.storage.k8s.io/v1alpha1.CSINodeInfo
-//	Output: io.k8s.storage.csi.v1alpha1.CSINodeInfo
-func ToRESTFriendlyName(name string) string {
 	nameParts := strings.Split(name, "/")
 	// Reverse first part. e.g., io.k8s... instead of k8s.io...
 	if len(nameParts) > 0 && strings.Contains(nameParts[0], ".") {
@@ -66,30 +41,9 @@ func ToRESTFriendlyName(name string) string {
 	return strings.Join(nameParts, ".")
 }
 
-// OpenAPICanonicalTypeNamer is an interface for models without Go type to seed model name.
-//
-// OpenAPI canonical names are Go type names with full package path, for uniquely indentifying
-// a model / Go type. If a Go type is vendored from another package, only the path after "/vendor/"
-// should be used. For custom resource definition (CRD), the canonical name is expected to be
-//     group/version.kind
-//
-// Examples of canonical name:
-//     Go type: k8s.io/kubernetes/pkg/apis/core.Pod
-//     CRD:     csi.storage.k8s.io/v1alpha1.CSINodeInfo
-//
-// Example for vendored Go type:
-//     Original full path:  k8s.io/kubernetes/vendor/k8s.io/api/core/v1.Pod
-//     Canonical name:      k8s.io/api/core/v1.Pod
-type OpenAPICanonicalTypeNamer interface {
-	OpenAPICanonicalTypeName() string
-}
-
 // GetCanonicalTypeName will find the canonical type name of a sample object, removing
 // the "vendor" part of the path
 func GetCanonicalTypeName(model interface{}) string {
-	if namer, ok := model.(OpenAPICanonicalTypeNamer); ok {
-		return namer.OpenAPICanonicalTypeName()
-	}
 	t := reflect.TypeOf(model)
 	if t.Kind() == reflect.Ptr {
 		t = t.Elem()