bump(k8s.io/kube-openapi)

vendor/sigs.k8s.io/structured-merge-diff/v4/schema/elements.go

@@ -196,6 +196,8 @@ type StructField struct {
 	Name string `yaml:"name,omitempty"`
 	// Type is the field type.
 	Type TypeRef `yaml:"type,omitempty"`
+	// Default value for the field, nil if not present.
+	Default interface{} `yaml:"default,omitempty"`
 }
 
 // List represents a type which contains a zero or more elements, all of the

vendor/sigs.k8s.io/structured-merge-diff/v4/schema/equals.go

@@ -16,6 +16,8 @@ limitations under the License.
 
 package schema
 
+import "reflect"
+
 // Equals returns true iff the two Schemas are equal.
 func (a *Schema) Equals(b *Schema) bool {
 	if a == nil || b == nil {
@@ -168,6 +170,9 @@ func (a *StructField) Equals(b *StructField) bool {
 	if a.Name != b.Name {
 		return false
 	}
+	if !reflect.DeepEqual(a.Default, b.Default) {
+		return false
+	}
 	return a.Type.Equals(&b.Type)
 }
 

vendor/sigs.k8s.io/structured-merge-diff/v4/schema/schemaschema.go

@@ -125,6 +125,9 @@ var SchemaSchemaYAML = `types:
     - name: type
       type:
         namedType: typeRef
+    - name: default
+      type:
+        namedType: __untyped_atomic_
 - name: list
   map:
     fields:
@@ -145,4 +148,14 @@ var SchemaSchemaYAML = `types:
     - name: elementRelationship
       type:
         scalar: string
+- name: __untyped_atomic_
+  scalar: untyped
+  list:
+    elementType:
+      namedType: __untyped_atomic_
+    elementRelationship: atomic
+  map:
+    elementType:
+      namedType: __untyped_atomic_
+    elementRelationship: atomic
 `

vendor/sigs.k8s.io/structured-merge-diff/v4/typed/helpers.go

@@ -180,11 +180,23 @@ func mapValue(a value.Allocator, val value.Value) (value.Map, error) {
 	return val.AsMapUsing(a), nil
 }
 
-func keyedAssociativeListItemToPathElement(a value.Allocator, list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
+func getAssociativeKeyDefault(s *schema.Schema, list *schema.List, fieldName string) (interface{}, error) {
+	atom, ok := s.Resolve(list.ElementType)
+	if !ok {
+		return nil, errors.New("invalid elementType for list")
+	}
+	if atom.Map == nil {
+		return nil, errors.New("associative list may not have non-map types")
+	}
+	// If the field is not found, we can assume there is no default.
+	field, _ := atom.Map.FindField(fieldName)
+	return field.Default, nil
+}
+
+func keyedAssociativeListItemToPathElement(a value.Allocator, s *schema.Schema, list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
 	pe := fieldpath.PathElement{}
 	if child.IsNull() {
-		// For now, the keys are required which means that null entries
-		// are illegal.
+		// null entries are illegal.
 		return pe, errors.New("associative list with keys may not have a null element")
 	}
 	if !child.IsMap() {
@@ -196,8 +208,12 @@ func keyedAssociativeListItemToPathElement(a value.Allocator, list *schema.List,
 	for _, fieldName := range list.Keys {
 		if val, ok := m.Get(fieldName); ok {
 			keyMap = append(keyMap, value.Field{Name: fieldName, Value: val})
+		} else if def, err := getAssociativeKeyDefault(s, list, fieldName); err != nil {
+			return pe, fmt.Errorf("couldn't find default value for %v: %v", fieldName, err)
+		} else if def != nil {
+			keyMap = append(keyMap, value.Field{Name: fieldName, Value: value.NewValueInterface(def)})
 		} else {
-			return pe, fmt.Errorf("associative list with keys has an element that omits key field %q", fieldName)
+			return pe, fmt.Errorf("associative list with keys has an element that omits key field %q (and doesn't have default value)", fieldName)
 		}
 	}
 	keyMap.Sort()
@@ -225,10 +241,10 @@ func setItemToPathElement(list *schema.List, index int, child value.Value) (fiel
 	}
 }
 
-func listItemToPathElement(a value.Allocator, list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
+func listItemToPathElement(a value.Allocator, s *schema.Schema, list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
 	if list.ElementRelationship == schema.Associative {
 		if len(list.Keys) > 0 {
-			return keyedAssociativeListItemToPathElement(a, list, index, child)
+			return keyedAssociativeListItemToPathElement(a, s, list, index, child)
 		}
 
 		// If there's no keys, then we must be a set of primitives.

vendor/sigs.k8s.io/structured-merge-diff/v4/typed/merge.go

@@ -183,7 +183,7 @@ func (w *mergingWalker) visitListItems(t *schema.List, lhs, rhs value.List) (err
 	if rhs != nil {
 		for i := 0; i < rhs.Length(); i++ {
 			child := rhs.At(i)
-			pe, err := listItemToPathElement(w.allocator, t, i, child)
+			pe, err := listItemToPathElement(w.allocator, w.schema, t, i, child)
 			if err != nil {
 				errs = append(errs, errorf("rhs: element %v: %v", i, err.Error())...)
 				// If we can't construct the path element, we can't
@@ -204,7 +204,7 @@ func (w *mergingWalker) visitListItems(t *schema.List, lhs, rhs value.List) (err
 	if lhs != nil {
 		for i := 0; i < lhs.Length(); i++ {
 			child := lhs.At(i)
-			pe, err := listItemToPathElement(w.allocator, t, i, child)
+			pe, err := listItemToPathElement(w.allocator, w.schema, t, i, child)
 			if err != nil {
 				errs = append(errs, errorf("lhs: element %v: %v", i, err.Error())...)
 				// If we can't construct the path element, we can't

vendor/sigs.k8s.io/structured-merge-diff/v4/typed/remove.go

@@ -57,7 +57,7 @@ func (w *removingWalker) doList(t *schema.List) (errs ValidationErrors) {
 	for iter.Next() {
 		i, item := iter.Item()
 		// Ignore error because we have already validated this list
-		pe, _ := listItemToPathElement(w.allocator, t, i, item)
+		pe, _ := listItemToPathElement(w.allocator, w.schema, t, i, item)
 		path, _ := fieldpath.MakePath(pe)
 		if w.toRemove.Has(path) {
 			continue

vendor/sigs.k8s.io/structured-merge-diff/v4/typed/tofieldset.go

@@ -96,7 +96,7 @@ func (v *toFieldSetWalker) doScalar(t *schema.Scalar) ValidationErrors {
 func (v *toFieldSetWalker) visitListItems(t *schema.List, list value.List) (errs ValidationErrors) {
 	for i := 0; i < list.Length(); i++ {
 		child := list.At(i)
-		pe, _ := listItemToPathElement(v.allocator, t, i, child)
+		pe, _ := listItemToPathElement(v.allocator, v.schema, t, i, child)
 		v2 := v.prepareDescent(pe, t.ElementType)
 		v2.value = child
 		errs = append(errs, v2.toFieldSet()...)

vendor/sigs.k8s.io/structured-merge-diff/v4/typed/validate.go

@@ -123,7 +123,7 @@ func (v *validatingObjectWalker) visitListItems(t *schema.List, list value.List)
 			pe.Index = &i
 		} else {
 			var err error
-			pe, err = listItemToPathElement(v.allocator, t, i, child)
+			pe, err = listItemToPathElement(v.allocator, v.schema, t, i, child)
 			if err != nil {
 				errs = append(errs, errorf("element %v: %v", i, err.Error())...)
 				// If we can't construct the path element, we can't