refact(deps): bump k8s and client-go deps to version v0.20.2 (#294)

Signed-off-by: prateekpandey14 <prateek.pandey@mayadata.io>

vendor/k8s.io/kube-openapi/pkg/util/proto/document.go

@@ -21,7 +21,7 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/googleapis/gnostic/OpenAPIv2"
+	openapi_v2 "github.com/googleapis/gnostic/openapiv2"
 	"gopkg.in/yaml.v2"
 )
 
@@ -109,19 +109,39 @@ func (d *Definitions) parseReference(s *openapi_v2.Schema, path *Path) (Schema,
 	if _, ok := d.models[reference]; !ok {
 		return nil, newSchemaError(path, "unknown model in reference: %q", reference)
 	}
+	base, err := d.parseBaseSchema(s, path)
+	if err != nil {
+		return nil, err
+	}
 	return &Ref{
-		BaseSchema:  d.parseBaseSchema(s, path),
+		BaseSchema:  base,
 		reference:   reference,
 		definitions: d,
 	}, nil
 }
 
-func (d *Definitions) parseBaseSchema(s *openapi_v2.Schema, path *Path) BaseSchema {
+func parseDefault(def *openapi_v2.Any) (interface{}, error) {
+	if def == nil {
+		return nil, nil
+	}
+	var i interface{}
+	if err := yaml.Unmarshal([]byte(def.Yaml), &i); err != nil {
+		return nil, err
+	}
+	return i, nil
+}
+
+func (d *Definitions) parseBaseSchema(s *openapi_v2.Schema, path *Path) (BaseSchema, error) {
+	def, err := parseDefault(s.GetDefault())
+	if err != nil {
+		return BaseSchema{}, err
+	}
 	return BaseSchema{
 		Description: s.GetDescription(),
+		Default:     def,
 		Extensions:  VendorExtensionToMap(s.GetVendorExtension()),
 		Path:        *path,
-	}
+	}, nil
 }
 
 // We believe the schema is a map, verify and return a new schema
@@ -132,8 +152,12 @@ func (d *Definitions) parseMap(s *openapi_v2.Schema, path *Path) (Schema, error)
 	var sub Schema
 	// TODO(incomplete): this misses the boolean case as AdditionalProperties is a bool+schema sum type.
 	if s.GetAdditionalProperties().GetSchema() == nil {
+		base, err := d.parseBaseSchema(s, path)
+		if err != nil {
+			return nil, err
+		}
 		sub = &Arbitrary{
-			BaseSchema: d.parseBaseSchema(s, path),
+			BaseSchema: base,
 		}
 	} else {
 		var err error
@@ -142,8 +166,12 @@ func (d *Definitions) parseMap(s *openapi_v2.Schema, path *Path) (Schema, error)
 			return nil, err
 		}
 	}
+	base, err := d.parseBaseSchema(s, path)
+	if err != nil {
+		return nil, err
+	}
 	return &Map{
-		BaseSchema: d.parseBaseSchema(s, path),
+		BaseSchema: base,
 		SubType:    sub,
 	}, nil
 }
@@ -165,8 +193,12 @@ func (d *Definitions) parsePrimitive(s *openapi_v2.Schema, path *Path) (Schema,
 	default:
 		return nil, newSchemaError(path, "Unknown primitive type: %q", t)
 	}
+	base, err := d.parseBaseSchema(s, path)
+	if err != nil {
+		return nil, err
+	}
 	return &Primitive{
-		BaseSchema: d.parseBaseSchema(s, path),
+		BaseSchema: base,
 		Type:       t,
 		Format:     s.GetFormat(),
 	}, nil
@@ -188,8 +220,12 @@ func (d *Definitions) parseArray(s *openapi_v2.Schema, path *Path) (Schema, erro
 	if err != nil {
 		return nil, err
 	}
+	base, err := d.parseBaseSchema(s, path)
+	if err != nil {
+		return nil, err
+	}
 	return &Array{
-		BaseSchema: d.parseBaseSchema(s, path),
+		BaseSchema: base,
 		SubType:    sub,
 	}, nil
 }
