Merge pull request #31468 from mbohlool/master

Makefile

@@ -206,13 +206,14 @@ clean: clean_meta
 clean_meta:
 	rm -rf $(META_DIR)
 
-# Remove all auto-generated artifacts.
+# Remove all auto-generated artifacts. Generated artifacts in staging folder should not be removed as they are not
+# generated using generated_files.
 #
 # Example:
 #   make clean_generated
 .PHONY: clean_generated
 clean_generated:
-	find . -type f -name $(GENERATED_FILE_PREFIX)\* | xargs rm -f
+	find . -type f -name $(GENERATED_FILE_PREFIX)\* | grep -v "[.]/staging/.*" | xargs rm -f
 
 # Run 'go vet'.
 #

Makefile.generated_files

@@ -35,7 +35,7 @@ SHELL := /bin/bash
 # This rule collects all the generated file sets into a single rule.  Other
 # rules should depend on this to ensure generated files are rebuilt.
 .PHONY: generated_files
-generated_files: gen_deepcopy gen_conversion
+generated_files: gen_deepcopy gen_conversion gen_openapi
 
 # Code-generation logic.
 #
@@ -286,6 +286,107 @@ $(DEEPCOPY_GEN):
 	touch $@
 
 #
+# Open-api generation
+#
+# Any package that wants open-api functions generated must include a
+# comment-tag in column 0 of one file of the form:
+#     // +k8s:openapi-gen=true
+#
+# The result file, in each pkg, of open-api generation.
+OPENAPI_BASENAME := $(GENERATED_FILE_PREFIX)openapi
+OPENAPI_FILENAME := $(OPENAPI_BASENAME).go
+
+# The tool used to generate open apis.
+OPENAPI_GEN := $(BIN_DIR)/openapi-gen
+
+# Find all the directories that request open-api generation.
+ifeq ($(DBG_MAKEFILE),1)
+    $(warning ***** finding all +k8s:openapi-gen tags)
+endif
+OPENAPI_DIRS := $(shell                                             \
+    grep --color=never -l '+k8s:openapi-gen=' $(ALL_K8S_TAG_FILES)  \
+        | xargs -n1 dirname                                         \
+        | sort -u                                                   \
+)
+
+OPENAPI_FILES := $(addsuffix /$(OPENAPI_FILENAME), $(OPENAPI_DIRS))
+
+# This rule aggregates the set of files to generate and then generates them all
+# in a single run of the tool.
+.PHONY: gen_openapi
+gen_openapi: $(OPENAPI_FILES)
+	if [[ -f $(META_DIR)/$(OPENAPI_GEN).todo ]]; then                   \
+	    ./hack/run-in-gopath.sh $(OPENAPI_GEN)                          \
+	        --v $(KUBE_VERBOSE)                                         \
+	        -i $$(cat $(META_DIR)/$(OPENAPI_GEN).todo | paste -sd, -)   \
+	        -O $(OPENAPI_BASENAME);                                     \
+	fi
+
+# For each dir in OPENAPI_DIRS, this establishes a dependency between the
+# output file and the input files that should trigger a rebuild.
+#
+# Note that this is a deps-only statement, not a full rule (see below).  This
+# has to be done in a distinct step because wildcards don't work in static
+# pattern rules.
+#
+# The '$(eval)' is needed because this has a different RHS for each LHS, and
+# would otherwise produce results that make can't parse.
+#
+# We depend on the $(GOFILES_META).stamp to detect when the set of input files
+# has changed.  This allows us to detect deleted input files.
+$(foreach dir, $(OPENAPI_DIRS), $(eval                                     \
+    $(dir)/$(OPENAPI_FILENAME): $(META_DIR)/$(dir)/$(GOFILES_META).stamp   \
+                                 $(gofiles__$(dir))                        \
+))
+
+# Unilaterally remove any leftovers from previous runs.
+$(shell rm -f $(META_DIR)/$(OPENAPI_GEN)*.todo)
+
+# How to regenerate open-api code.  We need to collect these up and trigger one
+# single run to generate definition for all types.
+$(OPENAPI_FILES): $(OPENAPI_GEN)
+	mkdir -p $$(dirname $(META_DIR)/$(OPENAPI_GEN))
+	echo $(PRJ_SRC_PATH)/$(@D) >> $(META_DIR)/$(OPENAPI_GEN).todo
+
+# This calculates the dependencies for the generator tool, so we only rebuild
+# it when needed.  It is PHONY so that it always runs, but it only updates the
+# file if the contents have actually changed.  We 'sinclude' this later.
+.PHONY: $(META_DIR)/$(OPENAPI_GEN).mk
+$(META_DIR)/$(OPENAPI_GEN).mk:
+	mkdir -p $(@D);                                        \
+	(echo -n "$(OPENAPI_GEN): ";                           \
+	 DIRECT=$$(go list -f '{{.Dir}} {{.Dir}}/*.go'         \
+	     ./cmd/libs/go2idl/openapi-gen);                   \
+	 INDIRECT=$$(go list                                   \
+	     -f '{{range .Deps}}{{.}}{{"\n"}}{{end}}'          \
+	     ./cmd/libs/go2idl/openapi-gen                     \
+	     | grep --color=never "^$(PRJ_SRC_PATH)"           \
+	     | sed 's|^$(PRJ_SRC_PATH)|./|'                    \
+	     | xargs go list -f '{{.Dir}} {{.Dir}}/*.go');     \
+	 echo $$DIRECT $$INDIRECT                              \
+	     | sed 's/ / \\=,/g'                               \
+	     | tr '=,' '\n\t';                                 \
+	) | sed "s|$$(pwd -P)/||" > $@.tmp;                    \
+	cmp -s $@.tmp $@ || cat $@.tmp > $@ && rm -f $@.tmp
+
+# Include dependency info for the generator tool.  This will cause the rule of
+# the same name to be considered and if it is updated, make will restart.
+sinclude $(META_DIR)/$(OPENAPI_GEN).mk
+
+# How to build the generator tool.  The deps for this are defined in
+# the $(OPENAPI_GEN).mk, above.
+#
+# A word on the need to touch: This rule might trigger if, for example, a
+# non-Go file was added or deleted from a directory on which this depends.
+# This target needs to be reconsidered, but Go realizes it doesn't actually
+# have to be rebuilt.  In that case, make will forever see the dependency as
+# newer than the binary, and try to rebuild it over and over.  So we touch it,
+# and make is happy.
+$(OPENAPI_GEN):
+	hack/make-rules/build.sh cmd/libs/go2idl/openapi-gen
+	touch $@
+
+#
 # Conversion generation
 #
 # Any package that wants conversion functions generated must include one or

api/swagger-spec/logs.json

@@ -16,7 +16,16 @@
       "type": "void",
       "method": "GET",
       "nickname": "logFileHandler",
