Merge pull request #44531 from pwittrock/kubectl-openapi

hack/.linted_packages

@@ -184,6 +184,7 @@ pkg/credentialprovider/aws
 pkg/fieldpath
 pkg/fields
 pkg/hyperkube
+pkg/kubectl/cmd/util/openapi
 pkg/kubelet/api
 pkg/kubelet/container
 pkg/kubelet/envvars

pkg/kubectl/cmd/get.go

@@ -131,6 +131,7 @@ func NewCmdGet(f cmdutil.Factory, out io.Writer, errOut io.Writer) *cobra.Comman
 	usage := "identifying the resource to get from a server."
 	cmdutil.AddFilenameOptionFlags(cmd, &options.FilenameOptions, usage)
 	cmdutil.AddInclude3rdPartyFlags(cmd)
+	cmdutil.AddOpenAPIFlags(cmd)
 	cmd.Flags().StringVar(&options.Raw, "raw", options.Raw, "Raw URI to request from the server.  Uses the transport specified by the kubeconfig file.")
 	return cmd
 }

pkg/kubectl/cmd/testing/BUILD

@@ -19,6 +19,7 @@ go_library(
         "//pkg/client/clientset_generated/internalclientset:go_default_library",
         "//pkg/kubectl:go_default_library",
         "//pkg/kubectl/cmd/util:go_default_library",
+        "//pkg/kubectl/cmd/util/openapi:go_default_library",
         "//pkg/kubectl/resource:go_default_library",
         "//pkg/printers:go_default_library",
         "//vendor/github.com/emicklei/go-restful/swagger:go_default_library",

pkg/kubectl/cmd/testing/fake.go

@@ -42,6 +42,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/kubectl"
 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
 	"k8s.io/kubernetes/pkg/printers"
 )
@@ -404,6 +405,10 @@ func (f *FakeFactory) SwaggerSchema(schema.GroupVersionKind) (*swagger.ApiDeclar
 	return nil, nil
 }
 
+func (f *FakeFactory) OpenAPISchema(cacheDir string) (*openapi.Resources, error) {
+	return &openapi.Resources{}, nil
+}
+
 func (f *FakeFactory) DefaultNamespace() (string, bool, error) {
 	return f.tf.Namespace, false, f.tf.Err
 }

pkg/kubectl/cmd/util/BUILD