@@ -216,8 +252,12 @@ func (d *Definitions) parseKind(s *openapi_v2.Schema, path *Path) (Schema, error
 		fieldOrder = append(fieldOrder, name)
 	}
 
+	base, err := d.parseBaseSchema(s, path)
+	if err != nil {
+		return nil, err
+	}
 	return &Kind{
-		BaseSchema:     d.parseBaseSchema(s, path),
+		BaseSchema:     base,
 		RequiredFields: s.GetRequired(),
 		Fields:         fields,
 		FieldOrder:     fieldOrder,
@@ -225,8 +265,12 @@ func (d *Definitions) parseKind(s *openapi_v2.Schema, path *Path) (Schema, error
 }
 
 func (d *Definitions) parseArbitrary(s *openapi_v2.Schema, path *Path) (Schema, error) {
+	base, err := d.parseBaseSchema(s, path)
+	if err != nil {
+		return nil, err
+	}
 	return &Arbitrary{
-		BaseSchema: d.parseBaseSchema(s, path),
+		BaseSchema: base,
 	}, nil
 }
 

vendor/k8s.io/kube-openapi/pkg/util/proto/openapi.go

@@ -77,6 +77,8 @@ type Schema interface {
 	GetPath() *Path
 	// Describes the field.
 	GetDescription() string
+	// Default for that schema.
+	GetDefault() interface{}
 	// Returns type extensions.
 	GetExtensions() map[string]interface{}
 }
@@ -129,6 +131,7 @@ func (p *Path) FieldPath(field string) Path {
 type BaseSchema struct {
 	Description string
 	Extensions  map[string]interface{}
+	Default     interface{}
 
 	Path Path
 }
@@ -141,6 +144,10 @@ func (b *BaseSchema) GetExtensions() map[string]interface{} {
 	return b.Extensions
 }
 
+func (b *BaseSchema) GetDefault() interface{} {
+	return b.Default
+}
+
 func (b *BaseSchema) GetPath() *Path {
 	return &b.Path
 }

vendor/k8s.io/kube-openapi/pkg/util/sets/empty.go

@@ -0,0 +1,27 @@
+/*
+Copyright 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.
+*/
+
+// Code generated by set-gen. DO NOT EDIT.
+
+// NOTE: This file is copied from k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/util/sets/empty.go
+// because in Kubernetes we don't allowed vendor code to import staging code. See
+// https://github.com/kubernetes/kube-openapi/pull/90 for more details.
+
+package sets
+
+// Empty is public since it is used by some internal API objects for conversions between external
+// string arrays and internal sets, and conversion logic requires public types today.
+type Empty struct{}

vendor/k8s.io/kube-openapi/pkg/util/sets/string.go

@@ -0,0 +1,207 @@
+/*
+Copyright 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.
+*/
+
+// Code generated by set-gen. DO NOT EDIT.
+
+// NOTE: This file is copied from k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/util/sets/string.go
+// because in Kubernetes we don't allowed vendor code to import staging code. See
+// https://github.com/kubernetes/kube-openapi/pull/90 for more details.
+
+package sets
+
+import (
+	"reflect"
+	"sort"
+)
+
+// sets.String is a set of strings, implemented via map[string]struct{} for minimal memory consumption.
+type String map[string]Empty
+
+// NewString creates a String from a list of values.
+func NewString(items ...string) String {
+	ss := String{}
+	ss.Insert(items...)
+	return ss
+}
+
+// StringKeySet creates a String from a keys of a map[string](? extends interface{}).
+// If the value passed in is not actually a map, this will panic.
+func StringKeySet(theMap interface{}) String {
+	v := reflect.ValueOf(theMap)
+	ret := String{}
+
+	for _, keyValue := range v.MapKeys() {
+		ret.Insert(keyValue.Interface().(string))
+	}
+	return ret
+}
+
+// Insert adds items to the set.
+func (s String) Insert(items ...string) {
+	for _, item := range items {
+		s[item] = Empty{}
+	}
+}
+
+// Delete removes all items from the set.
+func (s String) Delete(items ...string) {
+	for _, item := range items {
+		delete(s, item)
+	}
+}
+
+// Has returns true if and only if item is contained in the set.
+func (s String) Has(item string) bool {
+	_, contained := s[item]
+	return contained
+}
+
+// HasAll returns true if and only if all items are contained in the set.
+func (s String) HasAll(items ...string) bool {
+	for _, item := range items {
+		if !s.Has(item) {
+			return false
+		}
+	}
+	return true
+}
+
+// HasAny returns true if any items are contained in the set.
+func (s String) HasAny(items ...string) bool {
+	for _, item := range items {
+		if s.Has(item) {
+			return true
+		}
+	}
+	return false
+}
+
+// Difference returns a set of objects that are not in s2
+// For example:
+// s1 = {a1, a2, a3}
+// s2 = {a1, a2, a4, a5}
+// s1.Difference(s2) = {a3}
+// s2.Difference(s1) = {a4, a5}
+func (s String) Difference(s2 String) String {
+	result := NewString()
+	for key := range s {
+		if !s2.Has(key) {
+			result.Insert(key)
+		}
+	}
+	return result
+}
+
+// Union returns a new set which includes items in either s1 or s2.
+// For example:
+// s1 = {a1, a2}
+// s2 = {a3, a4}
+// s1.Union(s2) = {a1, a2, a3, a4}
+// s2.Union(s1) = {a1, a2, a3, a4}
+func (s1 String) Union(s2 String) String {
+	result := NewString()
+	for key := range s1 {
+		result.Insert(key)
+	}
+	for key := range s2 {
+		result.Insert(key)
+	}
+	return result
+}
+
+// Intersection returns a new set which includes the item in BOTH s1 and s2
+// For example:
+// s1 = {a1, a2}
+// s2 = {a2, a3}
+// s1.Intersection(s2) = {a2}
+func (s1 String) Intersection(s2 String) String {
+	var walk, other String
+	result := NewString()
+	if s1.Len() < s2.Len() {
+		walk = s1
+		other = s2
+	} else {
+		walk = s2
+		other = s1
+	}
+	for key := range walk {
+		if other.Has(key) {
+			result.Insert(key)
+		}
+	}
+	return result
+}
+
+// IsSuperset returns true if and only if s1 is a superset of s2.
+func (s1 String) IsSuperset(s2 String) bool {
+	for item := range s2 {
+		if !s1.Has(item) {
+			return false
+		}
+	}
+	return true
+}
+
+// Equal returns true if and only if s1 is equal (as a set) to s2.
+// Two sets are equal if their membership is identical.
+// (In practice, this means same elements, order doesn't matter)
+func (s1 String) Equal(s2 String) bool {
+	return len(s1) == len(s2) && s1.IsSuperset(s2)
+}
+
+type sortableSliceOfString []string
+
+func (s sortableSliceOfString) Len() int           { return len(s) }
+func (s sortableSliceOfString) Less(i, j int) bool { return lessString(s[i], s[j]) }
+func (s sortableSliceOfString) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+// List returns the contents as a sorted string slice.
+func (s String) List() []string {
+	res := make(sortableSliceOfString, 0, len(s))
+	for key := range s {
+		res = append(res, key)
+	}
+	sort.Sort(res)
+	return []string(res)
+}
+
+// UnsortedList returns the slice with contents in random order.
+func (s String) UnsortedList() []string {
+	res := make([]string, 0, len(s))
+	for key := range s {
+		res = append(res, key)
+	}
+	return res
+}
+
+// Returns a single element from the set.
+func (s String) PopAny() (string, bool) {
+	for key := range s {
+		s.Delete(key)
+		return key, true
+	}
+	var zeroValue string
+	return zeroValue, false
+}
+
+// Len returns the size of the set.
+func (s String) Len() int {
+	return len(s)
+}
+
+func lessString(lhs, rhs string) bool {
+	return lhs < rhs
+}