-      "parameters": []
+      "parameters": [
+       {
+        "type": "string",
+        "paramType": "path",
+        "name": "logpath",
+        "description": "path to the log",
+        "required": true,
+        "allowMultiple": false
+       }
+      ]
      }
     ]
    },

cmd/libs/go2idl/client-gen/test_apis/testgroup.k8s.io/v1/doc.go

+/*
+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.
+*/
+
+// +k8s:openapi-gen=true
+package v1

cmd/libs/go2idl/client-gen/test_apis/testgroup.k8s.io/v1/types.go

@@ -25,6 +25,10 @@ import (
 
 type TestType struct {
 	unversioned.TypeMeta `json:",inline"`
+	// ---
+	// the next tag removes the field from openapi spec. Adding unversioned objectMeta bring in a whole set of
+	// unversioned objects in the generate file that is not used anywhere other than this test type.
+	// +k8s:openapi-gen=false
 	api.ObjectMeta `json:"metadata,omitempty"`
 	Status         TestTypeStatus `json:"status,omitempty"`
 }

cmd/libs/go2idl/generator/default_generator.go

@@ -50,6 +50,7 @@ func (d DefaultGen) PackageConsts(*Context) []string                     { retur
 func (d DefaultGen) GenerateType(*Context, *types.Type, io.Writer) error { return nil }
 func (d DefaultGen) Filename() string                                    { return d.OptionalName + ".go" }
 func (d DefaultGen) FileType() string                                    { return GolangFileType }
+func (d DefaultGen) Finalize(*Context, io.Writer) error                  { return nil }
 
 func (d DefaultGen) Init(c *Context, w io.Writer) error {
 	_, err := w.Write(d.OptionalBody)

cmd/libs/go2idl/generator/execute.go

@@ -302,5 +302,8 @@ func (c *Context) executeBody(w io.Writer, generator Generator) error {
 			return err
 		}
 	}
+	if err := generator.Finalize(c, et); err != nil {
+		return err
+	}
 	return et.Error()
 }

cmd/libs/go2idl/generator/generator.go

@@ -110,6 +110,11 @@ type Generator interface {
 	// Generators.)
 	Init(*Context, io.Writer) error
 
+	// Finalize should write finish up codes, and any other content that's not
+	// generated per-type. For example if you are generating one block (function,
+	// type, etc) for all types, this function can be used to close the block.
+	Finalize(*Context, io.Writer) error
+
 	// PackageVars should emit an array of variable lines. They will be
 	// placed in a var ( ... ) block. There's no need to include a leading
 	// \t or trailing \n.

cmd/libs/go2idl/import-boss/generators/import_restrict.go

@@ -252,6 +252,7 @@ func (r *importRules) GenerateType(*generator.Context, *types.Type, io.Writer) e
 func (r *importRules) Filename() string                                              { return ".import-restrictions" }
 func (r *importRules) FileType() string                                              { return importBossFileType }
 func (r *importRules) Init(c *generator.Context, w io.Writer) error                  { return nil }
+func (r *importRules) Finalize(c *generator.Context, w io.Writer) error              { return nil }
 
 func dfsImports(dest *[]string, seen map[string]bool, p *types.Package) {
 	for _, p2 := range p.Imports {

cmd/libs/go2idl/namer/namer.go

@@ -301,10 +301,10 @@ func (r *rawNamer) Name(t *types.Type) string {
 	if t.Name.Package != "" {
 		var name string
 		if r.tracker != nil {
-			r.tracker.AddType(t)
 			if t.Name.Package == r.pkg {
 				name = t.Name.Name
 			} else {
+				r.tracker.AddType(t)
 				name = r.tracker.LocalNameOf(t.Name.Package) + "." + t.Name.Name
 			}
 		} else {

cmd/libs/go2idl/openapi-gen/README

+# Generate OpenAPI definitions
+
+- To generate definition for a specific type or package add "+k8s:openapi-gen=true" tag to the type/package comment lines.
+- To exclude a type or a member from a tagged package/type, add "+k8s:openapi-gen=false" tag to the comment lines.

cmd/libs/go2idl/openapi-gen/generators/common/common.go

+/*
+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 common
+
+import "github.com/go-openapi/spec"
+
+// OpenAPIDefinition describes single type. Normally these definitions are auto-generated using gen-openapi.
+type OpenAPIDefinition struct {
+	Schema       spec.Schema
+	Dependencies []string
+}
+
+// OpenAPIDefinitions is collection of all definitions.
+type OpenAPIDefinitions map[string]OpenAPIDefinition
+
+// OpenAPIDefinitionGetter gets openAPI definitions for a given type. If a type implements this interface,
+// the definition returned by it will be used, otherwise the auto-generated definitions will be used. See
+// GetOpenAPITypeFormat for more information about trade-offs of using this interface or GetOpenAPITypeFormat method when
+// possible.
+type OpenAPIDefinitionGetter interface {
+	OpenAPIDefinition() *OpenAPIDefinition
+}
+
+// This function is a reference for converting go (or any custom type) to a simple open API type,format pair. There are
+// two ways to customize spec for a type. If you add it here, a type will be converted to a simple type and the type
+// comment (the comment that is added before type definition) will be lost. The spec will still have the property
+// comment. The second way is to implement OpenAPIDefinitionGetter interface. That function can customize the spec (so
+// the spec does not need to be simple type,format) or can even return a simple type,format (e.g. IntOrString). For simple
+// type formats, the benefit of adding OpenAPIDefinitionGetter interface is to keep both type and property documentation.
+// Example:
+// type Sample struct {
+//      ...
+//      // port of the server
+//      port IntOrString
+//      ...
+// }
+// // IntOrString documentation...
+// type IntOrString { ... }
+//
+// Adding IntOrString to this function:
+// "port" : {
+//           format:      "string",
+//           type:        "int-or-string",
+//           Description: "port of the server"
+// }
+//
+// Implement OpenAPIDefinitionGetter for IntOrString:
+//
+// "port" : {
+//           $Ref:    "#/definitions/IntOrString"
+//           Description: "port of the server"
+// }
+// ...
+// definitions:
+// {
+//           "IntOrString": {
+//                     format:      "string",
+//                     type:        "int-or-string",
+//                     Description: "IntOrString documentation..."    // new
+//           }
+// }
+//
+func GetOpenAPITypeFormat(typeName string) (string, string) {
+	schemaTypeFormatMap := map[string][]string{
+		"uint":      {"integer", "int32"},
+		"uint8":     {"integer", "byte"},
+		"uint16":    {"integer", "int32"},
+		"uint32":    {"integer", "int64"},
+		"uint64":    {"integer", "int64"},
+		"int":       {"integer", "int32"},
+		"int8":      {"integer", "byte"},
+		"int16":     {"integer", "int32"},
+		"int32":     {"integer", "int32"},
+		"int64":     {"integer", "int64"},
+		"byte":      {"integer", "byte"},
+		"float64":   {"number", "double"},
+		"float32":   {"number", "float"},
+		"bool":      {"boolean", ""},
+		"time.Time": {"string", "date-time"},
+		"string":    {"string", ""},
+		"integer":   {"integer", ""},
+		"number":    {"number", ""},
+		"boolean":   {"boolean", ""},
+		"[]byte":    {"string", "byte"}, // base64 encoded characters
+	}
+	mapped, ok := schemaTypeFormatMap[typeName]
+	if !ok {
+		return "", ""
+	}
+	return mapped[0], mapped[1]
+}

cmd/libs/go2idl/openapi-gen/generators/common/doc.go

+/*
+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 common holds shared codes and types between open API code generator and spec generator.
+package common

cmd/libs/go2idl/openapi-gen/generators/openapi_test.go

+/*
+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 (
+	"bytes"
+	"fmt"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"k8s.io/kubernetes/cmd/libs/go2idl/generator"
+	"k8s.io/kubernetes/cmd/libs/go2idl/namer"
+	"k8s.io/kubernetes/cmd/libs/go2idl/parser"
+	"k8s.io/kubernetes/cmd/libs/go2idl/types"
+)
+
+func construct(t *testing.T, files map[string]string, testNamer namer.Namer) (*parser.Builder, types.Universe, []*types.Type) {
+	b := parser.New()
+	for name, src := range files {
+		if err := b.AddFile(filepath.Dir(name), name, []byte(src)); err != nil {
+			t.Fatal(err)
+		}
+	}
+	u, err := b.FindTypes()
+	if err != nil {
+		t.Fatal(err)
+	}
+	orderer := namer.Orderer{Namer: testNamer}
+	o := orderer.OrderUniverse(u)
+	return b, u, o
+}
+
+func testOpenAPITypeWritter(t *testing.T, code string) (error, *assert.Assertions, *bytes.Buffer) {
+	assert := assert.New(t)
+	var testFiles = map[string]string{
+		"base/foo/bar.go": code,
+	}
+	rawNamer := namer.NewRawNamer("o", nil)
+	namers := namer.NameSystems{
+		"raw": namer.NewRawNamer("", nil),
+	}
+	builder, universe, _ := construct(t, testFiles, rawNamer)
+	context, err := generator.NewContext(builder, namers, "raw")
+	if err != nil {
+		t.Fatal(err)
+	}
+	buffer := &bytes.Buffer{}
+	sw := generator.NewSnippetWriter(buffer, context, "$", "$")
+	blahT := universe.Type(types.Name{Package: "base/foo", Name: "Blah"})
+	return newOpenAPITypeWriter(sw).generate(blahT), assert, buffer
+}
+
+func TestSimple(t *testing.T) {
+	err, assert, buffer := testOpenAPITypeWritter(t, `
+package foo
+
+import (
+	"time"
+	"k8s.io/kubernetes/pkg/util/intstr"
+)
+
+// Blah is a test.
+// +k8s:openapi=true
+type Blah struct {
+	// A simple string
+	String string
+	// A simple int
+	Int int `+"`"+`json:",omitempty"`+"`"+`
+	// An int considered string simple int
+	IntString int `+"`"+`json:",string"`+"`"+`
+	// A simple int64
+	Int64 int64
+	// A simple int32
+	Int32 int32
+	// A simple int16
+	Int16 int16
+	// A simple int8
+	Int8 int8
+	// A simple int
+	Uint uint
+	// A simple int64
+	Uint64 uint64
+	// A simple int32
+	Uint32 uint32
+	// A simple int16
+	Uint16 uint16
+	// A simple int8
+	Uint8 uint8
+	// A simple byte
+	Byte byte
+	// A simple boolean
+	Bool bool
+	// A simple float64
+	Float64 float64
+	// A simple float32
+	Float32 float32
+	// A simple time
+	Time time.Time
+	// a base64 encoded characters
+	ByteArray []byte
+	// an int or string type
+	IntOrString intstr.IntOrString
+}
+		`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.Equal(`"foo.Blah": {
+Schema: spec.Schema{
+SchemaProps: spec.SchemaProps{
+Description: "Blah is a test.",
+Properties: map[string]spec.Schema{
+"String": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple string",
+Type: []string{"string"},
+Format: "",
+},
+},
+"Int64": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple int64",
+Type: []string{"integer"},
+Format: "int64",
+},
+},
+"Int32": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple int32",
+Type: []string{"integer"},
+Format: "int32",
+},
+},
+"Int16": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple int16",
+Type: []string{"integer"},
+Format: "int32",
+},
+},
+"Int8": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple int8",
+Type: []string{"integer"},
+Format: "byte",
+},
+},
+"Uint": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple int",
+Type: []string{"integer"},
+Format: "int32",
+},
+},
+"Uint64": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple int64",
+Type: []string{"integer"},
+Format: "int64",
+},
+},
+"Uint32": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple int32",
+Type: []string{"integer"},
+Format: "int64",
+},
+},
+"Uint16": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple int16",
+Type: []string{"integer"},
+Format: "int32",
+},
+},
+"Uint8": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple int8",
+Type: []string{"integer"},
+Format: "byte",
+},
+},
+"Byte": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple byte",
+Type: []string{"integer"},
+Format: "byte",
+},
+},
+"Bool": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple boolean",
+Type: []string{"boolean"},
+Format: "",
+},
+},
+"Float64": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple float64",
+Type: []string{"number"},
+Format: "double",
+},
+},
+"Float32": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple float32",
+Type: []string{"number"},
+Format: "float",
+},
+},
+"Time": {
+SchemaProps: spec.SchemaProps{
+Description: "A simple time",
+Type: []string{"string"},
+Format: "date-time",
+},
+},
+"ByteArray": {
+SchemaProps: spec.SchemaProps{
+Description: "a base64 encoded characters",
+Type: []string{"string"},
+Format: "byte",
+},
+},
+"IntOrString": {
+SchemaProps: spec.SchemaProps{
+Description: "an int or string type",
+Ref: spec.MustCreateRef("#/definitions/intstr.IntOrString"),
+},
+},
+},
+Required: []string{"String","Int64","Int32","Int16","Int8","Uint","Uint64","Uint32","Uint16","Uint8","Byte","Bool","Float64","Float32","Time","ByteArray","IntOrString"},
+},
+},
+Dependencies: []string{
+"intstr.IntOrString",},
+},
+`, buffer.String())
+}
+
+func TestFailingSample1(t *testing.T) {
+	err, assert, _ := testOpenAPITypeWritter(t, `
+package foo
+
+// Map sample tests openAPIGen.generateMapProperty method.
+type Blah struct {
+	// A sample String to String map
+	StringToArray map[string]map[string]string
+}
+	`)
+	if assert.Error(err, "An error was expected") {
+		assert.Equal(err, fmt.Errorf("map Element kind Map is not supported in map[string]map[string]string"))
+	}
+}
+
+func TestFailingSample2(t *testing.T) {
+	err, assert, _ := testOpenAPITypeWritter(t, `
+package foo
+
+// Map sample tests openAPIGen.generateMapProperty method.
+type Blah struct {
+	// A sample String to String map
+	StringToArray map[int]string
+}	`)
+	if assert.Error(err, "An error was expected") {
+		assert.Equal(err, fmt.Errorf("map with non-string keys are not supported by OpenAPI in map[int]string"))
+	}
+}
+
+func TestPointer(t *testing.T) {
+	err, assert, buffer := testOpenAPITypeWritter(t, `
+package foo
+
+// PointerSample demonstrate pointer's properties
+type Blah struct {
+	// A string pointer
+	StringPointer *string
+	// A struct pointer
+	StructPointer *Blah
+	// A slice pointer
+	SlicePointer *[]string
+	// A map pointer
+	MapPointer *map[string]string
+}
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.Equal(`"foo.Blah": {
+Schema: spec.Schema{
+SchemaProps: spec.SchemaProps{
+Description: "PointerSample demonstrate pointer's properties",
+Properties: map[string]spec.Schema{
+"StringPointer": {
+SchemaProps: spec.SchemaProps{
+Description: "A string pointer",
+Type: []string{"string"},
+Format: "",
+},
+},
+"StructPointer": {
+SchemaProps: spec.SchemaProps{
+Description: "A struct pointer",
+Ref: spec.MustCreateRef("#/definitions/foo.Blah"),
+},
+},
+"SlicePointer": {
+SchemaProps: spec.SchemaProps{
+Description: "A slice pointer",
+Type: []string{"array"},
+Items: &spec.SchemaOrArray{
+Schema: &spec.Schema{
+SchemaProps: spec.SchemaProps{
+Type: []string{"string"},
+Format: "",
+},
+},
+},
+},
+},
+"MapPointer": {
+SchemaProps: spec.SchemaProps{
+Description: "A map pointer",
+Type: []string{"object"},
+AdditionalProperties: &spec.SchemaOrBool{
+Schema: &spec.Schema{
+SchemaProps: spec.SchemaProps{
+Type: []string{"string"},
+Format: "",
+},
+},
+},
+},
+},
+},
+Required: []string{"StringPointer","StructPointer","SlicePointer","MapPointer"},
+},
+},
+Dependencies: []string{
+"foo.Blah",},
+},
+`, buffer.String())
+}

cmd/libs/go2idl/openapi-gen/main.go

+/*
+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.
+*/
+
+// This package generates openAPI definition file to be used in open API spec generation on API servers. To generate
+// definition for a specific type or package add "+k8s:openapi-gen=true" tag to the type/package comment lines. To
+// exclude a type from a tagged package, add "+k8s:openapi-gen=false" tag to the type comment lines.
+package main
+
+import (
+	"k8s.io/kubernetes/cmd/libs/go2idl/args"
+	"k8s.io/kubernetes/cmd/libs/go2idl/openapi-gen/generators"
+
+	"github.com/golang/glog"
+)
+
+func main() {
+	arguments := args.Default()
+
+	// Override defaults.
+	arguments.OutputFileBaseName = "openapi_generated"
+
+	// Run it.
+	if err := arguments.Execute(
+		generators.NameSystems(),
+		generators.DefaultNameSystem(),
+		generators.Packages,
+	); err != nil {
+		glog.Fatalf("Error: %v", err)
+	}
+	glog.V(2).Info("Completed successfully.")
+}

federation/apis/federation/v1beta1/doc.go

@@ -16,5 +16,5 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/federation/apis/federation
-
+// +k8s:openapi-gen=true
 package v1beta1 // import "k8s.io/kubernetes/federation/apis/federation/v1beta1"

hack/.linted_packages

@@ -24,6 +24,7 @@ cmd/libs/go2idl/generator
 cmd/libs/go2idl/go-to-protobuf
 cmd/libs/go2idl/go-to-protobuf/protoc-gen-gogo
 cmd/libs/go2idl/import-boss
+cmd/libs/go2idl/openapi-gen
 cmd/libs/go2idl/parser
 cmd/libs/go2idl/set-gen
 cmd/libs/go2idl/set-gen/generators

pkg/api/resource/amount.go

@@ -54,6 +54,7 @@ var (
 
 // int64Amount represents a fixed precision numerator and arbitrary scale exponent. It is faster
 // than operations on inf.Dec for values that can be represented as int64.
+// +k8s:openapi-gen=true
 type int64Amount struct {
 	value int64
 	scale Scale

pkg/api/resource/generated.proto

@@ -87,6 +87,7 @@ option go_package = "resource";
 // +protobuf.embed=string
 // +protobuf.options.marshal=false
 // +protobuf.options.(gogoproto.goproto_stringer)=false
+// +k8s:openapi-gen=true
 message Quantity {
   optional string string = 1;
 }

pkg/api/resource/quantity.go

@@ -27,7 +27,9 @@ import (
 
 	flag "github.com/spf13/pflag"
 
+	"github.com/go-openapi/spec"
 	inf "gopkg.in/inf.v0"
+	"k8s.io/kubernetes/cmd/libs/go2idl/openapi-gen/generators/common"
 )
 
 // Quantity is a fixed-point representation of a number.
@@ -91,6 +93,7 @@ import (
 // +protobuf.embed=string
 // +protobuf.options.marshal=false
 // +protobuf.options.(gogoproto.goproto_stringer)=false
+// +k8s:openapi-gen=true
 type Quantity struct {
 	// i is the quantity in int64 scaled form, if d.Dec == nil
 	i int64Amount
@@ -395,6 +398,18 @@ func (q Quantity) DeepCopy() Quantity {
 	return q
 }
 
+// OpenAPIDefinition returns openAPI definition for this type.
+func (_ Quantity) OpenAPIDefinition() common.OpenAPIDefinition {
+	return common.OpenAPIDefinition{
+		Schema: spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Type:   []string{"string"},
+				Format: "",
+			},
+		},
+	}
+}
+
 // CanonicalizeBytes returns the canonical form of q and its suffix (see comment on Quantity).
 //
 // Note about BinarySI:

pkg/api/unversioned/doc.go

@@ -15,5 +15,6 @@ limitations under the License.
 */
 
 // +k8s:deepcopy-gen=package
+// +k8s:openapi-gen=true
 
 package unversioned // import "k8s.io/kubernetes/pkg/api/unversioned"

pkg/api/unversioned/time.go

@@ -20,6 +20,9 @@ import (
 	"encoding/json"
 	"time"
 
+	"k8s.io/kubernetes/cmd/libs/go2idl/openapi-gen/generators/common"
+
+	"github.com/go-openapi/spec"
 	"github.com/google/gofuzz"
 )
 
@@ -142,6 +145,17 @@ func (t Time) MarshalJSON() ([]byte, error) {
 	return json.Marshal(t.UTC().Format(time.RFC3339))
 }
 
+func (_ Time) OpenAPIDefinition() common.OpenAPIDefinition {
+	return common.OpenAPIDefinition{
+		Schema: spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Type:   []string{"string"},
+				Format: "date-time",
+			},
+		},
+	}
+}
+
 // MarshalQueryParameter converts to a URL query parameter value
 func (t Time) MarshalQueryParameter() (string, error) {
 	if t.IsZero() {

pkg/api/v1/doc.go

@@ -16,6 +16,7 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/api
+// +k8s:openapi-gen=true
 
 // Package v1 is the v1 version of the API.
 package v1 // import "k8s.io/kubernetes/pkg/api/v1"

pkg/apis/abac/types.go

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+// +k8s:openapi-gen=true
 package abac
 
 import "k8s.io/kubernetes/pkg/api/unversioned"

pkg/apis/abac/v0/types.go

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+// +k8s:openapi-gen=true
 package v0
 
 import "k8s.io/kubernetes/pkg/api/unversioned"

pkg/apis/abac/v1beta1/types.go

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+// +k8s:openapi-gen=true
 package v1beta1
 
 import "k8s.io/kubernetes/pkg/api/unversioned"

pkg/apis/apps/doc.go

@@ -15,5 +15,6 @@ limitations under the License.
 */
 
 // +k8s:deepcopy-gen=package,register
+// +k8s:openapi-gen=true
 
 package apps // import "k8s.io/kubernetes/pkg/apis/apps"

pkg/apis/apps/v1alpha1/doc.go

@@ -16,5 +16,6 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/apps
+// +k8s:openapi-gen=true
 
 package v1alpha1 // import "k8s.io/kubernetes/pkg/apis/apps/v1alpha1"

pkg/apis/authentication/doc.go

@@ -16,4 +16,5 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +groupName=authentication.k8s.io
+// +k8s:openapi-gen=true
 package authentication // import "k8s.io/kubernetes/pkg/apis/authentication"

pkg/apis/authentication/v1beta1/doc.go

@@ -17,4 +17,5 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/authentication
 // +groupName=authentication.k8s.io
+// +k8s:openapi-gen=true
 package v1beta1 // import "k8s.io/kubernetes/pkg/apis/authentication/v1beta1"

pkg/apis/authorization/doc.go

@@ -15,6 +15,7 @@ limitations under the License.
 */
 
 // +k8s:deepcopy-gen=package,register
+// +k8s:openapi-gen=true
 
 // +groupName=authorization.k8s.io
 package authorization // import "k8s.io/kubernetes/pkg/apis/authorization"

pkg/apis/authorization/v1beta1/doc.go

@@ -16,6 +16,7 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/authorization
+// +k8s:openapi-gen=true
 
 // +groupName=authorization.k8s.io
 package v1beta1 // import "k8s.io/kubernetes/pkg/apis/authorization/v1beta1"

pkg/apis/autoscaling/doc.go

@@ -15,5 +15,6 @@ limitations under the License.
 */
 
 // +k8s:deepcopy-gen=package,register
+// +k8s:openapi-gen=true
 
 package autoscaling // import "k8s.io/kubernetes/pkg/apis/autoscaling"

pkg/apis/autoscaling/v1/doc.go

@@ -16,5 +16,6 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/autoscaling
+// +k8s:openapi-gen=true
 
 package v1 // import "k8s.io/kubernetes/pkg/apis/autoscaling/v1"

pkg/apis/batch/doc.go

@@ -15,5 +15,6 @@ limitations under the License.
 */
 
 // +k8s:deepcopy-gen=package,register
+// +k8s:openapi-gen=true
 
 package batch // import "k8s.io/kubernetes/pkg/apis/batch"

pkg/apis/batch/v1/doc.go

@@ -16,5 +16,6 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/batch
+// +k8s:openapi-gen=true
 
 package v1 // import "k8s.io/kubernetes/pkg/apis/batch/v1"

pkg/apis/batch/v2alpha1/doc.go

@@ -16,5 +16,6 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/batch
+// +k8s:openapi-gen=true
 
 package v2alpha1 // import "k8s.io/kubernetes/pkg/apis/batch/v2alpha1"

pkg/apis/certificates/doc.go

@@ -15,6 +15,7 @@ limitations under the License.
 */
 
 // +k8s:deepcopy-gen=package,register
+// +k8s:openapi-gen=true
 
 // +groupName=certificates.k8s.io
 package certificates // import "k8s.io/kubernetes/pkg/apis/certificates"

pkg/apis/certificates/v1alpha1/doc.go

@@ -17,5 +17,6 @@ limitations under the License.
 // +groupName=certificates.k8s.io
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/certificates
+// +k8s:openapi-gen=true
 
 package v1alpha1 // import "k8s.io/kubernetes/pkg/apis/certificates/v1alpha1"

pkg/apis/componentconfig/doc.go

@@ -15,5 +15,6 @@ limitations under the License.
 */
 
 // +k8s:deepcopy-gen=package,register
+// +k8s:openapi-gen=true
 
 package componentconfig // import "k8s.io/kubernetes/pkg/apis/componentconfig"

pkg/apis/componentconfig/v1alpha1/doc.go

@@ -16,5 +16,6 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/componentconfig
+// +k8s:openapi-gen=true
 
 package v1alpha1 // import "k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1"

pkg/apis/extensions/doc.go

@@ -15,5 +15,6 @@ limitations under the License.
 */
 
 // +k8s:deepcopy-gen=package,register
+// +k8s:openapi-gen=true
 
 package extensions // import "k8s.io/kubernetes/pkg/apis/extensions"

pkg/apis/extensions/v1beta1/doc.go

@@ -18,5 +18,6 @@ limitations under the License.
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/extensions
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/autoscaling
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/batch
+// +k8s:openapi-gen=true
 
 package v1beta1 // import "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"

pkg/apis/imagepolicy/doc.go

@@ -16,5 +16,6 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +groupName=imagepolicy.k8s.io
+// +k8s:openapi-gen=true
 
 package imagepolicy // import "k8s.io/kubernetes/pkg/apis/imagepolicy"

pkg/apis/imagepolicy/v1alpha1/doc.go

@@ -17,5 +17,6 @@ limitations under the License.
 // +groupName=imagepolicy.k8s.io
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/imagepolicy
+// +k8s:openapi-gen=true
 
 package v1alpha1 // import "k8s.io/kubernetes/pkg/apis/imagepolicy/v1alpha1"

pkg/apis/policy/doc.go

@@ -15,5 +15,6 @@ limitations under the License.
 */
 
 // +k8s:deepcopy-gen=package,register
+// +k8s:openapi-gen=true
 
 package policy // import "k8s.io/kubernetes/pkg/apis/policy"

pkg/apis/policy/v1alpha1/doc.go

@@ -20,4 +20,5 @@ limitations under the License.
 // Package policy is for any kind of policy object.  Suitable examples, even if
 // they aren't all here, are PodDisruptionBudget, PodSecurityPolicy,
 // NetworkPolicy, etc.
+// +k8s:openapi-gen=true
 package v1alpha1 // import "k8s.io/kubernetes/pkg/apis/policy/v1alpha1"

pkg/apis/rbac/doc.go

@@ -15,6 +15,7 @@ limitations under the License.
 */
 
 // +k8s:deepcopy-gen=package,register
+// +k8s:openapi-gen=true
 
 // +groupName=rbac.authorization.k8s.io
 package rbac // import "k8s.io/kubernetes/pkg/apis/rbac"

pkg/apis/rbac/v1alpha1/doc.go

@@ -17,5 +17,6 @@ limitations under the License.
 // +groupName=rbac.authorization.k8s.io
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/rbac
+// +k8s:openapi-gen=true
 
 package v1alpha1 // import "k8s.io/kubernetes/pkg/apis/rbac/v1alpha1"

pkg/apis/storage/doc.go

@@ -16,4 +16,5 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 // +groupName=storage.k8s.io
+// +g8k:openapi-gen=true
 package storage // import "k8s.io/kubernetes/pkg/apis/storage"

pkg/apis/storage/v1beta1/doc.go

@@ -17,4 +17,5 @@ limitations under the License.
 // +k8s:deepcopy-gen=package,register
 // +k8s:conversion-gen=k8s.io/kubernetes/pkg/apis/storage
 // +groupName=storage.k8s.io
+// +k8s:openapi-gen=true
 package v1beta1 // import "k8s.io/kubernetes/pkg/apis/storage/v1beta1"

pkg/apiserver/apiserver.go

@@ -215,7 +215,7 @@ func InstallLogsSupport(mux Mux, container *restful.Container) {
 	ws := new(restful.WebService)
 	ws.Path("/logs")
 	ws.Doc("get log files")
-	ws.Route(ws.GET("/{logpath:*}").To(logFileHandler))
+	ws.Route(ws.GET("/{logpath:*}").To(logFileHandler).Param(ws.PathParameter("logpath", "path to the log").DataType("string")))
 	ws.Route(ws.GET("/").To(logFileListHandler))
 
 	container.Add(ws)

pkg/genericapiserver/genericapiserver.go

@@ -522,17 +522,38 @@ func (s *GenericAPIServer) InstallSwaggerAPI() {
 	swagger.RegisterSwaggerService(*s.getSwaggerConfig(), s.HandlerContainer)
 }
 
-// InstallOpenAPI installs the /swagger.json endpoint to allow new OpenAPI schema discovery.
+// InstallOpenAPI installs spec endpoints for each web service.
 func (s *GenericAPIServer) InstallOpenAPI() {
-	openAPIConfig := openapi.Config{
-		SwaggerConfig:   s.getSwaggerConfig(),
+	// Install one spec per web service, an ideal client will have a ClientSet containing one client
+	// per each of these specs.
+	for _, w := range s.HandlerContainer.RegisteredWebServices() {
+		if w.RootPath() == "/swaggerapi" {
+			continue
+		}
+		info := s.openAPIInfo
+		info.Title = info.Title + " " + w.RootPath()
+		err := openapi.RegisterOpenAPIService(&openapi.Config{
+			OpenAPIServePath: w.RootPath() + "/swagger.json",
+			WebServices:      []*restful.WebService{w},
+			ProtocolList:     []string{"https"},
 			IgnorePrefixes:   []string{"/swaggerapi"},
-		Info:            &s.openAPIInfo,
+			Info:             &info,
 			DefaultResponse:  &s.openAPIDefaultResponse,
+		}, s.HandlerContainer)
+		if err != nil {
+			glog.Fatalf("Failed to register open api spec for %v: %v", w.RootPath(), err)
 		}
-	err := openapi.RegisterOpenAPIService(&openAPIConfig, s.HandlerContainer)
+	}
+	err := openapi.RegisterOpenAPIService(&openapi.Config{
+		OpenAPIServePath: "/swagger.json",
+		WebServices:      s.HandlerContainer.RegisteredWebServices(),
+		ProtocolList:     []string{"https"},
+		IgnorePrefixes:   []string{"/swaggerapi"},
+		Info:             &s.openAPIInfo,
+		DefaultResponse:  &s.openAPIDefaultResponse,
+	}, s.HandlerContainer)
 	if err != nil {
-		glog.Fatalf("Failed to generate open api spec: %v", err)
+		glog.Fatalf("Failed to register open api spec for root: %v", err)
 	}
 }
 

pkg/genericapiserver/openapi/openapi_test.go

@@ -22,56 +22,119 @@ import (
 	"testing"
 
 	"github.com/emicklei/go-restful"
-	"github.com/emicklei/go-restful/swagger"
 	"github.com/go-openapi/spec"
 	"github.com/stretchr/testify/assert"
+	"k8s.io/kubernetes/cmd/libs/go2idl/openapi-gen/generators/common"
 	"sort"
 )
 
 // setUp is a convenience function for setting up for (most) tests.
 func setUp(t *testing.T, fullMethods bool) (openAPI, *assert.Assertions) {
 	assert := assert.New(t)
-	config := Config{
-		SwaggerConfig: getSwaggerConfig(fullMethods),
-		Info: &spec.Info{
-			InfoProps: spec.InfoProps{
-				Title:       "TestAPI",
-				Description: "Test API",
+	config := 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,
 			},
 		},
-	}
-	return openAPI{config: &config}, assert
+		openAPIDefinitions: &common.OpenAPIDefinitions{
+			"openapi.TestInput":  *TestInput{}.OpenAPIDefinition(),
+			"openapi.TestOutput": *TestOutput{}.OpenAPIDefinition(),
+		},
+	}, 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 (t TestInput) SwaggerDoc() map[string]string {
-	return map[string]string{
-		"":     "Test input",
-		"name": "Name of the input",
-		"id":   "ID of the input",
+func (_ TestInput) OpenAPIDefinition() *common.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 &common.OpenAPIDefinition{
+		Schema:       schema,
+		Dependencies: []string{},
 	}
 }
 
-func (t TestOutput) SwaggerDoc() map[string]string {
-	return map[string]string{
-		"":      "Test output",
-		"name":  "Name of the output",
-		"count": "Number of outputs",
+func (_ TestOutput) OpenAPIDefinition() *common.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 &common.OpenAPIDefinition{
+		Schema:       schema,
+		Dependencies: []string{},
 	}
 }
 
+var _ common.OpenAPIDefinitionGetter = TestInput{}
+var _ common.OpenAPIDefinitionGetter = TestOutput{}
+
 func getTestRoute(ws *restful.WebService, method string, additionalParams bool) *restful.RouteBuilder {
 	ret := ws.Method(method).
 		Path("/test/{path:*}").
@@ -92,7 +155,7 @@ func getTestRoute(ws *restful.WebService, method string, additionalParams bool)
 	return ret
 }
 
-func getSwaggerConfig(fullMethods bool) *swagger.Config {
+func getConfig(fullMethods bool) *Config {
 	mux := http.NewServeMux()
 	container := restful.NewContainer()
 	container.ServeMux = mux
@@ -120,9 +183,16 @@ func getSwaggerConfig(fullMethods bool) *swagger.Config {
 
 	}
 	container.Add(ws)
-	return &swagger.Config{
-		WebServicesUrl: "https://test-server",
+	return &Config{
 		WebServices:      container.RegisteredWebServices(),
+		ProtocolList:     []string{"https"},
+		OpenAPIServePath: "/swagger.json",
+		Info: &spec.Info{
+			InfoProps: spec.InfoProps{
+				Title:       "TestAPI",
+				Description: "Test API",
+			},
+		},
 	}
 }
 
@@ -285,27 +355,23 @@ func getTestInputDefinition() spec.Schema {
 	return spec.Schema{
 		SchemaProps: spec.SchemaProps{
 			Description: "Test input",
-			Required:    []string{},
 			Properties: map[string]spec.Schema{
 				"id": {
 					SchemaProps: spec.SchemaProps{
 						Description: "ID of the input",
 						Type:        spec.StringOrArray{"integer"},
 						Format:      "int32",
-						Enum:        []interface{}{},
 					},
 				},
 				"name": {
 					SchemaProps: spec.SchemaProps{
 						Description: "Name of the input",
 						Type:        spec.StringOrArray{"string"},
-						Enum:        []interface{}{},
 					},
 				},
 				"tags": {
 					SchemaProps: spec.SchemaProps{
 						Type: spec.StringOrArray{"array"},
-						Enum: []interface{}{},
 						Items: &spec.SchemaOrArray{
 							Schema: &spec.Schema{
 								SchemaProps: spec.SchemaProps{
@@ -324,21 +390,18 @@ func getTestOutputDefinition() spec.Schema {
 	return spec.Schema{
 		SchemaProps: spec.SchemaProps{
 			Description: "Test output",
-			Required:    []string{},
 			Properties: map[string]spec.Schema{
 				"count": {
 					SchemaProps: spec.SchemaProps{
 						Description: "Number of outputs",
 						Type:        spec.StringOrArray{"integer"},
 						Format:      "int32",
-						Enum:        []interface{}{},
 					},
 				},
 				"name": {
 					SchemaProps: spec.SchemaProps{
 						Description: "Name of the output",
 						Type:        spec.StringOrArray{"string"},
-						Enum:        []interface{}{},
 					},
 				},
 			},
@@ -369,49 +432,10 @@ func TestBuildSwaggerSpec(t *testing.T) {
 			},
 		},
 	}
-	err := o.buildSwaggerSpec()
+	err := o.init()
 	if assert.NoError(err) {
 		sortParameters(expected)
 		sortParameters(o.swagger)
 		assert.Equal(expected, o.swagger)
 	}
 }
-
-func TestBuildSwaggerSpecTwice(t *testing.T) {
-	o, assert := setUp(t, true)
-	err := o.buildSwaggerSpec()
-	if assert.NoError(err) {
-		assert.Error(o.buildSwaggerSpec(), "Swagger spec is already built. Duplicate call to buildSwaggerSpec is not allowed.")
-	}
-
-}
-func TestBuildDefinitions(t *testing.T) {
-	o, assert := setUp(t, true)
-	expected := spec.Definitions{
-		"openapi.TestInput":  getTestInputDefinition(),
-		"openapi.TestOutput": getTestOutputDefinition(),
-	}
-	def, err := o.buildDefinitions()
-	if assert.NoError(err) {
-		assert.Equal(expected, def)
-	}
-}
-
-func TestBuildProtocolList(t *testing.T) {
-	assert := assert.New(t)
-	o := openAPI{config: &Config{SwaggerConfig: &swagger.Config{WebServicesUrl: "https://something"}}}
-	p, err := o.buildProtocolList()
-	if assert.NoError(err) {
-		assert.Equal([]string{"https"}, p)
-	}
-	o = openAPI{config: &Config{SwaggerConfig: &swagger.Config{WebServicesUrl: "http://something"}}}
-	p, err = o.buildProtocolList()
-	if assert.NoError(err) {
-		assert.Equal([]string{"http"}, p)
-	}
-	o = openAPI{config: &Config{SwaggerConfig: &swagger.Config{WebServicesUrl: "something"}}}
-	p, err = o.buildProtocolList()
-	if assert.NoError(err) {
-		assert.Equal([]string{"http"}, p)
-	}
-}

pkg/kubelet/server/server.go

@@ -342,7 +342,8 @@ func (s *Server) InstallDebuggingHandlers() {
 		Operation("getLogs"))
 	ws.Route(ws.GET("/{logpath:*}").
 		To(s.getLogs).
-		Operation("getLogs"))
+		Operation("getLogs").
+		Param(ws.PathParameter("logpath", "path to the log").DataType("string")))
 	s.restfulCont.Add(ws)
 
 	ws = new(restful.WebService)

pkg/master/master_test.go

@@ -821,6 +821,16 @@ func decodeResponse(resp *http.Response, obj interface{}) error {
 	return nil
 }
 
+func writeResponseToFile(resp *http.Response, filename string) error {
+	defer resp.Body.Close()
+
+	data, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(filename, data, 0755)
+}
+
 func TestInstallThirdPartyAPIGet(t *testing.T) {
 	for _, version := range versionsToTest {
 		testInstallThirdPartyAPIGetVersion(t, version)
@@ -1228,6 +1238,7 @@ func TestValidOpenAPISpec(t *testing.T) {
 	defer etcdserver.Terminate(t)
 
 	config.EnableOpenAPISupport = true
+	config.EnableIndex = true
 	config.OpenAPIInfo = spec.Info{
 		InfoProps: spec.InfoProps{
 			Title:   "Kubernetes",
@@ -1262,12 +1273,67 @@ func TestValidOpenAPISpec(t *testing.T) {
 		assert.NoError(res.AsError())
 	}
 
+	// TODO(mehdy): The actual validation part of these tests are timing out on jerkin but passing locally. Enable it after debugging timeout issue.
+	disableValidation := true
+
+	// Saving specs to a temporary folder is a good way to debug spec generation without bringing up an actual
+	// api server.
+	saveSwaggerSpecs := false
+
 	// Validate OpenApi spec
 	doc, err := loads.Spec(server.URL + "/swagger.json")
 	if assert.NoError(err) {
-		// TODO(mehdy): This test is timing out on jerkin but passing locally. Enable it after debugging timeout issue.
-		_ = validate.NewSpecValidator(doc.Schema(), strfmt.Default)
-		// res, _ := validator.Validate(doc)
-		// assert.NoError(res.AsError())
+		validator := validate.NewSpecValidator(doc.Schema(), strfmt.Default)
+		if !disableValidation {
+			res, warns := validator.Validate(doc)
+			assert.NoError(res.AsError())
+			if !warns.IsValid() {
+				t.Logf("Open API spec on root has some warnings : %v", warns)
+			}
+		} else {
+			t.Logf("Validation is disabled because it is timing out on jenkins put passing locally.")
 		}
+	}
+
+	// validate specs on each end-point
+	resp, err = http.Get(server.URL)
+	if !assert.NoError(err) {
+		t.Errorf("unexpected error: %v", err)
+	}
+	assert.Equal(http.StatusOK, resp.StatusCode)
+	var list unversioned.RootPaths
+	if assert.NoError(decodeResponse(resp, &list)) {
+		for _, path := range list.Paths {
+			if !strings.HasPrefix(path, "/api") {
+				continue
+			}
+			t.Logf("Validating open API spec on %v ...", path)
+
+			if saveSwaggerSpecs {
+				resp, err = http.Get(server.URL + path + "/swagger.json")
+				if !assert.NoError(err) {
+					t.Errorf("unexpected error: %v", err)
+				}
+				assert.Equal(http.StatusOK, resp.StatusCode)
+				assert.NoError(writeResponseToFile(resp, "/tmp/swagger_"+strings.Replace(path, "/", "_", -1)+".json"))
+			}
+
+			// Validate OpenApi spec on path
+			doc, err := loads.Spec(server.URL + path + "/swagger.json")
+			if assert.NoError(err) {
+				validator := validate.NewSpecValidator(doc.Schema(), strfmt.Default)
+				if !disableValidation {
+					res, warns := validator.Validate(doc)
+					assert.NoError(res.AsError())
+					if !warns.IsValid() {
+						t.Logf("Open API spec on %v has some warnings : %v", path, warns)
+					}
+				} else {
+					t.Logf("Validation is disabled because it is timing out on jenkins put passing locally.")
+				}
+			}
+
+		}
+	}
+
 }

pkg/runtime/generated.proto

@@ -71,6 +71,7 @@ option go_package = "runtime";
 // 
 // +k8s:deepcopy-gen=true
 // +protobuf=true
+// +k8s:openapi-gen=true
 message RawExtension {
   // Raw is the underlying serialization of this object.
   // 
@@ -91,6 +92,7 @@ message RawExtension {
 // 
 // +k8s:deepcopy-gen=true
 // +protobuf=true
+// +k8s:openapi-gen=true
 message TypeMeta {
   optional string apiVersion = 1;
 
@@ -105,6 +107,7 @@ message TypeMeta {
 // 
 // +k8s:deepcopy-gen=true
 // +protobuf=true
+// +k8s:openapi-gen=true
 message Unknown {
   optional TypeMeta typeMeta = 1;
 

pkg/runtime/types.go

@@ -43,6 +43,7 @@ import (
 //
 // +k8s:deepcopy-gen=true
 // +protobuf=true
+// +k8s:openapi-gen=true
 type TypeMeta struct {
 	APIVersion string `json:"apiVersion,omitempty" yaml:"apiVersion,omitempty" protobuf:"bytes,1,opt,name=apiVersion"`
 	Kind       string `json:"kind,omitempty" yaml:"kind,omitempty" protobuf:"bytes,2,opt,name=kind"`
@@ -96,6 +97,7 @@ const (
 //
 // +k8s:deepcopy-gen=true
 // +protobuf=true
+// +k8s:openapi-gen=true
 type RawExtension struct {
 	// Raw is the underlying serialization of this object.
 	//
@@ -114,6 +116,7 @@ type RawExtension struct {
 //
 // +k8s:deepcopy-gen=true
 // +protobuf=true
+// +k8s:openapi-gen=true
 type Unknown struct {
 	TypeMeta `json:",inline" protobuf:"bytes,1,opt,name=typeMeta"`
 	// Raw will hold the complete serialized object which couldn't be matched

pkg/util/intstr/generated.proto

@@ -32,6 +32,7 @@ option go_package = "intstr";
 // 
 // +protobuf=true
 // +protobuf.options.(gogoproto.goproto_stringer)=false
+// +k8s:openapi-gen=true
 message IntOrString {
   optional int64 type = 1;
 

pkg/util/intstr/intstr.go

@@ -23,6 +23,9 @@ import (
 	"strconv"
 	"strings"
 
+	"k8s.io/kubernetes/cmd/libs/go2idl/openapi-gen/generators/common"
+
+	"github.com/go-openapi/spec"
 	"github.com/google/gofuzz"
 )
 
@@ -34,6 +37,7 @@ import (
 //
 // +protobuf=true
 // +protobuf.options.(gogoproto.goproto_stringer)=false
+// +k8s:openapi-gen=true
 type IntOrString struct {
 	Type   Type   `protobuf:"varint,1,opt,name=type,casttype=Type"`
 	IntVal int32  `protobuf:"varint,2,opt,name=intVal"`
@@ -101,6 +105,17 @@ func (intstr IntOrString) MarshalJSON() ([]byte, error) {
 	}
 }
 
+func (_ IntOrString) OpenAPIDefinition() common.OpenAPIDefinition {
+	return common.OpenAPIDefinition{
+		Schema: spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Type:   []string{"string"},
+				Format: "int-or-string",
+			},
+		},
+	}
+}
+
 func (intstr *IntOrString) Fuzz(c fuzz.Continue) {
 	if intstr == nil {
 		return

pkg/version/doc.go

@@ -16,4 +16,5 @@ limitations under the License.
 
 // Package version supplies version information collected at build time to
 // kubernetes components.
+// +k8s:openapi-gen=true
 package version // import "k8s.io/kubernetes/pkg/version"

pkg/watch/versioned/generated.proto

@@ -30,6 +30,7 @@ option go_package = "versioned";
 // Event represents a single event to a watched resource.
 // 
 // +protobuf=true
+// +k8s:openapi-gen=true
 message Event {
   optional string type = 1;
 

pkg/watch/versioned/types.go

@@ -25,6 +25,7 @@ import (
 // Event represents a single event to a watched resource.
 //
 // +protobuf=true
+// +k8s:openapi-gen=true
 type Event struct {
 	Type string `json:"type" protobuf:"bytes,1,opt,name=type"`