@@ -37,6 +37,7 @@ go_library(
         "//pkg/client/unversioned:go_default_library",
         "//pkg/controller:go_default_library",
         "//pkg/kubectl:go_default_library",
+        "//pkg/kubectl/cmd/util/openapi:go_default_library",
         "//pkg/kubectl/resource:go_default_library",
         "//pkg/printers:go_default_library",
         "//pkg/printers/internalversion:go_default_library",
@@ -44,6 +45,7 @@ go_library(
         "//pkg/version:go_default_library",
         "//vendor/github.com/emicklei/go-restful/swagger:go_default_library",
         "//vendor/github.com/evanphx/json-patch:go_default_library",
+        "//vendor/github.com/go-openapi/spec:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/github.com/spf13/cobra:go_default_library",
         "//vendor/github.com/spf13/pflag:go_default_library",
@@ -102,6 +104,7 @@ go_test(
         "//pkg/kubectl/resource:go_default_library",
         "//pkg/util/exec:go_default_library",
         "//vendor/github.com/emicklei/go-restful/swagger:go_default_library",
+        "//vendor/github.com/go-openapi/spec:go_default_library",
         "//vendor/github.com/stretchr/testify/assert:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/equality:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
@@ -137,6 +140,7 @@ filegroup(
         ":package-srcs",
         "//pkg/kubectl/cmd/util/editor:all-srcs",
         "//pkg/kubectl/cmd/util/jsonmerge:all-srcs",
+        "//pkg/kubectl/cmd/util/openapi:all-srcs",
         "//pkg/kubectl/cmd/util/sanity:all-srcs",
     ],
     tags = ["automanaged"],

pkg/kubectl/cmd/util/cached_discovery.go

@@ -25,6 +25,7 @@ import (
 	"time"
 
 	"github.com/emicklei/go-restful/swagger"
+	"github.com/go-openapi/spec"
 	"github.com/golang/glog"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -236,6 +237,10 @@ func (d *CachedDiscoveryClient) SwaggerSchema(version schema.GroupVersion) (*swa
 	return d.delegate.SwaggerSchema(version)
 }
 
+func (d *CachedDiscoveryClient) OpenAPISchema() (*spec.Swagger, error) {
+	return d.delegate.OpenAPISchema()
+}
+
 func (d *CachedDiscoveryClient) Fresh() bool {
 	d.mutex.Lock()
 	defer d.mutex.Unlock()

pkg/kubectl/cmd/util/cached_discovery_test.go

@@ -23,6 +23,7 @@ import (
 	"time"
 
 	"github.com/emicklei/go-restful/swagger"
+	"github.com/go-openapi/spec"
 	"github.com/stretchr/testify/assert"
 
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -101,6 +102,7 @@ type fakeDiscoveryClient struct {
 	resourceCalls int
 	versionCalls  int
 	swaggerCalls  int
+	openAPICalls  int
 
 	serverResourcesHandler func() ([]*metav1.APIResourceList, error)
 }
@@ -168,3 +170,8 @@ func (c *fakeDiscoveryClient) SwaggerSchema(version schema.GroupVersion) (*swagg
 	c.swaggerCalls = c.swaggerCalls + 1
 	return &swagger.ApiDeclaration{}, nil
 }
+
+func (c *fakeDiscoveryClient) OpenAPISchema() (*spec.Swagger, error) {
+	c.openAPICalls = c.openAPICalls + 1
+	return &spec.Swagger{}, nil
+}

pkg/kubectl/cmd/util/factory.go

@@ -30,6 +30,7 @@ import (
 	"time"
 
 	"github.com/emicklei/go-restful/swagger"
+	"github.com/golang/glog"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 
@@ -50,6 +51,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"
 	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
 	"k8s.io/kubernetes/pkg/printers"
 )
@@ -219,6 +221,8 @@ type ObjectMappingFactory interface {
 	Validator(validate bool, cacheDir string) (validation.Schema, error)
 	// SwaggerSchema returns the schema declaration for the provided group version kind.
 	SwaggerSchema(schema.GroupVersionKind) (*swagger.ApiDeclaration, error)
+	// OpenAPISchema returns the schema openapi schema definiton
+	OpenAPISchema(cacheDir string) (*openapi.Resources, error)
 }
 
 // BuilderFactory holds the second level of factory methods.  These functions depend upon ObjectMappingFactory and ClientAccessFactory methods.
@@ -417,6 +421,7 @@ func writeSchemaFile(schemaData []byte, cacheDir, cacheFile, prefix, groupVersio
 	if _, err := io.Copy(tmpFile, bytes.NewBuffer(schemaData)); err != nil {
 		return err
 	}
+	glog.V(4).Infof("Writing swagger cache (dir %v) file %v (from %v)", cacheDir, cacheFile, tmpFile.Name())
 	if err := os.Link(tmpFile.Name(), cacheFile); err != nil {
 		// If we can't write due to file existing, or permission problems, keep going.
 		if os.IsExist(err) || os.IsPermission(err) {

pkg/kubectl/cmd/util/factory_object_mapping.go

@@ -24,6 +24,7 @@ import (
 	"os"
 	"path"
 	"sort"
+	"sync"
 	"time"
 
 	"github.com/emicklei/go-restful/swagger"
@@ -46,6 +47,7 @@ import (
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/kubectl"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
 	"k8s.io/kubernetes/pkg/printers"
 	printersinternal "k8s.io/kubernetes/pkg/printers/internalversion"
@@ -53,6 +55,14 @@ import (
 
 type ring1Factory struct {
 	clientAccessFactory ClientAccessFactory
+
+	// openAPIGetter loads and caches openapi specs
+	openAPIGetter openAPIGetter
+}
+
+type openAPIGetter struct {
+	once   sync.Once
+	getter openapi.Getter
 }
 
 func NewObjectMappingFactory(clientAccessFactory ClientAccessFactory) ObjectMappingFactory {
@@ -427,3 +437,41 @@ func (f *ring1Factory) SwaggerSchema(gvk schema.GroupVersionKind) (*swagger.ApiD
 	}
 	return discovery.SwaggerSchema(version)
 }
+
+// OpenAPISchema returns metadata and structural information about Kubernetes object definitions.
+// Will try to cache the data to a local file.  Cache is written and read from a
+// file created with ioutil.TempFile and obeys the expiration semantics of that file.
+// The cache location is a function of the client and server versions so that the open API
+// schema will be cached separately for different client / server combinations.
+// Note, the cache will not be invalidated if the server changes its open API schema without
+// changing the server version.
+func (f *ring1Factory) OpenAPISchema(cacheDir string) (*openapi.Resources, error) {
+	discovery, err := f.clientAccessFactory.DiscoveryClient()
+	if err != nil {
+		return nil, err
+	}
+
+	// Lazily initialize the OpenAPIGetter once
+	f.openAPIGetter.once.Do(func() {
+		// Get the server version for caching the openapi spec
+		versionString := ""
+		version, err := discovery.ServerVersion()
+		if err != nil {
+			// Cache the result under the server version
+			versionString = version.String()
+		}
+
+		// Get the cache directory for caching the openapi spec
+		cacheDir, err = substituteUserHome(cacheDir)
+		if err != nil {
+			// Don't cache the result if we couldn't substitute the home directory
+			cacheDir = ""
+		}
+
+		// Create the caching OpenAPIGetter
+		f.openAPIGetter.getter = openapi.NewOpenAPIGetter(cacheDir, versionString, discovery)
+	})
+
+	// Delegate to the OpenAPIGetter
+	return f.openAPIGetter.getter.Get()
+}

pkg/kubectl/cmd/util/helpers.go

@@ -408,6 +408,15 @@ func AddValidateOptionFlags(cmd *cobra.Command, options *ValidateOptions) {
 	cmd.MarkFlagFilename("schema-cache-dir")
 }
 
+func AddOpenAPIFlags(cmd *cobra.Command) {
+	cmd.Flags().String("schema-cache-dir",
+		fmt.Sprintf("~/%s/%s", clientcmd.RecommendedHomeDir, clientcmd.RecommendedSchemaName),
+		fmt.Sprintf("If non-empty, load/store cached API schemas in this directory, default is '$HOME/%s/%s'",
+			clientcmd.RecommendedHomeDir, clientcmd.RecommendedSchemaName),
+	)
+	cmd.MarkFlagFilename("schema-cache-dir")
+}
+
 func AddFilenameOptionFlags(cmd *cobra.Command, options *resource.FilenameOptions, usage string) {
 	kubectl.AddJsonFilenameFlag(cmd, &options.Filenames, "Filename, directory, or URL to files "+usage)
 	cmd.Flags().BoolVarP(&options.Recursive, "recursive", "R", options.Recursive, "Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory.")

pkg/kubectl/cmd/util/openapi/BUILD

+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "openapi_cache_test.go",
+        "openapi_getter_test.go",
+        "openapi_test.go",
+    ],
+    library = ":go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/github.com/go-openapi/loads:go_default_library",
+        "//vendor/github.com/go-openapi/spec:go_default_library",
+        "//vendor/github.com/onsi/ginkgo:go_default_library",
+        "//vendor/github.com/onsi/gomega:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "openapi.go",
+        "openapi_cache.go",
+        "openapi_getter.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/version:go_default_library",
+        "//vendor/github.com/go-openapi/spec:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/client-go/discovery:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_xtest",
+    srcs = ["openapi_suite_test.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/github.com/onsi/ginkgo:go_default_library",
+        "//vendor/github.com/onsi/gomega:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

pkg/kubectl/cmd/util/openapi/doc.go

+/*
+Copyright 2017 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 is a collection of libraries for fetching the openapi spec
+// from a Kubernetes server and then indexing the type definitions.
+// The openapi spec contains the object model definitions and extensions metadata
+// such as the patchStrategy and patchMergeKey for creating patches.
+package openapi

pkg/kubectl/cmd/util/openapi/openapi_cache.go

+/*
+Copyright 2017 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 (
+	"bytes"
+	"encoding/gob"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/golang/glog"
+
+	"k8s.io/client-go/discovery"
+	"k8s.io/kubernetes/pkg/version"
+)
+
+func init() {
+	registerBinaryEncodingTypes()
+}
+
+const openapiFileName = "openapi_cache"
+
+type cachingOpenAPIClient struct {
+	version      string
+	client       discovery.OpenAPISchemaInterface
+	cacheDirName string
+}
+
+// newCachingOpenAPIClient returns a new discovery.OpenAPISchemaInterface
+// that will read the openapi spec from a local cache if it exists, and
+// if not will then fetch an openapi spec using a client.
+// client: used to fetch a new openapi spec if a local cache is not found
+// version: the server version and used as part of the cache file location
+// cacheDir: the directory under which the cache file will be written
+func newCachingOpenAPIClient(client discovery.OpenAPISchemaInterface, version, cacheDir string) *cachingOpenAPIClient {
+	return &cachingOpenAPIClient{
+		client:       client,
+		version:      version,
+		cacheDirName: cacheDir,
+	}
+}
+
+// openAPIData returns an openapi spec.
+// It will first attempt to read the spec from a local cache
+// If it cannot read a local cache, it will read the file
+// using the client and then write the cache.
+func (c *cachingOpenAPIClient) openAPIData() (*Resources, error) {
+	// Try to use the cached version
+	if c.useCache() {
+		doc, err := c.readOpenAPICache()
+		if err == nil {
+			return doc, nil
+		}
+	}
+
+	// No cached version found, download from server
+	s, err := c.client.OpenAPISchema()
+	if err != nil {
+		glog.V(2).Infof("Failed to download openapi data %v", err)
+		return nil, err
+	}
+
+	oa, err := newOpenAPIData(s)
+	if err != nil {
+		glog.V(2).Infof("Failed to parse openapi data %v", err)
+		return nil, err
+	}
+
+	// Try to cache the openapi spec
+	if c.useCache() {
+		err = c.writeToCache(oa)
+		if err != nil {
+			// Just log an message, no need to fail the command since we got the data we need
+			glog.V(2).Infof("Unable to cache openapi spec %v", err)
+		}
+	}
+
+	// Return the parsed data
+	return oa, nil
+}
+
+// useCache returns true if the client should try to use the cache file
+func (c *cachingOpenAPIClient) useCache() bool {
+	return len(c.version) > 0 && len(c.cacheDirName) > 0
+}
+
+// readOpenAPICache tries to read the openapi spec from the local file cache
+func (c *cachingOpenAPIClient) readOpenAPICache() (*Resources, error) {
+	// Get the filename to read
+	filename := c.openAPICacheFilename()
+
+	// Read the cached file
+	data, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	// Decode the openapi spec
+	s, err := c.decodeSpec(data)
+
+	return s, err
+}
+
+// decodeSpec binary decodes the openapi spec
+func (c *cachingOpenAPIClient) decodeSpec(data []byte) (*Resources, error) {
+	b := bytes.NewBuffer(data)
+	d := gob.NewDecoder(b)
+	parsed := &Resources{}
+	err := d.Decode(parsed)
+	return parsed, err
+}
+
+// encodeSpec binary encodes the openapi spec
+func (c *cachingOpenAPIClient) encodeSpec(parsed *Resources) ([]byte, error) {
+	b := &bytes.Buffer{}
+	e := gob.NewEncoder(b)
+	err := e.Encode(parsed)
+	return b.Bytes(), err
+
+}
+
+// writeToCache tries to write the openapi spec to the local file cache.
+// writes the data to a new tempfile, and then links the cache file and the tempfile
+func (c *cachingOpenAPIClient) writeToCache(parsed *Resources) error {
+	// Get the constant filename used to read the cache.
+	cacheFile := c.openAPICacheFilename()
+
+	// Binary encode the spec.  This is 10x as fast as using json encoding.  (60ms vs 600ms)
+	b, err := c.encodeSpec(parsed)
+	if err != nil {
+		return fmt.Errorf("Could not binary encode openapi spec: %v", err)
+	}
+
+	// Create a new temp file for the cached openapi spec.
+	cacheDir := filepath.Dir(cacheFile)
+	if err := os.MkdirAll(cacheDir, 0755); err != nil {
+		return fmt.Errorf("Could not create directory: %v %v", cacheDir, err)
+	}
+	tmpFile, err := ioutil.TempFile(cacheDir, "openapi")
+	if err != nil {
+		return fmt.Errorf("Could not create temp cache file: %v %v", cacheFile, err)
+	}
+
+	// Write the binary encoded openapi spec to the temp file
+	if _, err := io.Copy(tmpFile, bytes.NewBuffer(b)); err != nil {
+		return fmt.Errorf("Could not write temp cache file: %v", err)
+	}
+
+	// Link the temp cache file to the constant cache filepath
+	return linkFiles(tmpFile.Name(), cacheFile)
+}
+
+// openAPICacheFilename returns the filename to read the cache from
+func (c *cachingOpenAPIClient) openAPICacheFilename() string {
+	// Cache using the client and server versions
+	return filepath.Join(c.cacheDirName, c.version, version.Get().GitVersion, openapiFileName)
+}
+
+// linkFiles links the old file to the new file
+func linkFiles(old, new string) error {
+	if err := os.Link(old, new); err != nil {
+		// If we can't write due to file existing, or permission problems, keep going.
+		if os.IsExist(err) || os.IsPermission(err) {
+			return nil
+		}
+		return err
+	}
+	return nil
+}
+
+// registerBinaryEncodingTypes registers the types so they can be binary encoded by gob
+func registerBinaryEncodingTypes() {
+	gob.Register(map[string]interface{}{})
+	gob.Register([]interface{}{})
+	gob.Register(Resources{})
+}

pkg/kubectl/cmd/util/openapi/openapi_cache_test.go

+/*
+Copyright 2017 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"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sync"
+
+	"github.com/go-openapi/loads"
+	"github.com/go-openapi/spec"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("When reading openAPIData", func() {
+	var tmpDir string
+	var err error
+	var client *fakeOpenAPIClient
+	var instance *cachingOpenAPIClient
+	var expectedData *Resources
+
+	BeforeEach(func() {
+		tmpDir, err = ioutil.TempDir("", "openapi_cache_test")
+		Expect(err).To(BeNil())
+		client = &fakeOpenAPIClient{}
+		instance = newCachingOpenAPIClient(client, "v1.6", tmpDir)
+
+		d, err := data.OpenAPISchema()
+		Expect(err).To(BeNil())
+
+		expectedData, err = newOpenAPIData(d)
+		Expect(err).To(BeNil())
+	})
+
+	AfterEach(func() {
+		os.RemoveAll(tmpDir)
+	})
+
+	It("should write to the cache", func() {
+		By("getting the live openapi spec from the server")
+		result, err := instance.openAPIData()
+		Expect(err).To(BeNil())
+		expectEqual(result, expectedData)
+		Expect(client.calls).To(Equal(1))
+
+		By("writing the live openapi spec to a local cache file")
+		names, err := getFilenames(tmpDir)
+		Expect(err).To(BeNil())
+		Expect(names).To(ConsistOf("v1.6"))
+
+		names, err = getFilenames(filepath.Join(tmpDir, "v1.6"))
+		Expect(err).To(BeNil())
+		Expect(names).To(HaveLen(1))
+		clientVersion := names[0]
+
+		names, err = getFilenames(filepath.Join(tmpDir, "v1.6", clientVersion))
+		Expect(err).To(BeNil())
+		Expect(names).To(ContainElement("openapi_cache"))
+	})
+
+	It("should read from the cache", func() {
+		// First call should use the client
+		result, err := instance.openAPIData()
+		Expect(err).To(BeNil())
+		expectEqual(result, expectedData)
+		Expect(client.calls).To(Equal(1))
+
+		// Second call shouldn't use the client
+		result, err = instance.openAPIData()
+		Expect(err).To(BeNil())
+		expectEqual(result, expectedData)
+		Expect(client.calls).To(Equal(1))
+
+		names, err := getFilenames(tmpDir)
+		Expect(err).To(BeNil())
+		Expect(names).To(ConsistOf("v1.6"))
+	})
+
+	It("propagate errors that are encountered", func() {
+		// Expect an error
+		client.err = fmt.Errorf("expected error")
+		result, err := instance.openAPIData()
+		Expect(err.Error()).To(Equal(client.err.Error()))
+		Expect(result).To(BeNil())
+		Expect(client.calls).To(Equal(1))
+
+		// No cache file is written
+		files, err := ioutil.ReadDir(tmpDir)
+		Expect(err).To(BeNil())
+		Expect(files).To(HaveLen(0))
+
+		// Client error is not cached
+		result, err = instance.openAPIData()
+		Expect(err.Error()).To(Equal(client.err.Error()))
+		Expect(result).To(BeNil())
+		Expect(client.calls).To(Equal(2))
+	})
+})
+
+var _ = Describe("Reading openAPIData", func() {
+	var tmpDir string
+	var serverVersion string
+	var cacheDir string
+
+	BeforeEach(func() {
+		var err error
+		tmpDir, err = ioutil.TempDir("", "openapi_cache_test")
+		Expect(err).To(BeNil())
+	})
+
+	AfterEach(func() {
+		os.RemoveAll(tmpDir)
+	})
+
+	// Set the serverVersion to empty
+	Context("when the server version is empty", func() {
+		BeforeEach(func() {
+			serverVersion = ""
+			cacheDir = tmpDir
+		})
+		It("should not cache the result", func() {
+			client := &fakeOpenAPIClient{}
+
+			instance := newCachingOpenAPIClient(client, serverVersion, cacheDir)
+
+			d, err := data.OpenAPISchema()
+			Expect(err).To(BeNil())
+
+			expectedData, err := newOpenAPIData(d)
+			Expect(err).To(BeNil())
+
+			By("getting the live openapi schema")
+			result, err := instance.openAPIData()
+			Expect(err).To(BeNil())
+			expectEqual(result, expectedData)
+			Expect(client.calls).To(Equal(1))
+
+			files, err := ioutil.ReadDir(tmpDir)
+			Expect(err).To(BeNil())
+			Expect(files).To(HaveLen(0))
+		})
+	})
+
+	Context("when the cache directory is empty", func() {
+		BeforeEach(func() {
+			serverVersion = "v1.6"
+			cacheDir = ""
+		})
+		It("should not cache the result", func() {
+			client := &fakeOpenAPIClient{}
+
+			instance := newCachingOpenAPIClient(client, serverVersion, cacheDir)
+
+			d, err := data.OpenAPISchema()
+			Expect(err).To(BeNil())
+
+			expectedData, err := newOpenAPIData(d)
+			Expect(err).To(BeNil())
+
+			By("getting the live openapi schema")
+			result, err := instance.openAPIData()
+			Expect(err).To(BeNil())
+			expectEqual(result, expectedData)
+			Expect(client.calls).To(Equal(1))
+
+			files, err := ioutil.ReadDir(tmpDir)
+			Expect(err).To(BeNil())
+			Expect(files).To(HaveLen(0))
+		})
+	})
+})
+
+// Test Utils
+func getFilenames(path string) ([]string, error) {
+	files, err := ioutil.ReadDir(path)
+	if err != nil {
+		return nil, err
+	}
+	result := []string{}
+	for _, n := range files {
+		result = append(result, n.Name())
+	}
+	return result, nil
+}
+
+func expectEqual(a *Resources, b *Resources) {
+	Expect(a.NameToDefinition).To(HaveLen(len(b.NameToDefinition)))
+	for k, v := range a.NameToDefinition {
+		Expect(v).To(Equal(b.NameToDefinition[k]),
+			fmt.Sprintf("Names for GVK do not match %v", k))
+	}
+	Expect(a.GroupVersionKindToName).To(HaveLen(len(b.GroupVersionKindToName)))
+	for k, v := range a.GroupVersionKindToName {
+		Expect(v).To(Equal(b.GroupVersionKindToName[k]),
+			fmt.Sprintf("Values for name do not match %v", k))
+	}
+}
+
+type fakeOpenAPIClient struct {
+	calls int
+	err   error
+}
+
+func (f *fakeOpenAPIClient) OpenAPISchema() (*spec.Swagger, error) {
+	f.calls = f.calls + 1
+
+	if f.err != nil {
+		return nil, f.err
+	}
+
+	return data.OpenAPISchema()
+}
+
+// Test utils
+var data apiData
+
+type apiData struct {
+	sync.Once
+	data *spec.Swagger
+	err  error
+}
+
+func (d *apiData) OpenAPISchema() (*spec.Swagger, error) {
+	d.Do(func() {
+		// Get the path to the swagger.json file
+		wd, err := os.Getwd()
+		if err != nil {
+			d.err = err
+			return
+		}
+
+		abs, err := filepath.Abs(wd)
+		if err != nil {
+			d.err = err
+			return
+		}
+
+		root := filepath.Dir(filepath.Dir(filepath.Dir(filepath.Dir(filepath.Dir(abs)))))
+		specpath := filepath.Join(root, "api", "openapi-spec", "swagger.json")
+		_, err = os.Stat(specpath)
+		if err != nil {
+			d.err = err
+			return
+		}
+		// Load the openapi document
+		doc, err := loads.Spec(specpath)
+		if err != nil {
+			d.err = err
+			return
+		}
+
+		d.data = doc.Spec()
+	})
+	return d.data, d.err
+}

pkg/kubectl/cmd/util/openapi/openapi_getter.go

+/*
+Copyright 2017 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 (
+	"sync"
+
+	"k8s.io/client-go/discovery"
+)
+
+// synchronizedOpenAPIGetter fetches the openapi schema once and then caches it in memory
+type synchronizedOpenAPIGetter struct {
+	// Cached results
+	sync.Once
+	openAPISchema *Resources
+	err           error
+
+	serverVersion string
+	cacheDir      string
+	openAPIClient discovery.OpenAPISchemaInterface
+}
+
+var _ Getter = &synchronizedOpenAPIGetter{}
+
+// Getter is an interface for fetching openapi specs and parsing them into an Resources struct
+type Getter interface {
+	// openAPIData returns the parsed openAPIData
+	Get() (*Resources, error)
+}
+
+// NewOpenAPIGetter returns an object to return OpenAPIDatas which either read from a
+// local file cache or read from a server, and then stored in memory for subsequent invocations
+func NewOpenAPIGetter(cacheDir, serverVersion string, openAPIClient discovery.OpenAPISchemaInterface) Getter {
+	return &synchronizedOpenAPIGetter{
+		serverVersion: serverVersion,
+		cacheDir:      cacheDir,
+		openAPIClient: openAPIClient,
+	}
+}
+
+// Resources implements Getter
+func (g *synchronizedOpenAPIGetter) Get() (*Resources, error) {
+	g.Do(func() {
+		client := newCachingOpenAPIClient(g.openAPIClient, g.serverVersion, g.cacheDir)
+		result, err := client.openAPIData()
+		if err != nil {
+			g.err = err
+			return
+		}
+
+		// Save the result
+		g.openAPISchema = result
+	})
+
+	// Return the save result
+	return g.openAPISchema, g.err
+}

pkg/kubectl/cmd/util/openapi/openapi_getter_test.go

+/*
+Copyright 2017 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"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Getting the Resources", func() {
+	var client *fakeOpenAPIClient
+	var expectedData *Resources
+	var instance Getter
+
+	BeforeEach(func() {
+		client = &fakeOpenAPIClient{}
+		d, err := data.OpenAPISchema()
+		Expect(err).To(BeNil())
+
+		expectedData, err = newOpenAPIData(d)
+		Expect(err).To(BeNil())
+
+		instance = NewOpenAPIGetter("", "", client)
+	})
+
+	Context("when the server returns a successful result", func() {
+		It("should return the same data for multiple calls", func() {
+			Expect(client.calls).To(Equal(0))
+
+			result, err := instance.Get()
+			Expect(err).To(BeNil())
+			expectEqual(result, expectedData)
+			Expect(client.calls).To(Equal(1))
+
+			result, err = instance.Get()
+			Expect(err).To(BeNil())
+			expectEqual(result, expectedData)
+			// No additional client calls expected
+			Expect(client.calls).To(Equal(1))
+		})
+	})
+
+	Context("when the server returns an unsuccessful result", func() {
+		It("should return the same instance for multiple calls.", func() {
+			Expect(client.calls).To(Equal(0))
+
+			client.err = fmt.Errorf("expected error")
+			_, err := instance.Get()
+			Expect(err).To(Equal(client.err))
+			Expect(client.calls).To(Equal(1))
+
+			_, err = instance.Get()
+			Expect(err).To(Equal(client.err))
+			// No additional client calls expected
+			Expect(client.calls).To(Equal(1))
+		})
+	})
+})

pkg/kubectl/cmd/util/openapi/openapi_suite_test.go

+/*
+Copyright 2017 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_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"testing"
+)
+
+func TestOpenapi(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Openapi Suite")
+}

staging/src/k8s.io/apiserver/Godeps/Godeps.json

@@ -335,6 +335,10 @@
 			"Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee"
 		},
 		{
+			"ImportPath": "github.com/go-openapi/analysis",
+			"Rev": "b44dc874b601d9e4e2f6e19140e794ba24bead3b"
+		},
+		{
 			"ImportPath": "github.com/go-openapi/jsonpointer",
 			"Rev": "46af16f9f7b149af66e5d1bd010e3574dc06de98"
 		},
@@ -343,6 +347,10 @@
 			"Rev": "13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272"
 		},
 		{
+			"ImportPath": "github.com/go-openapi/loads",
+			"Rev": "18441dfa706d924a39a030ee2c3b1d8d81917b38"
+		},
+		{
 			"ImportPath": "github.com/go-openapi/spec",
 			"Rev": "6aced65f8501fe1217321abf0749d354824ba2ff"
 		},

staging/src/k8s.io/client-go/Godeps/Godeps.json

@@ -83,6 +83,10 @@
 			"Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee"
 		},
 		{
+			"ImportPath": "github.com/go-openapi/analysis",
+			"Rev": "b44dc874b601d9e4e2f6e19140e794ba24bead3b"
+		},
+		{
 			"ImportPath": "github.com/go-openapi/jsonpointer",
 			"Rev": "46af16f9f7b149af66e5d1bd010e3574dc06de98"
 		},
@@ -91,6 +95,10 @@
 			"Rev": "13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272"
 		},
 		{
+			"ImportPath": "github.com/go-openapi/loads",
+			"Rev": "18441dfa706d924a39a030ee2c3b1d8d81917b38"
+		},
+		{
 			"ImportPath": "github.com/go-openapi/spec",
 			"Rev": "6aced65f8501fe1217321abf0749d354824ba2ff"
 		},

staging/src/k8s.io/client-go/discovery/BUILD

@@ -19,6 +19,8 @@ go_library(
     tags = ["automanaged"],
     deps = [
         "//vendor/github.com/emicklei/go-restful/swagger:go_default_library",
+        "//vendor/github.com/go-openapi/loads:go_default_library",
+        "//vendor/github.com/go-openapi/spec:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
@@ -44,6 +46,7 @@ go_test(
     tags = ["automanaged"],
     deps = [
         "//vendor/github.com/emicklei/go-restful/swagger:go_default_library",
+        "//vendor/github.com/go-openapi/spec:go_default_library",
         "//vendor/github.com/stretchr/testify/assert:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",

staging/src/k8s.io/client-go/discovery/discovery_client.go

@@ -25,6 +25,8 @@ import (
 
 	"github.com/emicklei/go-restful/swagger"
 
+	"github.com/go-openapi/loads"
+	"github.com/go-openapi/spec"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -47,6 +49,7 @@ type DiscoveryInterface interface {
 	ServerResourcesInterface
 	ServerVersionInterface
 	SwaggerSchemaInterface
+	OpenAPISchemaInterface
 }
 
 // CachedDiscoveryInterface is a DiscoveryInterface with cache invalidation and freshness.
@@ -91,6 +94,12 @@ type SwaggerSchemaInterface interface {
 	SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error)
 }
 
+// OpenAPISchemaInterface has a method to retrieve the open API schema.
+type OpenAPISchemaInterface interface {
+	// OpenAPISchema retrieves and parses the swagger API schema the server supports.
+	OpenAPISchema() (*spec.Swagger, error)
+}
+
 // DiscoveryClient implements the functions that discover server-supported API groups,
 // versions and resources.
 type DiscoveryClient struct {
@@ -332,6 +341,7 @@ func (d *DiscoveryClient) ServerVersion() (*version.Info, error) {
 }
 
 // SwaggerSchema retrieves and parses the swagger API schema the server supports.
+// TODO: Replace usages with Open API.  Tracked in https://github.com/kubernetes/kubernetes/issues/44589
 func (d *DiscoveryClient) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
 	if version.Empty() {
 		return nil, fmt.Errorf("groupVersion cannot be empty")
@@ -365,6 +375,21 @@ func (d *DiscoveryClient) SwaggerSchema(version schema.GroupVersion) (*swagger.A
 	return &schema, nil
 }
 
+// OpenAPISchema fetches the open api schema using a rest client and parses the json.
+// Warning: this is very expensive (~1.2s)
+func (d *DiscoveryClient) OpenAPISchema() (*spec.Swagger, error) {
+	data, err := d.restClient.Get().AbsPath("/swagger.json").Do().Raw()
+	if err != nil {
+		return nil, err
+	}
+	msg := json.RawMessage(data)
+	doc, err := loads.Analyzed(msg, "")
+	if err != nil {
+		return nil, err
+	}
+	return doc.Spec(), err
+}
+
 // withRetries retries the given recovery function in case the groups supported by the server change after ServerGroup() returns.
 func withRetries(maxRetries int, f func(failEarly bool) ([]*metav1.APIResourceList, error)) ([]*metav1.APIResourceList, error) {
 	var result []*metav1.APIResourceList

staging/src/k8s.io/client-go/discovery/discovery_client_test.go

@@ -18,6 +18,7 @@ package discovery_test
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"reflect"
@@ -25,6 +26,7 @@ import (
 
 	"github.com/emicklei/go-restful/swagger"
 
+	"github.com/go-openapi/spec"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/sets"
@@ -325,6 +327,81 @@ func TestGetSwaggerSchemaFail(t *testing.T) {
 	}
 }
 
+var returnedOpenAPI = spec.Swagger{
+	SwaggerProps: spec.SwaggerProps{
+		Definitions: spec.Definitions{
+			"fake.type.1": spec.Schema{
+				SchemaProps: spec.SchemaProps{
+					Properties: map[string]spec.Schema{
+						"count": {
+							SchemaProps: spec.SchemaProps{
+								Type: []string{"integer"},
+							},
+						},
+					},
+				},
+			},
+			"fake.type.2": spec.Schema{
+				SchemaProps: spec.SchemaProps{
+					Properties: map[string]spec.Schema{
+						"count": {
+							SchemaProps: spec.SchemaProps{
+								Type: []string{"array"},
+								Items: &spec.SchemaOrArray{
+									Schema: &spec.Schema{
+										SchemaProps: spec.SchemaProps{
+											Type: []string{"string"},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	},
+}
+
+func openapiSchemaFakeServer() (*httptest.Server, error) {
+	var sErr error
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		if req.URL.Path != "/swagger.json" {
+			sErr = fmt.Errorf("Unexpected url %v", req.URL)
+		}
+		if req.Method != "GET" {
+			sErr = fmt.Errorf("Unexpected method %v", req.Method)
+		}
+
+		output, err := json.Marshal(returnedOpenAPI)
+		if err != nil {
+			sErr = err
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		w.Write(output)
+	}))
+	return server, sErr
+}
+
+func TestGetOpenAPISchema(t *testing.T) {
+	server, err := openapiSchemaFakeServer()
+	if err != nil {
+		t.Errorf("unexpected error starting fake server: %v", err)
+	}
+	defer server.Close()
+
+	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+	got, err := client.OpenAPISchema()
+	if err != nil {
+		t.Fatalf("unexpected error getting openapi: %v", err)
+	}
+	if e, a := returnedOpenAPI, *got; !reflect.DeepEqual(e, a) {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+}
+
 func TestServerPreferredResources(t *testing.T) {
 	stable := metav1.APIResourceList{
 		GroupVersion: "v1",

staging/src/k8s.io/client-go/discovery/fake/BUILD

@@ -13,6 +13,7 @@ go_library(
     tags = ["automanaged"],
     deps = [
         "//vendor/github.com/emicklei/go-restful/swagger:go_default_library",
+        "//vendor/github.com/go-openapi/spec:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/version:go_default_library",

staging/src/k8s.io/client-go/discovery/fake/discovery.go

@@ -21,6 +21,7 @@ import (
 
 	"github.com/emicklei/go-restful/swagger"
 
+	"github.com/go-openapi/spec"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/version"
@@ -92,6 +93,8 @@ func (c *FakeDiscovery) SwaggerSchema(version schema.GroupVersion) (*swagger.Api
 	return &swagger.ApiDeclaration{}, nil
 }
 
+func (c *FakeDiscovery) OpenAPISchema() (*spec.Swagger, error) { return &spec.Swagger{}, nil }
+
 func (c *FakeDiscovery) RESTClient() restclient.Interface {
 	return nil
 }

staging/src/k8s.io/client-go/discovery/restmapper_test.go

@@ -30,6 +30,7 @@ import (
 	"k8s.io/client-go/rest/fake"
 
 	"github.com/emicklei/go-restful/swagger"
+	"github.com/go-openapi/spec"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -347,3 +348,7 @@ func (c *fakeCachedDiscoveryInterface) ServerVersion() (*version.Info, error) {
 func (c *fakeCachedDiscoveryInterface) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
 	return &swagger.ApiDeclaration{}, nil
 }
+
+func (c *fakeCachedDiscoveryInterface) OpenAPISchema() (*spec.Swagger, error) {
+	return &spec.Swagger{}, nil
+}

staging/src/k8s.io/kube-aggregator/Godeps/Godeps.json

@@ -123,6 +123,10 @@
 			"Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee"
 		},
 		{
+			"ImportPath": "github.com/go-openapi/analysis",
+			"Rev": "b44dc874b601d9e4e2f6e19140e794ba24bead3b"
+		},
+		{
 			"ImportPath": "github.com/go-openapi/jsonpointer",
 			"Rev": "46af16f9f7b149af66e5d1bd010e3574dc06de98"
 		},
@@ -131,6 +135,10 @@
 			"Rev": "13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272"
 		},
 		{
+			"ImportPath": "github.com/go-openapi/loads",
+			"Rev": "18441dfa706d924a39a030ee2c3b1d8d81917b38"
+		},
+		{
 			"ImportPath": "github.com/go-openapi/spec",
 			"Rev": "6aced65f8501fe1217321abf0749d354824ba2ff"
 		},