Vendor: Update k8s version

Signed-off-by: Michał Żyłowski <michal.zylowski@intel.com>

vendor/k8s.io/kubernetes/pkg/genericapiserver/server/openapi/BUILD

@@ -0,0 +1,53 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "openapi.go",
+        "util.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/genericapiserver/server/mux:go_default_library",
+        "//pkg/util:go_default_library",
+        "//vendor:github.com/emicklei/go-restful",
+        "//vendor:github.com/go-openapi/spec",
+        "//vendor:k8s.io/apimachinery/pkg/openapi",
+        "//vendor:k8s.io/apimachinery/pkg/util/json",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["openapi_test.go"],
+    library = ":go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//vendor:github.com/emicklei/go-restful",
+        "//vendor:github.com/go-openapi/spec",
+        "//vendor:github.com/stretchr/testify/assert",
+        "//vendor:k8s.io/apimachinery/pkg/openapi",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/genericapiserver/server/openapi/OWNERS

@@ -0,0 +1,5 @@
+reviewers:
+- yujuhong
+- gmarek
+- mbohlool
+- philips

vendor/k8s.io/kubernetes/pkg/genericapiserver/server/openapi/doc.go

@@ -0,0 +1,20 @@
+/*
+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 openapi contains code to generate OpenAPI discovery spec (which
+// initial version of it also known as Swagger 2.0).
+// For more details: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md
+package openapi

vendor/k8s.io/kubernetes/pkg/genericapiserver/server/openapi/openapi.go

@@ -0,0 +1,384 @@
+/*
+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 openapi
+
+import (
+	"fmt"
+	"net/http"
+	"reflect"
+	"strings"
+
+	"github.com/emicklei/go-restful"
+	"github.com/go-openapi/spec"
+
+	"k8s.io/apimachinery/pkg/openapi"
+	"k8s.io/apimachinery/pkg/util/json"
+	genericmux "k8s.io/kubernetes/pkg/genericapiserver/server/mux"
+	"k8s.io/kubernetes/pkg/util"
+)
+
+const (
+	OpenAPIVersion = "2.0"
+)
+
+type openAPI struct {
+	config       *openapi.Config
+	swagger      *spec.Swagger
+	protocolList []string
+	servePath    string
+}
+
+// RegisterOpenAPIService registers a handler to provides standard OpenAPI specification.
+func RegisterOpenAPIService(servePath string, webServices []*restful.WebService, config *openapi.Config, container *genericmux.APIContainer) (err error) {
+	o := openAPI{
+		config:    config,
+		servePath: servePath,
+		swagger: &spec.Swagger{
+			SwaggerProps: spec.SwaggerProps{
+				Swagger:     OpenAPIVersion,
+				Definitions: spec.Definitions{},
+				Paths:       &spec.Paths{Paths: map[string]spec.PathItem{}},
+				Info:        config.Info,
+			},
+		},
+	}
+
+	err = o.init(webServices)
+	if err != nil {
+		return err
+	}
+
+	container.UnlistedRoutes.HandleFunc(servePath, func(w http.ResponseWriter, r *http.Request) {
+		resp := restful.NewResponse(w)
+		if r.URL.Path != servePath {
+			resp.WriteErrorString(http.StatusNotFound, "Path not found!")
+		}
+		// TODO: we can cache json string and return it here.
+		resp.WriteAsJson(o.swagger)
+	})
+	return nil
+}
+
+func (o *openAPI) init(webServices []*restful.WebService) error {
+	if o.config.GetOperationIDAndTags == nil {
+		o.config.GetOperationIDAndTags = func(_ string, r *restful.Route) (string, []string, error) {
+			return r.Operation, nil, nil
+		}
+	}
+	if o.config.CommonResponses == nil {
+		o.config.CommonResponses = map[int]spec.Response{}
+	}
+	err := o.buildPaths(webServices)
+	if err != nil {
+		return err
+	}
+	if o.config.SecurityDefinitions != nil {
+		o.swagger.SecurityDefinitions = *o.config.SecurityDefinitions
+		o.swagger.Security = o.config.DefaultSecurity
+	}
+	return nil
+}
+
+func (o *openAPI) buildDefinitionRecursively(name string) error {
+	if _, ok := o.swagger.Definitions[name]; ok {
+		return nil
+	}
+	if item, ok := (*o.config.Definitions)[name]; ok {
+		o.swagger.Definitions[name] = item.Schema
+		for _, v := range item.Dependencies {
+			if err := o.buildDefinitionRecursively(v); err != nil {
+				return err
+			}
+		}
+	} else {
+		return fmt.Errorf("cannot find model definition for %v. If you added a new type, you may need to add +k8s:openapi-gen=true to the package or type and run code-gen again.", name)
+	}
+	return nil
+}
+
+// buildDefinitionForType build a definition for a given type and return a referable name to it's definition.
+// This is the main function that keep track of definitions used in this spec and is depend on code generated
+// by k8s.io/kubernetes/cmd/libs/go2idl/openapi-gen.
+func (o *openAPI) buildDefinitionForType(sample interface{}) (string, error) {
+	t := reflect.TypeOf(sample)
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	name := t.String()
+	if err := o.buildDefinitionRecursively(name); err != nil {
+		return "", err
+	}
+	return "#/definitions/" + name, nil
+}
+
+// buildPaths builds OpenAPI paths using go-restful's web services.
+func (o *openAPI) buildPaths(webServices []*restful.WebService) error {
+	pathsToIgnore := util.CreateTrie(o.config.IgnorePrefixes)
+	duplicateOpId := make(map[string]string)
+	for _, w := range webServices {
+		rootPath := w.RootPath()
+		if pathsToIgnore.HasPrefix(rootPath) {
+			continue
+		}
+		commonParams, err := o.buildParameters(w.PathParameters())
+		if err != nil {
+			return err
+		}
+		for path, routes := range groupRoutesByPath(w.Routes()) {
+			// go-swagger has special variable definition {$NAME:*} that can only be
+			// used at the end of the path and it is not recognized by OpenAPI.
+			if strings.HasSuffix(path, ":*}") {
+				path = path[:len(path)-3] + "}"
+			}
+			if pathsToIgnore.HasPrefix(path) {
+				continue
+			}
+			// Aggregating common parameters make API spec (and generated clients) simpler
+			inPathCommonParamsMap, err := o.findCommonParameters(routes)
+			if err != nil {
+				return err
+			}
+			pathItem, exists := o.swagger.Paths.Paths[path]
+			if exists {
+				return fmt.Errorf("duplicate webservice route has been found for path: %v", path)
+			}
+			pathItem = spec.PathItem{
+				PathItemProps: spec.PathItemProps{
+					Parameters: make([]spec.Parameter, 0),
+				},
+			}
+			// add web services's parameters as well as any parameters appears in all ops, as common parameters
+			pathItem.Parameters = append(pathItem.Parameters, commonParams...)
+			for _, p := range inPathCommonParamsMap {
+				pathItem.Parameters = append(pathItem.Parameters, p)
+			}
+			sortParameters(pathItem.Parameters)
+			for _, route := range routes {
+				op, err := o.buildOperations(route, inPathCommonParamsMap)
+				sortParameters(op.Parameters)
+				if err != nil {
+					return err
+				}
+				dpath, exists := duplicateOpId[op.ID]
+				if exists {
+					return fmt.Errorf("Duplicate Operation ID %v for path %v and %v.", op.ID, dpath, path)
+				} else {
+					duplicateOpId[op.ID] = path
+				}
+				switch strings.ToUpper(route.Method) {
+				case "GET":
+					pathItem.Get = op
+				case "POST":
+					pathItem.Post = op
+				case "HEAD":
+					pathItem.Head = op
+				case "PUT":
+					pathItem.Put = op
+				case "DELETE":
+					pathItem.Delete = op
+				case "OPTIONS":
+					pathItem.Options = op
+				case "PATCH":
+					pathItem.Patch = op
+				}
+			}
+			o.swagger.Paths.Paths[path] = pathItem
+		}
+	}
+	return nil
+}
+
+// buildOperations builds operations for each webservice path
+func (o *openAPI) buildOperations(route restful.Route, inPathCommonParamsMap map[interface{}]spec.Parameter) (ret *spec.Operation, err error) {
+	ret = &spec.Operation{
+		OperationProps: spec.OperationProps{
+			Description: route.Doc,
+			Consumes:    route.Consumes,
+			Produces:    route.Produces,
+			Schemes:     o.config.ProtocolList,
+			Responses: &spec.Responses{
+				ResponsesProps: spec.ResponsesProps{
+					StatusCodeResponses: make(map[int]spec.Response),
+				},
+			},
+		},
+	}
+	if ret.ID, ret.Tags, err = o.config.GetOperationIDAndTags(o.servePath, &route); err != nil {
+		return ret, err
+	}
+
+	// Build responses
+	for _, resp := range route.ResponseErrors {
+		ret.Responses.StatusCodeResponses[resp.Code], err = o.buildResponse(resp.Model, resp.Message)
+		if err != nil {
+			return ret, err
+		}
+	}
+	// If there is no response but a write sample, assume that write sample is an http.StatusOK response.
+	if len(ret.Responses.StatusCodeResponses) == 0 && route.WriteSample != nil {
+		ret.Responses.StatusCodeResponses[http.StatusOK], err = o.buildResponse(route.WriteSample, "OK")
+		if err != nil {
+			return ret, err
+		}
+	}
+	for code, resp := range o.config.CommonResponses {
+		if _, exists := ret.Responses.StatusCodeResponses[code]; !exists {
+			ret.Responses.StatusCodeResponses[code] = resp
+		}
+	}
+	// If there is still no response, use default response provided.
+	if len(ret.Responses.StatusCodeResponses) == 0 {
+		ret.Responses.Default = o.config.DefaultResponse
+	}
+	// If there is a read sample, there will be a body param referring to it.
+	if route.ReadSample != nil {
+		if _, err := o.toSchema(reflect.TypeOf(route.ReadSample).String(), route.ReadSample); err != nil {
+			return ret, err
+		}
+	}
+
+	// Build non-common Parameters
+	ret.Parameters = make([]spec.Parameter, 0)
+	for _, param := range route.ParameterDocs {
+		if _, isCommon := inPathCommonParamsMap[mapKeyFromParam(param)]; !isCommon {
+			openAPIParam, err := o.buildParameter(param.Data())
+			if err != nil {
+				return ret, err
+			}
+			ret.Parameters = append(ret.Parameters, openAPIParam)
+		}
+	}
+	return ret, nil
+}
+
+func (o *openAPI) buildResponse(model interface{}, description string) (spec.Response, error) {
+	typeName := reflect.TypeOf(model).String()
+	schema, err := o.toSchema(typeName, model)
+	if err != nil {
+		return spec.Response{}, err
+	}
+	return spec.Response{
+		ResponseProps: spec.ResponseProps{
+			Description: description,
+			Schema:      schema,
+		},
+	}, nil
+}
+
+func (o *openAPI) findCommonParameters(routes []restful.Route) (map[interface{}]spec.Parameter, error) {
+	commonParamsMap := make(map[interface{}]spec.Parameter, 0)
+	paramOpsCountByName := make(map[interface{}]int, 0)
+	paramNameKindToDataMap := make(map[interface{}]restful.ParameterData, 0)
+	for _, route := range routes {
+		routeParamDuplicateMap := make(map[interface{}]bool)
+		s := ""
+		for _, param := range route.ParameterDocs {
+			m, _ := json.Marshal(param.Data())
+			s += string(m) + "\n"
+			key := mapKeyFromParam(param)
+			if routeParamDuplicateMap[key] {
+				msg, _ := json.Marshal(route.ParameterDocs)
+				return commonParamsMap, fmt.Errorf("duplicate parameter %v for route %v, %v.", param.Data().Name, string(msg), s)
+			}
+			routeParamDuplicateMap[key] = true
+			paramOpsCountByName[key]++
+			paramNameKindToDataMap[key] = param.Data()
+		}
+	}
+	for key, count := range paramOpsCountByName {
+		if count == len(routes) {
+			openAPIParam, err := o.buildParameter(paramNameKindToDataMap[key])
+			if err != nil {
+				return commonParamsMap, err
+			}
+			commonParamsMap[key] = openAPIParam
+		}
+	}
+	return commonParamsMap, nil
+}
+
+func (o *openAPI) toSchema(typeName string, model interface{}) (_ *spec.Schema, err error) {
+	if openAPIType, openAPIFormat := openapi.GetOpenAPITypeFormat(typeName); openAPIType != "" {
+		return &spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Type:   []string{openAPIType},
+				Format: openAPIFormat,
+			},
+		}, nil
+	} else {
+		ref := "#/definitions/" + typeName
+		if model != nil {
+			ref, err = o.buildDefinitionForType(model)
+			if err != nil {
+				return nil, err
+			}
+		}
+		return &spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Ref: spec.MustCreateRef(ref),
+			},
+		}, nil
+	}
+}
+
+func (o *openAPI) buildParameter(restParam restful.ParameterData) (ret spec.Parameter, err error) {
+	ret = spec.Parameter{
+		ParamProps: spec.ParamProps{
+			Name:        restParam.Name,
+			Description: restParam.Description,
+			Required:    restParam.Required,
+		},
+	}
+	switch restParam.Kind {
+	case restful.BodyParameterKind:
+		ret.In = "body"
+		ret.Schema, err = o.toSchema(restParam.DataType, nil)
+		return ret, err
+	case restful.PathParameterKind:
+		ret.In = "path"
+		if !restParam.Required {
+			return ret, fmt.Errorf("path parameters should be marked at required for parameter %v", restParam)
+		}
+	case restful.QueryParameterKind:
+		ret.In = "query"
+	case restful.HeaderParameterKind:
+		ret.In = "header"
+	case restful.FormParameterKind:
+		ret.In = "form"
+	default:
+		return ret, fmt.Errorf("unknown restful operation kind : %v", restParam.Kind)
+	}
+	openAPIType, openAPIFormat := openapi.GetOpenAPITypeFormat(restParam.DataType)
+	if openAPIType == "" {
+		return ret, fmt.Errorf("non-body Restful parameter type should be a simple type, but got : %v", restParam.DataType)
+	}
+	ret.Type = openAPIType
+	ret.Format = openAPIFormat
+	ret.UniqueItems = !restParam.AllowMultiple
+	return ret, nil
+}
+
+func (o *openAPI) buildParameters(restParam []*restful.Parameter) (ret []spec.Parameter, err error) {
+	ret = make([]spec.Parameter, len(restParam))
+	for i, v := range restParam {
+		ret[i], err = o.buildParameter(v.Data())
+		if err != nil {
+			return ret, err
+		}
+	}
+	return ret, nil
+}

vendor/k8s.io/kubernetes/pkg/genericapiserver/server/openapi/openapi_test.go

@@ -0,0 +1,408 @@
+/*
+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 openapi
+
+import (
+	"fmt"
+	"net/http"
+	"testing"
+
+	"github.com/emicklei/go-restful"
+	"github.com/go-openapi/spec"
+	"github.com/stretchr/testify/assert"
+	"k8s.io/apimachinery/pkg/openapi"
+)
+
+// setUp is a convenience function for setting up for (most) tests.
+func setUp(t *testing.T, fullMethods bool) (openAPI, *restful.Container, *assert.Assertions) {
+	assert := assert.New(t)
+	config, container := getConfig(fullMethods)
+	return openAPI{
+		config: config,
+		swagger: &spec.Swagger{
+			SwaggerProps: spec.SwaggerProps{
+				Swagger:     OpenAPIVersion,
+				Definitions: spec.Definitions{},
+				Paths:       &spec.Paths{Paths: map[string]spec.PathItem{}},
+				Info:        config.Info,
+			},
+		},
+	}, container, assert
+}
+
+func noOp(request *restful.Request, response *restful.Response) {}
+
+// Test input
+type TestInput struct {
+	// Name of the input
+	Name string `json:"name,omitempty"`
+	// ID of the input
+	ID   int      `json:"id,omitempty"`
+	Tags []string `json:"tags,omitempty"`
+}
+
+// Test output
+type TestOutput struct {
+	// Name of the output
+	Name string `json:"name,omitempty"`
+	// Number of outputs
+	Count int `json:"count,omitempty"`
+}
+
+func (_ TestInput) OpenAPIDefinition() *openapi.OpenAPIDefinition {
+	schema := spec.Schema{}
+	schema.Description = "Test input"
+	schema.Properties = map[string]spec.Schema{
+		"name": {
+			SchemaProps: spec.SchemaProps{
+				Description: "Name of the input",
+				Type:        []string{"string"},
+				Format:      "",
+			},
+		},
+		"id": {
+			SchemaProps: spec.SchemaProps{
+				Description: "ID of the input",
+				Type:        []string{"integer"},
+				Format:      "int32",
+			},
+		},
+		"tags": {
+			SchemaProps: spec.SchemaProps{
+				Description: "",
+				Type:        []string{"array"},
+				Items: &spec.SchemaOrArray{
+					Schema: &spec.Schema{
+						SchemaProps: spec.SchemaProps{
+							Type:   []string{"string"},
+							Format: "",
+						},
+					},
+				},
+			},
+		},
+	}
+	return &openapi.OpenAPIDefinition{
+		Schema:       schema,
+		Dependencies: []string{},
+	}
+}
+
+func (_ TestOutput) OpenAPIDefinition() *openapi.OpenAPIDefinition {
+	schema := spec.Schema{}
+	schema.Description = "Test output"
+	schema.Properties = map[string]spec.Schema{
+		"name": {
+			SchemaProps: spec.SchemaProps{
+				Description: "Name of the output",
+				Type:        []string{"string"},
+				Format:      "",
+			},
+		},
+		"count": {
+			SchemaProps: spec.SchemaProps{
+				Description: "Number of outputs",
+				Type:        []string{"integer"},
+				Format:      "int32",
+			},
+		},
+	}
+	return &openapi.OpenAPIDefinition{
+		Schema:       schema,
+		Dependencies: []string{},
+	}
+}
+
+var _ openapi.OpenAPIDefinitionGetter = TestInput{}
+var _ openapi.OpenAPIDefinitionGetter = TestOutput{}
+
+func getTestRoute(ws *restful.WebService, method string, additionalParams bool, opPrefix string) *restful.RouteBuilder {
+	ret := ws.Method(method).
+		Path("/test/{path:*}").
+		Doc(fmt.Sprintf("%s test input", method)).
+		Operation(fmt.Sprintf("%s%sTestInput", method, opPrefix)).
+		Produces(restful.MIME_JSON).
+		Consumes(restful.MIME_JSON).
+		Param(ws.PathParameter("path", "path to the resource").DataType("string")).
+		Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
+		Reads(TestInput{}).
+		Returns(200, "OK", TestOutput{}).
+		Writes(TestOutput{}).
+		To(noOp)
+	if additionalParams {
+		ret.Param(ws.HeaderParameter("hparam", "a test head parameter").DataType("integer"))
+		ret.Param(ws.FormParameter("fparam", "a test form parameter").DataType("number"))
+	}
+	return ret
+}
+
+func getConfig(fullMethods bool) (*openapi.Config, *restful.Container) {
+	mux := http.NewServeMux()
+	container := restful.NewContainer()
+	container.ServeMux = mux
+	ws := new(restful.WebService)
+	ws.Path("/foo")
+	ws.Route(getTestRoute(ws, "get", true, "foo"))
+	if fullMethods {
+		ws.Route(getTestRoute(ws, "post", false, "foo")).
+			Route(getTestRoute(ws, "put", false, "foo")).
+			Route(getTestRoute(ws, "head", false, "foo")).
+			Route(getTestRoute(ws, "patch", false, "foo")).
+			Route(getTestRoute(ws, "options", false, "foo")).
+			Route(getTestRoute(ws, "delete", false, "foo"))
+
+	}
+	ws.Path("/bar")
+	ws.Route(getTestRoute(ws, "get", true, "bar"))
+	if fullMethods {
+		ws.Route(getTestRoute(ws, "post", false, "bar")).
+			Route(getTestRoute(ws, "put", false, "bar")).
+			Route(getTestRoute(ws, "head", false, "bar")).
+			Route(getTestRoute(ws, "patch", false, "bar")).
+			Route(getTestRoute(ws, "options", false, "bar")).
+			Route(getTestRoute(ws, "delete", false, "bar"))
+
+	}
+	container.Add(ws)
+	return &openapi.Config{
+		ProtocolList: []string{"https"},
+		Info: &spec.Info{
+			InfoProps: spec.InfoProps{
+				Title:       "TestAPI",
+				Description: "Test API",
+			},
+		},
+		Definitions: &openapi.OpenAPIDefinitions{
+			"openapi.TestInput":  *TestInput{}.OpenAPIDefinition(),
+			"openapi.TestOutput": *TestOutput{}.OpenAPIDefinition(),
+		},
+	}, container
+}
+
+func getTestOperation(method string, opPrefix string) *spec.Operation {
+	return &spec.Operation{
+		OperationProps: spec.OperationProps{
+			Description: fmt.Sprintf("%s test input", method),
+			Consumes:    []string{"application/json"},
+			Produces:    []string{"application/json"},
+			Schemes:     []string{"https"},
+			Parameters:  []spec.Parameter{},
+			Responses:   getTestResponses(),
+			ID:          fmt.Sprintf("%s%sTestInput", method, opPrefix),
+		},
+	}
+}
+
+func getTestPathItem(allMethods bool, opPrefix string) spec.PathItem {
+	ret := spec.PathItem{
+		PathItemProps: spec.PathItemProps{
+			Get:        getTestOperation("get", opPrefix),
+			Parameters: getTestCommonParameters(),
+		},
+	}
+	ret.Get.Parameters = getAdditionalTestParameters()
+	if allMethods {
+		ret.PathItemProps.Put = getTestOperation("put", opPrefix)
+		ret.PathItemProps.Post = getTestOperation("post", opPrefix)
+		ret.PathItemProps.Head = getTestOperation("head", opPrefix)
+		ret.PathItemProps.Patch = getTestOperation("patch", opPrefix)
+		ret.PathItemProps.Delete = getTestOperation("delete", opPrefix)
+		ret.PathItemProps.Options = getTestOperation("options", opPrefix)
+	}
+	return ret
+}
+
+func getRefSchema(ref string) *spec.Schema {
+	return &spec.Schema{
+		SchemaProps: spec.SchemaProps{
+			Ref: spec.MustCreateRef(ref),
+		},
+	}
+}
+
+func getTestResponses() *spec.Responses {
+	ret := spec.Responses{
+		ResponsesProps: spec.ResponsesProps{
+			StatusCodeResponses: map[int]spec.Response{},
+		},
+	}
+	ret.StatusCodeResponses[200] = spec.Response{
+		ResponseProps: spec.ResponseProps{
+			Description: "OK",
+			Schema:      getRefSchema("#/definitions/openapi.TestOutput"),
+		},
+	}
+	return &ret
+}
+
+func getTestCommonParameters() []spec.Parameter {
+	ret := make([]spec.Parameter, 3)
+	ret[0] = spec.Parameter{
+		ParamProps: spec.ParamProps{
+			Name:     "body",
+			In:       "body",
+			Required: true,
+			Schema:   getRefSchema("#/definitions/openapi.TestInput"),
+		},
+	}
+	ret[1] = spec.Parameter{
+		SimpleSchema: spec.SimpleSchema{
+			Type: "string",
+		},
+		ParamProps: spec.ParamProps{
+			Description: "path to the resource",
+			Name:        "path",
+			In:          "path",
+			Required:    true,
+		},
+		CommonValidations: spec.CommonValidations{
+			UniqueItems: true,
+		},
+	}
+	ret[2] = spec.Parameter{
+		SimpleSchema: spec.SimpleSchema{
+			Type: "string",
+		},
+		ParamProps: spec.ParamProps{
+			Description: "If 'true', then the output is pretty printed.",
+			Name:        "pretty",
+			In:          "query",
+		},
+		CommonValidations: spec.CommonValidations{
+			UniqueItems: true,
+		},
+	}
+	return ret
+}
+
+func getAdditionalTestParameters() []spec.Parameter {
+	ret := make([]spec.Parameter, 2)
+	ret[0] = spec.Parameter{
+		ParamProps: spec.ParamProps{
+			Name:        "fparam",
+			Description: "a test form parameter",
+			In:          "form",
+		},
+		SimpleSchema: spec.SimpleSchema{
+			Type: "number",
+		},
+		CommonValidations: spec.CommonValidations{
+			UniqueItems: true,
+		},
+	}
+	ret[1] = spec.Parameter{
+		SimpleSchema: spec.SimpleSchema{
+			Type: "integer",
+		},
+		ParamProps: spec.ParamProps{
+			Description: "a test head parameter",
+			Name:        "hparam",
+			In:          "header",
+		},
+		CommonValidations: spec.CommonValidations{
+			UniqueItems: true,
+		},
+	}
+	return ret
+}
+
+func getTestInputDefinition() spec.Schema {
+	return spec.Schema{
+		SchemaProps: spec.SchemaProps{
+			Description: "Test input",
+			Properties: map[string]spec.Schema{
+				"id": {
+					SchemaProps: spec.SchemaProps{
+						Description: "ID of the input",
+						Type:        spec.StringOrArray{"integer"},
+						Format:      "int32",
+					},
+				},
+				"name": {
+					SchemaProps: spec.SchemaProps{
+						Description: "Name of the input",
+						Type:        spec.StringOrArray{"string"},
+					},
+				},
+				"tags": {
+					SchemaProps: spec.SchemaProps{
+						Type: spec.StringOrArray{"array"},
+						Items: &spec.SchemaOrArray{
+							Schema: &spec.Schema{
+								SchemaProps: spec.SchemaProps{
+									Type: spec.StringOrArray{"string"},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func getTestOutputDefinition() spec.Schema {
+	return spec.Schema{
+		SchemaProps: spec.SchemaProps{
+			Description: "Test output",
+			Properties: map[string]spec.Schema{
+				"count": {
+					SchemaProps: spec.SchemaProps{
+						Description: "Number of outputs",
+						Type:        spec.StringOrArray{"integer"},
+						Format:      "int32",
+					},
+				},
+				"name": {
+					SchemaProps: spec.SchemaProps{
+						Description: "Name of the output",
+						Type:        spec.StringOrArray{"string"},
+					},
+				},
+			},
+		},
+	}
+}
+
+func TestBuildSwaggerSpec(t *testing.T) {
+	o, container, assert := setUp(t, true)
+	expected := &spec.Swagger{
+		SwaggerProps: spec.SwaggerProps{
+			Info: &spec.Info{
+				InfoProps: spec.InfoProps{
+					Title:       "TestAPI",
+					Description: "Test API",
+				},
+			},
+			Swagger: "2.0",
+			Paths: &spec.Paths{
+				Paths: map[string]spec.PathItem{
+					"/foo/test/{path}": getTestPathItem(true, "foo"),
+					"/bar/test/{path}": getTestPathItem(true, "bar"),
+				},
+			},
+			Definitions: spec.Definitions{
+				"openapi.TestInput":  getTestInputDefinition(),
+				"openapi.TestOutput": getTestOutputDefinition(),
+			},
+		},
+	}
+	err := o.init(container.RegisteredWebServices())
+	if assert.NoError(err) {
+		assert.Equal(expected, o.swagger)
+	}
+}

vendor/k8s.io/kubernetes/pkg/genericapiserver/server/openapi/util.go

@@ -0,0 +1,61 @@
+/*
+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 openapi
+
+import (
+	"sort"
+
+	"github.com/emicklei/go-restful"
+	"github.com/go-openapi/spec"
+)
+
+type parameters []spec.Parameter
+
+func (s parameters) Len() int      { return len(s) }
+func (s parameters) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// byNameIn used in sorting parameters by Name and In fields.
+type byNameIn struct {
+	parameters
+}
+
+func (s byNameIn) Less(i, j int) bool {
+	return s.parameters[i].Name < s.parameters[j].Name || (s.parameters[i].Name == s.parameters[j].Name && s.parameters[i].In < s.parameters[j].In)
+}
+
+// SortParameters sorts parameters by Name and In fields.
+func sortParameters(p []spec.Parameter) {
+	sort.Sort(byNameIn{p})
+}
+
+func groupRoutesByPath(routes []restful.Route) map[string][]restful.Route {
+	pathToRoutes := make(map[string][]restful.Route)
+	for _, r := range routes {
+		pathToRoutes[r.Path] = append(pathToRoutes[r.Path], r)
+	}
+	return pathToRoutes
+}
+
+func mapKeyFromParam(param *restful.Parameter) interface{} {
+	return struct {
+		Name string
+		Kind int
+	}{
+		Name: param.Data().Name,
+		Kind: param.Data().Kind,
+	}
+}