Update vendor

vendor/k8s.io/kubectl/pkg/util/openapi/OWNERS

@@ -0,0 +1,6 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- apelisse
+reviewers:
+- apelisse

vendor/k8s.io/kubectl/pkg/util/openapi/doc.go

@@ -0,0 +1,21 @@
+/*
+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 // k8s.io/kubectl/pkg/util/openapi

vendor/k8s.io/kubectl/pkg/util/openapi/extensions.go

@@ -0,0 +1,27 @@
+/*
+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 "github.com/go-openapi/spec"
+
+// PrintColumnsKey is the key that defines which columns should be printed
+const PrintColumnsKey = "x-kubernetes-print-columns"
+
+// GetPrintColumns looks for the open API extension for the display columns.
+func GetPrintColumns(extensions spec.Extensions) (string, bool) {
+	return extensions.GetString(PrintColumnsKey)
+}

vendor/k8s.io/kubectl/pkg/util/openapi/openapi.go

@@ -0,0 +1,128 @@
+/*
+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 (
+	openapi_v2 "github.com/googleapis/gnostic/OpenAPIv2"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kube-openapi/pkg/util/proto"
+)
+
+// Resources interface describe a resources provider, that can give you
+// resource based on group-version-kind.
+type Resources interface {
+	LookupResource(gvk schema.GroupVersionKind) proto.Schema
+}
+
+// groupVersionKindExtensionKey is the key used to lookup the
+// GroupVersionKind value for an object definition from the
+// definition's "extensions" map.
+const groupVersionKindExtensionKey = "x-kubernetes-group-version-kind"
+
+// document is an implementation of `Resources`. It looks for
+// resources in an openapi Schema.
+type document struct {
+	// Maps gvk to model name
+	resources map[schema.GroupVersionKind]string
+	models    proto.Models
+}
+
+var _ Resources = &document{}
+
+// NewOpenAPIData creates a new `Resources` out of the openapi document
+func NewOpenAPIData(doc *openapi_v2.Document) (Resources, error) {
+	models, err := proto.NewOpenAPIData(doc)
+	if err != nil {
+		return nil, err
+	}
+
+	resources := map[schema.GroupVersionKind]string{}
+	for _, modelName := range models.ListModels() {
+		model := models.LookupModel(modelName)
+		if model == nil {
+			panic("ListModels returns a model that can't be looked-up.")
+		}
+		gvkList := parseGroupVersionKind(model)
+		for _, gvk := range gvkList {
+			if len(gvk.Kind) > 0 {
+				resources[gvk] = modelName
+			}
+		}
+	}
+
+	return &document{
+		resources: resources,
+		models:    models,
+	}, nil
+}
+
+func (d *document) LookupResource(gvk schema.GroupVersionKind) proto.Schema {
+	modelName, found := d.resources[gvk]
+	if !found {
+		return nil
+	}
+	return d.models.LookupModel(modelName)
+}
+
+// Get and parse GroupVersionKind from the extension. Returns empty if it doesn't have one.
+func parseGroupVersionKind(s proto.Schema) []schema.GroupVersionKind {
+	extensions := s.GetExtensions()
+
+	gvkListResult := []schema.GroupVersionKind{}
+
+	// Get the extensions
+	gvkExtension, ok := extensions[groupVersionKindExtensionKey]
+	if !ok {
+		return []schema.GroupVersionKind{}
+	}
+
+	// gvk extension must be a list of at least 1 element.
+	gvkList, ok := gvkExtension.([]interface{})
+	if !ok {
+		return []schema.GroupVersionKind{}
+	}
+
+	for _, gvk := range gvkList {
+		// gvk extension list must be a map with group, version, and
+		// kind fields
+		gvkMap, ok := gvk.(map[interface{}]interface{})
+		if !ok {
+			continue
+		}
+		group, ok := gvkMap["group"].(string)
+		if !ok {
+			continue
+		}
+		version, ok := gvkMap["version"].(string)
+		if !ok {
+			continue
+		}
+		kind, ok := gvkMap["kind"].(string)
+		if !ok {
+			continue
+		}
+
+		gvkListResult = append(gvkListResult, schema.GroupVersionKind{
+			Group:   group,
+			Version: version,
+			Kind:    kind,
+		})
+	}
+
+	return gvkListResult
+}

vendor/k8s.io/kubectl/pkg/util/openapi/openapi_getter.go

@@ -0,0 +1,65 @@
+/*
+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
+
+	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 reads
+// from a server, and then stores in memory for subsequent invocations
+func NewOpenAPIGetter(openAPIClient discovery.OpenAPISchemaInterface) Getter {
+	return &synchronizedOpenAPIGetter{
+		openAPIClient: openAPIClient,
+	}
+}
+
+// Resources implements Getter
+func (g *synchronizedOpenAPIGetter) Get() (Resources, error) {
+	g.Do(func() {
+		s, err := g.openAPIClient.OpenAPISchema()
+		if err != nil {
+			g.err = err
+			return
+		}
+
+		g.openAPISchema, g.err = NewOpenAPIData(s)
+	})
+
+	// Return the save result
+	return g.openAPISchema, g.err
+}

vendor/k8s.io/kubectl/pkg/util/openapi/validation/validation.go

@@ -0,0 +1,140 @@
+/*
+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 validation
+
+import (
+	"errors"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	utilerrors "k8s.io/apimachinery/pkg/util/errors"
+	"k8s.io/apimachinery/pkg/util/json"
+	"k8s.io/apimachinery/pkg/util/yaml"
+	"k8s.io/kube-openapi/pkg/util/proto/validation"
+	"k8s.io/kubectl/pkg/util/openapi"
+)
+
+// SchemaValidation validates the object against an OpenAPI schema.
+type SchemaValidation struct {
+	resources openapi.Resources
+}
+
+// NewSchemaValidation creates a new SchemaValidation that can be used
+// to validate objects.
+func NewSchemaValidation(resources openapi.Resources) *SchemaValidation {
+	return &SchemaValidation{
+		resources: resources,
+	}
+}
+
+// ValidateBytes will validates the object against using the Resources
+// object.
+func (v *SchemaValidation) ValidateBytes(data []byte) error {
+	obj, err := parse(data)
+	if err != nil {
+		return err
+	}
+
+	gvk, errs := getObjectKind(obj)
+	if errs != nil {
+		return utilerrors.NewAggregate(errs)
+	}
+
+	if (gvk == schema.GroupVersionKind{Version: "v1", Kind: "List"}) {
+		return utilerrors.NewAggregate(v.validateList(obj))
+	}
+
+	return utilerrors.NewAggregate(v.validateResource(obj, gvk))
+}
+
+func (v *SchemaValidation) validateList(object interface{}) []error {
+	fields, ok := object.(map[string]interface{})
+	if !ok || fields == nil {
+		return []error{errors.New("invalid object to validate")}
+	}
+
+	allErrors := []error{}
+	if _, ok := fields["items"].([]interface{}); !ok {
+		return []error{errors.New("invalid object to validate")}
+	}
+	for _, item := range fields["items"].([]interface{}) {
+		if gvk, errs := getObjectKind(item); errs != nil {
+			allErrors = append(allErrors, errs...)
+		} else {
+			allErrors = append(allErrors, v.validateResource(item, gvk)...)
+		}
+	}
+	return allErrors
+}
+
+func (v *SchemaValidation) validateResource(obj interface{}, gvk schema.GroupVersionKind) []error {
+	resource := v.resources.LookupResource(gvk)
+	if resource == nil {
+		// resource is not present, let's just skip validation.
+		return nil
+	}
+
+	return validation.ValidateModel(obj, resource, gvk.Kind)
+}
+
+func parse(data []byte) (interface{}, error) {
+	var obj interface{}
+	out, err := yaml.ToJSON(data)
+	if err != nil {
+		return nil, err
+	}
+	if err := json.Unmarshal(out, &obj); err != nil {
+		return nil, err
+	}
+	return obj, nil
+}
+
+func getObjectKind(object interface{}) (schema.GroupVersionKind, []error) {
+	var listErrors []error
+	fields, ok := object.(map[string]interface{})
+	if !ok || fields == nil {
+		listErrors = append(listErrors, errors.New("invalid object to validate"))
+		return schema.GroupVersionKind{}, listErrors
+	}
+
+	var group string
+	var version string
+	apiVersion := fields["apiVersion"]
+	if apiVersion == nil {
+		listErrors = append(listErrors, errors.New("apiVersion not set"))
+	} else if _, ok := apiVersion.(string); !ok {
+		listErrors = append(listErrors, errors.New("apiVersion isn't string type"))
+	} else {
+		gv, err := schema.ParseGroupVersion(apiVersion.(string))
+		if err != nil {
+			listErrors = append(listErrors, err)
+		} else {
+			group = gv.Group
+			version = gv.Version
+		}
+	}
+	kind := fields["kind"]
+	if kind == nil {
+		listErrors = append(listErrors, errors.New("kind not set"))
+	} else if _, ok := kind.(string); !ok {
+		listErrors = append(listErrors, errors.New("kind isn't string type"))
+	}
+	if listErrors != nil {
+		return schema.GroupVersionKind{}, listErrors
+	}
+
+	return schema.GroupVersionKind{Group: group, Version: version, Kind: kind.(string)}, nil
+}