bump(*): kubernetes release-1.16.0 dependencies

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

@@ -20,12 +20,9 @@ import (
 	"bytes"
 	"compress/gzip"
 	"crypto/sha512"
-	"encoding/json"
 	"fmt"
-	"gopkg.in/yaml.v2"
 	"mime"
 	"net/http"
-	"strings"
 	"sync"
 	"time"
 
@@ -35,6 +32,9 @@ import (
 	"github.com/golang/protobuf/proto"
 	"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"
@@ -55,7 +55,6 @@ type OpenAPIService struct {
 	// rwMutex protects All members of this service.
 	rwMutex sync.RWMutex
 
-	orgSpec      *spec.Swagger
 	lastModified time.Time
 
 	specBytes []byte
@@ -77,58 +76,13 @@ func computeETag(data []byte) string {
 	return fmt.Sprintf("\"%X\"", sha512.Sum512(data))
 }
 
-// BuildAndRegisterOpenAPIService builds the spec and registers a handler to provides 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 {
+// 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 {
 		return nil, err
 	}
-	return RegisterOpenAPIService(spec, servePath, handler)
-}
-
-// RegisterOpenAPIService registers a handler to provides 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
+	return o, nil
 }
 
 func (o *OpenAPIService) getSwaggerBytes() ([]byte, string, time.Time) {
@@ -150,12 +104,15 @@ func (o *OpenAPIService) getSwaggerPbGzBytes() ([]byte, string, time.Time) {
 }
 
 func (o *OpenAPIService) UpdateSpec(openapiSpec *spec.Swagger) (err error) {
-	orgSpec := openapiSpec
-	specBytes, err := json.MarshalIndent(openapiSpec, " ", " ")
+	specBytes, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(openapiSpec)
 	if err != nil {
 		return err
 	}
-	specPb, err := toProtoBinary(specBytes)
+	var json map[string]interface{}
+	if err := jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(specBytes, &json); err != nil {
+		return err
+	}
+	specPb, err := ToProtoBinary(json)
 	if err != nil {
 		return err
 	}
@@ -170,7 +127,6 @@ func (o *OpenAPIService) UpdateSpec(openapiSpec *spec.Swagger) (err error) {
 	o.rwMutex.Lock()
 	defer o.rwMutex.Unlock()
 
-	o.orgSpec = orgSpec
 	o.specBytes = specBytes
 	o.specPb = specPb
 	o.specPbGz = specPbGz
@@ -182,13 +138,50 @@ func (o *OpenAPIService) UpdateSpec(openapiSpec *spec.Swagger) (err error) {
 	return nil
 }
 
-func toProtoBinary(spec []byte) ([]byte, error) {
-	var info yaml.MapSlice
-	err := yaml.Unmarshal(spec, &info)
-	if err != nil {
-		return nil, err
+func jsonToYAML(j map[string]interface{}) yaml.MapSlice {
+	if j == nil {
+		return nil
 	}
-	document, err := openapi_v2.NewDocument(info, compiler.NewContext("$root", nil))
+	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))
 	if err != nil {
 		return nil, err
 	}
@@ -202,3 +195,73 @@ func toGzip(data []byte) []byte {
 	zw.Close()
 	return buf.Bytes()
 }
+
+// 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 {
+		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
+		GetDataAndETag func() ([]byte, string, time.Time)
+	}{
+		{"application", "json", o.getSwaggerBytes},
+		{"application", "com.github.proto-openapi.spec.v2@v1.0+protobuf", o.getSwaggerPbBytes},
+	}
+
+	handler.Handle(servePath, gziphandler.GzipHandler(http.HandlerFunc(
+		func(w http.ResponseWriter, r *http.Request) {
+			decipherableFormats := r.Header.Get("Accept")
+			if decipherableFormats == "" {
+				decipherableFormats = "*/*"
+			}
+			clauses := goautoneg.ParseAccept(decipherableFormats)
+			w.Header().Add("Vary", "Accept")
+			for _, clause := range clauses {
+				for _, accepts := range accepted {
+					if clause.Type != accepts.Type && clause.Type != "*" {
+						continue
+					}
+					if clause.SubType != accepts.SubType && clause.SubType != "*" {
+						continue
+					}
+
+					// serve the first matching media type in the sorted clause list
+					data, etag, lastModified := accepts.GetDataAndETag()
+					w.Header().Set("Etag", etag)
+					// ServeContent will take care of caching using eTag.
+					http.ServeContent(w, r, servePath, lastModified, bytes.NewReader(data))
+					return
+				}
+			}
+			// Return 406 for not acceptable format
+			w.WriteHeader(406)
+			return
+		}),
+	))
+
+	return nil
+}
+
+// BuildAndRegisterOpenAPIVersionedService 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 RegisterOpenAPIVersionedService.
+func BuildAndRegisterOpenAPIVersionedService(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
+	}
+	o, err := NewOpenAPIService(spec)
+	if err != nil {
+		return nil, err
+	}
+	return o, o.RegisterOpenAPIVersionedService(servePath, handler)
+}