Use OpenAPI when merging (3way) resources

- When merging (3way) resources use the patch strategy from the openAPI if the definition exists for the field
- Allow disabling of guessing patch strategy merge keys when no definition exists
- Support defining strategy and key directly on configuration fields through line and header coments
- Support attaching schema to parent fields of lists, and propagating -- e.g. that a field is a PodTemplate

kyaml/yaml/walk/associative_sequence.go

@@ -7,28 +7,44 @@ import (
 	"strings"
 
 	"github.com/go-errors/errors"
+	"sigs.k8s.io/kustomize/kyaml/openapi"
 	"sigs.k8s.io/kustomize/kyaml/sets"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
 
 func (l *Walker) walkAssociativeSequence() (*yaml.RNode, error) {
 	// may require initializing the dest node
-	dest, err := l.Sources.setDestNode(l.VisitList(l.Sources, AssociativeList))
+	dest, err := l.Sources.setDestNode(l.VisitList(l.Sources, l.Schema, AssociativeList))
 	if dest == nil || err != nil {
 		return nil, err
 	}
 
-	// find the list of elements we need to recursively walk
-	key, err := l.elementKey()
-	if err != nil {
-		return nil, err
+	var key string
+	if l.Schema != nil {
+		_, key = l.Schema.PatchStrategyAndKey()
 	}
+	if key == "" { // no key from the schema, try to infer one
+		// find the list of elements we need to recursively walk
+		key, err = l.elementKey()
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	values := l.elementValues(key)
 
 	// recursively set the elements in the list
+	var s *openapi.ResourceSchema
+	if l.Schema != nil {
+		s = l.Schema.Elements()
+	}
 	for _, value := range values {
-		val, err := Walker{Visitor: l,
-			Sources: l.elementValue(key, value)}.Walk()
+		val, err := Walker{
+			InferAssociativeLists: l.InferAssociativeLists,
+			Visitor:               l,
+			Schema:                s,
+			Sources:               l.elementValue(key, value),
+		}.Walk()
 		if err != nil {
 			return nil, err
 		}

kyaml/yaml/walk/map.go

@@ -6,6 +6,8 @@ package walk
 import (
 	"sort"
 
+	"sigs.k8s.io/kustomize/kyaml/fieldmeta"
+	"sigs.k8s.io/kustomize/kyaml/openapi"
 	"sigs.k8s.io/kustomize/kyaml/sets"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
@@ -18,15 +20,27 @@ import (
 // - set each source field value on l.Dest
 func (l Walker) walkMap() (*yaml.RNode, error) {
 	// get the new map value
-	dest, err := l.Sources.setDestNode(l.VisitMap(l.Sources))
+	dest, err := l.Sources.setDestNode(l.VisitMap(l.Sources, l.Schema))
 	if dest == nil || err != nil {
 		return nil, err
 	}
 
 	// recursively set the field values on the map
 	for _, key := range l.fieldNames() {
-		val, err := Walker{Visitor: l,
-			Sources: l.fieldValue(key), Path: append(l.Path, key)}.Walk()
+		var s *openapi.ResourceSchema
+		if l.Schema != nil {
+			s = l.Schema.Field(key)
+		}
+		fv, commentSch := l.fieldValue(key)
+		if commentSch != nil {
+			s = commentSch
+		}
+		val, err := Walker{
+			InferAssociativeLists: l.InferAssociativeLists,
+			Visitor:               l,
+			Schema:                s,
+			Sources:               fv,
+			Path:                  append(l.Path, key)}.Walk()
 		if err != nil {
 			return nil, err
 		}
@@ -42,11 +56,40 @@ func (l Walker) walkMap() (*yaml.RNode, error) {
 }
 
 // valueIfPresent returns node.Value if node is non-nil, otherwise returns nil
-func (l Walker) valueIfPresent(node *yaml.MapNode) *yaml.RNode {
+func (l Walker) valueIfPresent(node *yaml.MapNode) (*yaml.RNode, *openapi.ResourceSchema) {
 	if node == nil {
-		return nil
+		return nil, nil
 	}
-	return node.Value
+
+	// parse the schema for the field if present
+	var s *openapi.ResourceSchema
+	fm := fieldmeta.FieldMeta{}
+	var err error
+	// check the value for a schema
+	if err = fm.Read(node.Value); err == nil {
+		s = &openapi.ResourceSchema{Schema: &fm.Schema}
+		if fm.Schema.Ref.String() != "" {
+			r, err := openapi.Resolve(&fm.Schema.Ref)
+			if err == nil && r != nil {
+				s.Schema = r
+			}
+		}
+	}
+	// check the key for a schema -- this will be used
+	// when the value is a Sequence (comments are attached)
+	// to the key
+	if fm.IsEmpty() {
+		if err = fm.Read(node.Key); err == nil {
+			s = &openapi.ResourceSchema{Schema: &fm.Schema}
+		}
+		if fm.Schema.Ref.String() != "" {
+			r, err := openapi.Resolve(&fm.Schema.Ref)
+			if err == nil && r != nil {
+				s.Schema = r
+			}
+		}
+	}
+	return node.Value, s
 }
 
 // fieldNames returns a sorted slice containing the names of all fields that appear in any of
@@ -67,15 +110,20 @@ func (l Walker) fieldNames() []string {
 }
 
 // fieldValue returns a slice containing each source's value for fieldName
-func (l Walker) fieldValue(fieldName string) []*yaml.RNode {
+func (l Walker) fieldValue(fieldName string) ([]*yaml.RNode, *openapi.ResourceSchema) {
 	var fields []*yaml.RNode
+	var sch *openapi.ResourceSchema
 	for i := range l.Sources {
 		if l.Sources[i] == nil {
 			fields = append(fields, nil)
 			continue
 		}
 		field := l.Sources[i].Field(fieldName)
-		fields = append(fields, l.valueIfPresent(field))
+		f, s := l.valueIfPresent(field)
+		fields = append(fields, f)
+		if sch == nil && !s.IsEmpty() {
+			sch = s
+		}
 	}
-	return fields
+	return fields, sch
 }

kyaml/yaml/walk/nonassociative_sequence.go

@@ -9,5 +9,5 @@ import (
 
 // walkNonAssociativeSequence returns the value of VisitList
 func (l Walker) walkNonAssociativeSequence() (*yaml.RNode, error) {
-	return l.VisitList(l.Sources, NonAssociateList)
+	return l.VisitList(l.Sources, l.Schema, NonAssociateList)
 }

kyaml/yaml/walk/scalar.go

@@ -7,5 +7,5 @@ import "sigs.k8s.io/kustomize/kyaml/yaml"
 
 // walkScalar returns the value of VisitScalar
 func (l Walker) walkScalar() (*yaml.RNode, error) {
-	return l.VisitScalar(l.Sources)
+	return l.VisitScalar(l.Sources, l.Schema)
 }

kyaml/yaml/walk/visitor.go

@@ -4,6 +4,7 @@
 package walk
 
 import (
+	"sigs.k8s.io/kustomize/kyaml/openapi"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
 )
 
@@ -16,11 +17,11 @@ const (
 
 // Visitor is invoked by walk with source and destination node pairs
 type Visitor interface {
-	VisitMap(nodes Sources) (*yaml.RNode, error)
+	VisitMap(Sources, *openapi.ResourceSchema) (*yaml.RNode, error)
 
-	VisitScalar(nodes Sources) (*yaml.RNode, error)
+	VisitScalar(Sources, *openapi.ResourceSchema) (*yaml.RNode, error)
 
-	VisitList(nodes Sources, kind ListKind) (*yaml.RNode, error)
+	VisitList(Sources, *openapi.ResourceSchema, ListKind) (*yaml.RNode, error)
 }
 
 // ClearNode is returned if GrepFilter should do nothing after calling Set

kyaml/yaml/walk/walk.go

@@ -8,20 +8,30 @@ import (
 	"os"
 	"strings"
 
+	"sigs.k8s.io/kustomize/kyaml/fieldmeta"
+	"sigs.k8s.io/kustomize/kyaml/openapi"
 	"sigs.k8s.io/kustomize/kyaml/yaml"
+	"sigs.k8s.io/kustomize/kyaml/yaml/schema"
 )
 
-// Filter walks the Source RNode and modifies the RNode provided to GrepFilter.
+// Walker walks the Source RNode and modifies the RNode provided to GrepFilter.
 type Walker struct {
 	// Visitor is invoked by GrepFilter
 	Visitor
 
+	Schema *openapi.ResourceSchema
+
 	// Source is the RNode to walk.  All Source fields and associative list elements
 	// will be visited.
 	Sources Sources
 
 	// Path is the field path to the current Source Node.
 	Path []string
+
+	// InferAssociativeLists if set to true will infer merge strategies for
+	// fields which it doesn't have the schema based on the fields in the
+	// list elements.
+	InferAssociativeLists bool
 }
 
 func (l Walker) Kind() yaml.Kind {
@@ -35,6 +45,8 @@ func (l Walker) Kind() yaml.Kind {
 
 // GrepFilter implements yaml.GrepFilter
 func (l Walker) Walk() (*yaml.RNode, error) {
+	l.Schema = l.GetSchema()
+
 	// invoke the handler for the corresponding node type
 	switch l.Kind() {
 	case yaml.MappingNode:
@@ -46,7 +58,7 @@ func (l Walker) Walk() (*yaml.RNode, error) {
 		if err := yaml.ErrorIfAnyInvalidAndNonNull(yaml.SequenceNode, l.Sources...); err != nil {
 			return nil, err
 		}
-		if yaml.IsAssociative(l.Sources) {
+		if schema.IsAssociative(l.Schema, l.Sources, l.InferAssociativeLists) {
 			return l.walkAssociativeSequence()
 		}
 		return l.walkNonAssociativeSequence()
@@ -64,6 +76,49 @@ func (l Walker) Walk() (*yaml.RNode, error) {
 	}
 }
 
+func (l Walker) GetSchema() *openapi.ResourceSchema {
+	for i := range l.Sources {
+		r := l.Sources[i]
+		if yaml.IsEmpty(r) {
+			continue
+		}
+
+		fm := fieldmeta.FieldMeta{}
+		if err := fm.Read(r); err == nil && !fm.IsEmpty() {
+			// per-field schema, this is fine
+			if fm.Schema.Ref.String() != "" {
+				// resolve the reference
+				s, err := openapi.Resolve(&fm.Schema.Ref)
+				if err == nil && s != nil {
+					fm.Schema = *s
+				}
+			}
+			return &openapi.ResourceSchema{Schema: &fm.Schema}
+		}
+	}
+
+	if l.Schema != nil {
+		return l.Schema
+	}
+	for i := range l.Sources {
+		r := l.Sources[i]
+		if yaml.IsEmpty(r) {
+			continue
+		}
+
+		m, _ := r.GetMeta()
+		if m.Kind == "" || m.APIVersion == "" {
+			continue
+		}
+
+		s := openapi.SchemaForResourceType(yaml.TypeMeta{Kind: m.Kind, APIVersion: m.APIVersion})
+		if s != nil {
+			return s
+		}
+	}
+	return nil
+}
+
 const (
 	DestIndex = iota
 	OriginIndex