Beginning of rewrite apply merge-logic using visitor pattern.

pkg/kubectl/BUILD

@@ -194,6 +194,7 @@ filegroup(
     name = "all-srcs",
     srcs = [
         ":package-srcs",
+        "//pkg/kubectl/apply:all-srcs",
         "//pkg/kubectl/apps:all-srcs",
         "//pkg/kubectl/cmd:all-srcs",
         "//pkg/kubectl/metricsutil:all-srcs",

pkg/kubectl/apply/BUILD

+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "element.go",
+        "empty_element.go",
+        "list_element.go",
+        "map_element.go",
+        "primitive_element.go",
+        "type_element.go",
+        "visitor.go",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/kubectl/apply/parse:all-srcs",
+        "//pkg/kubectl/apply/strategy:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

pkg/kubectl/apply/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 apply
+
+// This package is used for creating and applying patches generated
+// from a last recorded config, local config, remote object.
+// Example usage for a test:
+//
+//fakeSchema := tst.Fake{Path: swaggerPath}
+//s, err := fakeSchema.OpenAPISchema()
+//Expect(err).To(BeNil())
+//resources, err := openapi.NewOpenAPIData(s)
+//Expect(err).To(BeNil())
+//elementParser := parse.Factory{resources}
+//
+//obj, err := parser.CreateElement(recorded, local, remote)
+//Expect(err).Should(Not(HaveOccurred()))
+//
+//merged, err := obj.Merge(strategy.Create(strategy.Options{}))
+//

pkg/kubectl/apply/empty_element.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 apply
+
+// EmptyElement is a placeholder for when no value is set for a field so its type is unknown
+type EmptyElement struct {
+	// FieldMetaImpl contains metadata about the field from openapi
+	FieldMetaImpl
+}
+
+// Merge implements Element.Merge
+func (e EmptyElement) Merge(v Strategy) (Result, error) {
+	return v.MergeEmpty(e)
+}
+
+// IsAdd implements Element.IsAdd
+func (e EmptyElement) IsAdd() bool {
+	return false
+}
+
+// IsDelete implements Element.IsDelete
+func (e EmptyElement) IsDelete() bool {
+	return false
+}
+
+// GetRecorded implements Element.GetRecorded
+func (e EmptyElement) GetRecorded() interface{} {
+	return nil
+}
+
+// GetLocal implements Element.GetLocal
+func (e EmptyElement) GetLocal() interface{} {
+	return nil
+}
+
+// GetRemote implements Element.GetRemote
+func (e EmptyElement) GetRemote() interface{} {
+	return nil
+}
+
+// HasRecorded implements Element.HasRecorded
+func (e EmptyElement) HasRecorded() bool {
+	return false
+}
+
+// HasLocal implements Element.HasLocal
+func (e EmptyElement) HasLocal() bool {
+	return false
+}
+
+// HasRemote implements Element.IsAdd
+func (e EmptyElement) HasRemote() bool {
+	return false
+}
+
+var _ Element = &EmptyElement{}

pkg/kubectl/apply/list_element.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 apply
+
+// ListElement contains the recorded, local and remote values for a field
+// of type list
+type ListElement struct {
+	// FieldMetaImpl contains metadata about the field from openapi
+	FieldMetaImpl
+
+	// HasElementData contains whether the field was set
+	HasElementData
+
+	// ListElementData contains the value a field was set to
+	ListElementData
+
+	// Values contains the combined recorded-local-remote value of each item in the list
+	// Present for lists that can be merged only.  Contains the items
+	// from each of the 3 lists merged into single Elements using
+	// the merge-key.
+	Values []Element
+}
+
+// Merge implements Element.Merge
+func (e ListElement) Merge(v Strategy) (Result, error) {
+	return v.MergeList(e)
+}
+
+var _ Element = &ListElement{}
+
+// ListElementData contains the recorded, local and remote data for a list
+type ListElementData struct {
+	// recorded contains the value of the field from the recorded object
+	Recorded []interface{}
+
+	// Local contains the value of the field from the recorded object
+	Local []interface{}
+
+	// Remote contains the value of the field from the recorded object
+	Remote []interface{}
+}
+
+// GetRecorded implements Element.GetRecorded
+func (e ListElementData) GetRecorded() interface{} {
+	// https://golang.org/doc/faq#nil_error
+	if e.Recorded == nil {
+		return nil
+	}
+	return e.Recorded
+}
+
+// GetLocal implements Element.GetLocal
+func (e ListElementData) GetLocal() interface{} {
+	// https://golang.org/doc/faq#nil_error
+	if e.Local == nil {
+		return nil
+	}
+	return e.Local
+}
+
+// GetRemote implements Element.GetRemote
+func (e ListElementData) GetRemote() interface{} {
+	// https://golang.org/doc/faq#nil_error
+	if e.Remote == nil {
+		return nil
+	}
+	return e.Remote
+}

pkg/kubectl/apply/map_element.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 apply
+
+// MapElement contains the recorded, local and remote values for a field
+// of type map
+type MapElement struct {
+	// FieldMetaImpl contains metadata about the field from openapi
+	FieldMetaImpl
+
+	// HasElementData contains whether the field was set
+	HasElementData
+
+	// MapElementData contains the value a field was set to
+	MapElementData
+
+	// Values contains the combined recorded-local-remote value of each item in the map
+	// Values contains the values in mapElement.  Element must contain
+	// a Name matching its key in Values
+	Values map[string]Element
+}
+
+// Merge implements Element.Merge
+func (e MapElement) Merge(v Strategy) (Result, error) {
+	return v.MergeMap(e)
+}
+
+// GetValues implements Element.GetValues
+func (e MapElement) GetValues() map[string]Element {
+	return e.Values
+}
+
+var _ Element = &MapElement{}
+
+// MapElementData contains the recorded, local and remote data for a map or type
+type MapElementData struct {
+	// recorded contains the value of the field from the recorded object
+	Recorded map[string]interface{}
+
+	// Local contains the value of the field from the recorded object
+	Local map[string]interface{}
+
+	// Remote contains the value of the field from the recorded object
+	Remote map[string]interface{}
+}
+
+// GetRecorded implements Element.GetRecorded
+func (e MapElementData) GetRecorded() interface{} {
+	// https://golang.org/doc/faq#nil_error
+	if e.Recorded == nil {
+		return nil
+	}
+	return e.Recorded
+}
+
+// GetLocal implements Element.GetLocal
+func (e MapElementData) GetLocal() interface{} {
+	// https://golang.org/doc/faq#nil_error
+	if e.Local == nil {
+		return nil
+	}
+	return e.Local
+}
+
+// GetRemote implements Element.GetRemote
+func (e MapElementData) GetRemote() interface{} {
+	// https://golang.org/doc/faq#nil_error
+	if e.Remote == nil {
+		return nil
+	}
+	return e.Remote
+}

pkg/kubectl/apply/parse/BUILD

+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "factory.go",
+        "item.go",
+        "list_element.go",
+        "map_element.go",
+        "openapi.go",
+        "primitive_element.go",
+        "type_element.go",
+        "util.go",
+        "visitor.go",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/kubectl/apply:go_default_library",
+        "//pkg/kubectl/cmd/util/openapi:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_xtest",
+    srcs = ["suite_test.go"],
+    data = [
+        "//api/openapi-spec:swagger-spec",
+    ],
+    deps = [
+        "//vendor/github.com/onsi/ginkgo:go_default_library",
+        "//vendor/github.com/onsi/ginkgo/config:go_default_library",
+        "//vendor/github.com/onsi/ginkgo/types: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"],
+    visibility = ["//visibility:public"],
+)

pkg/kubectl/apply/parse/factory.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 parse
+
+import (
+	"fmt"
+	"reflect"
+
+	"k8s.io/kubernetes/pkg/kubectl/apply"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+)
+
+// Factory creates an Element by combining object values from recorded, local and remote sources with
+// the metadata from an openapi schema.
+type Factory struct {
+	// Resources contains the openapi field metadata for the object models
+	Resources openapi.Resources
+}
+
+// CreateElement returns an Element by collating the recorded, local and remote field values
+func (b *Factory) CreateElement(recorded, local, remote map[string]interface{}) (apply.Element, error) {
+	// Create an Item from the 3 values.  Use empty name for field
+	visitor := &ElementBuildingVisitor{b.Resources}
+
+	gvk, err := getCommonGroupVersionKind(recorded, local, remote)
+	if err != nil {
+		return nil, err
+	}
+
+	// Get the openapi object metadata
+	s := visitor.resources.LookupResource(gvk)
+	oapiKind, err := getKind(s)
+	if err != nil {
+		return nil, err
+	}
+
+	// Get the item for the type
+	hasRecorded := recorded != nil
+	hasLocal := local != nil
+	hasRemote := remote != nil
+	fieldName := ""
+	item, err := visitor.getItem(oapiKind, fieldName,
+		apply.RawElementData{recorded, local, remote},
+		apply.HasElementData{hasRecorded, hasLocal, hasRemote})
+	if err != nil {
+		return nil, err
+	}
+
+	// Collate each field of the item into a combined Element
+	return item.CreateElement(visitor)
+}
+
+// getItem returns the appropriate Item based on the underlying type of the arguments
+func (v *ElementBuildingVisitor) getItem(s openapi.Schema, name string,
+	data apply.RawElementData,
+	isSet apply.HasElementData) (Item, error) {
+	kind, err := getType(data.Recorded, data.Local, data.Remote)
+	if err != nil {
+		return nil, err
+	}
+	if kind == nil {
+		// All of the items values are nil.
+		return &emptyItem{Name: name}, nil
+	}
+
+	// Create an item matching the type
+	switch kind.Kind() {
+	case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint,
+		reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64,
+		reflect.String:
+		p, err := getPrimitive(s)
+		if err != nil {
+			return nil, fmt.Errorf("expected openapi Primitive, was %T for %v", s, kind)
+		}
+		return &primitiveItem{name, p, isSet, data}, nil
+	case reflect.Array, reflect.Slice:
+		a, err := getArray(s)
+		if err != nil {
+			return nil, fmt.Errorf("expected openapi Array, was %T for %v", s, kind)
+		}
+		return &listItem{name, a, isSet,
+			apply.ListElementData{
+				sliceCast(data.Recorded),
+				sliceCast(data.Local),
+				sliceCast(data.Remote),
+			}}, nil
+	case reflect.Map:
+		if k, err := getKind(s); err == nil {
+			return &typeItem{name, k, isSet,
+				apply.MapElementData{
+					mapCast(data.Recorded),
+					mapCast(data.Local),
+					mapCast(data.Remote),
+				}}, nil
+		}
+		// If it looks like a map, and no openapi type is found, default to mapItem
+		m, err := getMap(s)
+		if err != nil {
+			return nil, fmt.Errorf("expected openapi Kind or Map, was %T for %v", s, kind)
+		}
+		return &mapItem{name, m, isSet,
+			apply.MapElementData{
+				mapCast(data.Recorded),
+				mapCast(data.Local),
+				mapCast(data.Remote),
+			}}, nil
+	}
+	return nil, fmt.Errorf("unsupported type type %v", kind)
+}

pkg/kubectl/apply/parse/item.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 parse
+
+import (
+	"k8s.io/kubernetes/pkg/kubectl/apply"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+)
+
+// Item wraps values from 3 sources (recorded, local, remote).
+// The values are not collated
+type Item interface {
+	// CreateElement merges the values in the item into a combined Element
+	CreateElement(ItemVisitor) (apply.Element, error)
+}
+
+// primitiveItem contains a recorded, local, and remote value
+type primitiveItem struct {
+	Name      string
+	Primitive *openapi.Primitive
+
+	apply.HasElementData
+	apply.RawElementData
+}
+
+func (i *primitiveItem) CreateElement(v ItemVisitor) (apply.Element, error) {
+	return v.CreatePrimitiveElement(i)
+}
+
+func (i *primitiveItem) GetMeta() openapi.Schema {
+	// https://golang.org/doc/faq#nil_error
+	if i.Primitive != nil {
+		return i.Primitive
+	}
+	return nil
+}
+
+// listItem contains a recorded, local, and remote list
+type listItem struct {
+	Name  string
+	Array *openapi.Array
+
+	apply.HasElementData
+	apply.ListElementData
+}
+
+func (i *listItem) CreateElement(v ItemVisitor) (apply.Element, error) {
+	return v.CreateListElement(i)
+}
+
+func (i *listItem) GetMeta() openapi.Schema {
+	// https://golang.org/doc/faq#nil_error
+	if i.Array != nil {
+		return i.Array
+	}
+	return nil
+}
+
+// mapItem contains a recorded, local, and remote map
+type mapItem struct {
+	Name string
+	Map  *openapi.Map
+
+	apply.HasElementData
+	apply.MapElementData
+}
+
+func (i *mapItem) CreateElement(v ItemVisitor) (apply.Element, error) {
+	return v.CreateMapElement(i)
+}
+
+func (i *mapItem) GetMeta() openapi.Schema {
+	// https://golang.org/doc/faq#nil_error
+	if i.Map != nil {
+		return i.Map
+	}
+	return nil
+}
+
+// mapItem contains a recorded, local, and remote map
+type typeItem struct {
+	Name string
+	Type *openapi.Kind
+
+	apply.HasElementData
+	apply.MapElementData
+}
+
+func (i *typeItem) GetMeta() openapi.Schema {
+	// https://golang.org/doc/faq#nil_error
+	if i.Type != nil {
+		return i.Type
+	}
+	return nil
+}
+
+func (i *typeItem) CreateElement(v ItemVisitor) (apply.Element, error) {
+	return v.CreateTypeElement(i)
+}
+
+// emptyItem contains no values
+type emptyItem struct {
+	Name string
+}
+
+func (i *emptyItem) CreateElement(v ItemVisitor) (apply.Element, error) {
+	e := &apply.EmptyElement{}
+	e.Name = i.Name
+	return e, nil
+}

pkg/kubectl/apply/parse/list_element.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 parse
+
+import (
+	"fmt"
+	"k8s.io/kubernetes/pkg/kubectl/apply"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+)
+
+// Contains the heavy lifting for finding tuples of matching elements in lists based on the merge key
+// and then uses the canonical order derived from the orders in the recorded, local and remote lists.
+
+// replaceListElement builds a ListElement for a listItem.
+// Uses the "merge" strategy to identify "same" elements across lists by a "merge key"
+func (v ElementBuildingVisitor) mergeListElement(meta apply.FieldMetaImpl, item *listItem) (*apply.ListElement, error) {
+	subtype := getSchemaType(item.Array.SubType)
+	switch subtype {
+	case "primitive":
+		return v.doPrimitiveList(meta, item)
+	case "map", "kind", "reference":
+		return v.doMapList(meta, item)
+	default:
+		return nil, fmt.Errorf("Cannot merge lists with subtype %s", subtype)
+	}
+}
+
+// doPrimitiveList merges 3 lists of primitives together
+// tries to maintain ordering
+func (v ElementBuildingVisitor) doPrimitiveList(meta apply.FieldMetaImpl, item *listItem) (*apply.ListElement, error) {
+	result := &apply.ListElement{
+		FieldMetaImpl: apply.FieldMetaImpl{
+			MergeType: "merge",
+			Name:      item.Name,
+		},
+		HasElementData:  item.HasElementData,
+		ListElementData: item.ListElementData,
+		Values:          []apply.Element{},
+	}
+
+	// Use locally defined order, then add remote, then add recorded.
+	orderedKeys := &apply.CombinedPrimitiveSlice{}
+
+	// Locally defined items come first and retain their order
+	// as defined locally
+	for _, l := range item.Local {
+		orderedKeys.UpsertLocal(l)
+	}
+	// Mixin remote values, adding any that are not present locally
+	for _, l := range item.Remote {
+		orderedKeys.UpsertRemote(l)
+	}
+	// Mixin recorded values, adding any that are not present locally
+	// or remotely
+	for _, l := range item.Recorded {
+		orderedKeys.UpsertRecorded(l)
+	}
+
+	for i, l := range orderedKeys.Items {
+		recordedSet := l.Recorded != nil
+		localSet := l.Local != nil
+		remoteSet := l.Remote != nil
+
+		var s openapi.Schema
+		if item.Array != nil && item.Array.SubType != nil {
+			s = item.Array.SubType
+		}
+
+		subitem, err := v.getItem(s, fmt.Sprintf("%d", i),
+			l.RawElementData,
+			apply.HasElementData{recordedSet, localSet, remoteSet})
+
+		if err != nil {
+			return nil, err
+		}
+
+		// Convert the Item to an Element
+		newelem, err := subitem.CreateElement(v)
+		if err != nil {
+			return nil, err
+		}
+
+		// Append the element to the list
+		result.Values = append(result.Values, newelem)
+	}
+
+	return result, nil
+}
+
+// doMapList merges 3 lists of maps together by collating their values.
+// tries to retain ordering
+func (v ElementBuildingVisitor) doMapList(meta apply.FieldMetaImpl, item *listItem) (*apply.ListElement, error) {
+	key := meta.GetFieldMergeKeys()
+	result := &apply.ListElement{
+		FieldMetaImpl: apply.FieldMetaImpl{
+			MergeType: "merge",
+			MergeKeys: key,
+			Name:      item.Name,
+		},
+		HasElementData:  item.HasElementData,
+		ListElementData: item.ListElementData,
+		Values:          []apply.Element{},
+	}
+
+	// Use locally defined order, then add remote, then add recorded.
+	orderedKeys := &apply.CombinedMapSlice{}
+
+	// Locally defined items come first and retain their order
+	// as defined locally
+	for _, l := range item.Local {
+		orderedKeys.UpsertLocal(key, l)
+	}
+	// Mixin remote values, adding any that are not present locally
+	for _, l := range item.Remote {
+		orderedKeys.UpsertRemote(key, l)
+	}
+	// Mixin recorded values, adding any that are not present locally
+	// or remotely
+	for _, l := range item.Recorded {
+		orderedKeys.UpsertRecorded(key, l)
+	}
+
+	for i, l := range orderedKeys.Items {
+		recordedSet := l.Recorded != nil
+		localSet := l.Local != nil
+		remoteSet := l.Remote != nil
+
+		var s openapi.Schema
+		if item.Array != nil && item.Array.SubType != nil {
+			s = item.Array.SubType
+		}
+		subitem, err := v.getItem(s, fmt.Sprintf("%d", i),
+			l.RawElementData,
+			apply.HasElementData{recordedSet, localSet, remoteSet})
+		if err != nil {
+			return nil, err
+		}
+
+		// Build the element fully
+		newelem, err := subitem.CreateElement(v)
+		if err != nil {
+			return nil, err
+		}
+
+		// Append the element to the list
+		result.Values = append(result.Values, newelem)
+	}
+
+	return result, nil
+}
+
+// replaceListElement builds a new ListElement from a listItem
+// Uses the "replace" strategy and identify "same" elements across lists by their index
+func (v ElementBuildingVisitor) replaceListElement(meta apply.FieldMetaImpl, item *listItem) (*apply.ListElement, error) {
+	result := &apply.ListElement{
+		FieldMetaImpl:   meta,
+		ListElementData: item.ListElementData,
+		HasElementData:  item.HasElementData,
+		Values:          []apply.Element{},
+	}
+	result.Name = item.Name
+
+	// Use the max length to iterate over the slices
+	for i := 0; i < max(len(item.Recorded), len(item.Local), len(item.Remote)); i++ {
+
+		// Lookup the item from each list
+		recorded, recordedSet := boundsSafeLookup(i, item.Recorded)
+		local, localSet := boundsSafeLookup(i, item.Local)
+		remote, remoteSet := boundsSafeLookup(i, item.Remote)
+
+		// Create the Item
+		var s openapi.Schema
+		if item.Array != nil && item.Array.SubType != nil {
+			s = item.Array.SubType
+		}
+		subitem, err := v.getItem(s, fmt.Sprintf("%d", i),
+			apply.RawElementData{recorded, local, remote},
+			apply.HasElementData{recordedSet, localSet, remoteSet})
+		if err != nil {
+			return nil, err
+		}
+
+		// Build the element
+		newelem, err := subitem.CreateElement(v)
+		if err != nil {
+			return nil, err
+		}
+
+		// Append the element to the list
+		result.Values = append(result.Values, newelem)
+	}
+
+	return result, nil
+}

pkg/kubectl/apply/parse/map_element.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 parse
+
+import (
+	"k8s.io/kubernetes/pkg/kubectl/apply"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+)
+
+// mapElement builds a new mapElement from a mapItem
+func (v ElementBuildingVisitor) mapElement(meta apply.FieldMetaImpl, item *mapItem) (*apply.MapElement, error) {
+	// Function to return schema type of the map values
+	var fn schemaFn = func(string) openapi.Schema {
+		// All map values share the same schema
+		if item.Map != nil && item.Map.SubType != nil {
+			return item.Map.SubType
+		}
+		return nil
+	}
+
+	// Collect same fields from multiple maps into a map of elements
+	values, err := v.createMapValues(fn, meta, item.HasElementData, item.MapElementData)
+	if err != nil {
+		return nil, err
+	}
+
+	// Return the result
+	return &apply.MapElement{
+		FieldMetaImpl:  meta,
+		HasElementData: item.HasElementData,
+		MapElementData: item.MapElementData,
+		Values:         values,
+	}, nil
+}
+
+// schemaFn returns the schema for a field or map value based on its name or key
+type schemaFn func(key string) openapi.Schema
+
+// createMapValues combines the recorded, local and remote values from
+// data into a map of elements.
+func (v ElementBuildingVisitor) createMapValues(
+	schemaFn schemaFn,
+	meta apply.FieldMetaImpl,
+	hasData apply.HasElementData,
+	data apply.MapElementData) (map[string]apply.Element, error) {
+
+	// Collate each key in the map
+	values := map[string]apply.Element{}
+	for _, key := range keysUnion(data.Recorded, data.Local, data.Remote) {
+		recorded, recordedSet := nilSafeLookup(key, data.Recorded)
+		local, localSet := nilSafeLookup(key, data.Local)
+		remote, remoteSet := nilSafeLookup(key, data.Remote)
+
+		// Create an item for the field
+		field, err := v.getItem(schemaFn(key), key,
+			apply.RawElementData{recorded, local, remote},
+			apply.HasElementData{recordedSet, localSet, remoteSet})
+		if err != nil {
+			return nil, err
+		}
+
+		// Build the element for this field
+		element, err := field.CreateElement(v)
+		if err != nil {
+			return nil, err
+		}
+
+		// Add the field element to the map
+		values[key] = element
+	}
+	return values, nil
+}

pkg/kubectl/apply/parse/openapi.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 parse
+
+import (
+	"fmt"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+)
+
+// Contains functions for casting openapi interfaces to their underlying types
+
+// getSchemaType returns the string type of the schema - e.g. array, primitive, map, kind, reference
+func getSchemaType(schema openapi.Schema) string {
+	if schema == nil {
+		return ""
+	}
+	visitor := &baseSchemaVisitor{}
+	schema.Accept(visitor)
+	return visitor.Kind
+}
+
+// getKind converts schema to an *openapi.Kind object
+func getKind(schema openapi.Schema) (*openapi.Kind, error) {
+	if schema == nil {
+		return nil, nil
+	}
+	visitor := &kindSchemaVisitor{}
+	schema.Accept(visitor)
+	return visitor.Result, visitor.Err
+}
+
+// getArray converts schema to an *openapi.Array object
+func getArray(schema openapi.Schema) (*openapi.Array, error) {
+	if schema == nil {
+		return nil, nil
+	}
+	visitor := &arraySchemaVisitor{}
+	schema.Accept(visitor)
+	return visitor.Result, visitor.Err
+}
+
+// getMap converts schema to an *openapi.Map object
+func getMap(schema openapi.Schema) (*openapi.Map, error) {
+	if schema == nil {
+		return nil, nil
+	}
+	visitor := &mapSchemaVisitor{}
+	schema.Accept(visitor)
+	return visitor.Result, visitor.Err
+}
+
+// getPrimitive converts schema to an *openapi.Primitive object
+func getPrimitive(schema openapi.Schema) (*openapi.Primitive, error) {
+	if schema == nil {
+		return nil, nil
+	}
+	visitor := &primitiveSchemaVisitor{}
+	schema.Accept(visitor)
+	return visitor.Result, visitor.Err
+}
+
+type baseSchemaVisitor struct {
+	Err  error
+	Kind string
+}
+
+// VisitArray implements openapi
+func (v *baseSchemaVisitor) VisitArray(array *openapi.Array) {
+	v.Kind = "array"
+	v.Err = fmt.Errorf("Array type not expected")
+}
+
+// MergeMap implements openapi
+func (v *baseSchemaVisitor) VisitMap(*openapi.Map) {
+	v.Kind = "map"
+	v.Err = fmt.Errorf("Map type not expected")
+}
+
+// MergePrimitive implements openapi
+func (v *baseSchemaVisitor) VisitPrimitive(*openapi.Primitive) {
+	v.Kind = "primitive"
+	v.Err = fmt.Errorf("Primitive type not expected")
+}
+
+// VisitKind implements openapi
+func (v *baseSchemaVisitor) VisitKind(*openapi.Kind) {
+	v.Kind = "kind"
+	v.Err = fmt.Errorf("Kind type not expected")
+}
+
+// VisitReference implements openapi
+func (v *baseSchemaVisitor) VisitReference(reference openapi.Reference) {
+	v.Kind = "reference"
+	v.Err = fmt.Errorf("Reference type not expected")
+}
+
+type kindSchemaVisitor struct {
+	baseSchemaVisitor
+	Result *openapi.Kind
+}
+
+// VisitKind implements openapi
+func (v *kindSchemaVisitor) VisitKind(result *openapi.Kind) {
+	v.Result = result
+	v.Kind = "kind"
+}
+
+// VisitReference implements openapi
+func (v *kindSchemaVisitor) VisitReference(reference openapi.Reference) {
+	reference.SubSchema().Accept(v)
+}
+
+type mapSchemaVisitor struct {
+	baseSchemaVisitor
+	Result *openapi.Map
+}
+
+// MergeMap implements openapi
+func (v *mapSchemaVisitor) VisitMap(result *openapi.Map) {
+	v.Result = result
+	v.Kind = "map"
+}
+
+// VisitReference implements openapi
+func (v *mapSchemaVisitor) VisitReference(reference openapi.Reference) {
+	reference.SubSchema().Accept(v)
+}
+
+type arraySchemaVisitor struct {
+	baseSchemaVisitor
+	Result *openapi.Array
+}
+
+// VisitArray implements openapi
+func (v *arraySchemaVisitor) VisitArray(result *openapi.Array) {
+	v.Result = result
+	v.Kind = "array"
+}
+
+// MergePrimitive implements openapi
+func (v *arraySchemaVisitor) VisitReference(reference openapi.Reference) {
+	reference.SubSchema().Accept(v)
+}
+
+type primitiveSchemaVisitor struct {
+	baseSchemaVisitor
+	Result *openapi.Primitive
+}
+
+// MergePrimitive implements openapi
+func (v *primitiveSchemaVisitor) VisitPrimitive(result *openapi.Primitive) {
+	v.Result = result
+	v.Kind = "primitive"
+}
+
+// VisitReference implements openapi
+func (v *primitiveSchemaVisitor) VisitReference(reference openapi.Reference) {
+	reference.SubSchema().Accept(v)
+}

pkg/kubectl/apply/parse/primitive_element.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 parse
+
+import "k8s.io/kubernetes/pkg/kubectl/apply"
+
+// primitiveElement builds a new primitiveElement from a PrimitiveItem
+func (v ElementBuildingVisitor) primitiveElement(item *primitiveItem) (*apply.PrimitiveElement, error) {
+	result := &apply.PrimitiveElement{
+		HasElementData: item.HasElementData,
+		RawElementData: item.RawElementData,
+	}
+	result.Name = item.Name
+
+	return result, nil
+}

pkg/kubectl/apply/parse/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 parse_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/config"
+	. "github.com/onsi/ginkgo/types"
+	. "github.com/onsi/gomega"
+
+	"fmt"
+	"testing"
+)
+
+func TestOpenapi(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecsWithDefaultAndCustomReporters(t, "Openapi Suite", []Reporter{newlineReporter{}})
+}
+
+// Print a newline after the default newlineReporter due to issue
+// https://github.com/jstemmer/go-junit-report/issues/31
+type newlineReporter struct{}
+
+func (newlineReporter) SpecSuiteWillBegin(config GinkgoConfigType, summary *SuiteSummary) {}
+
+func (newlineReporter) BeforeSuiteDidRun(setupSummary *SetupSummary) {}
+
+func (newlineReporter) AfterSuiteDidRun(setupSummary *SetupSummary) {}
+
+func (newlineReporter) SpecWillRun(specSummary *SpecSummary) {}
+
+func (newlineReporter) SpecDidComplete(specSummary *SpecSummary) {}
+
+// SpecSuiteDidEnd Prints a newline between "35 Passed | 0 Failed | 0 Pending | 0 Skipped" and "--- PASS:"
+func (newlineReporter) SpecSuiteDidEnd(summary *SuiteSummary) { fmt.Printf("\n") }

pkg/kubectl/apply/parse/type_element.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 parse
+
+import (
+	"k8s.io/kubernetes/pkg/kubectl/apply"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+)
+
+// typeElement builds a new mapElement from a typeItem
+func (v ElementBuildingVisitor) typeElement(meta apply.FieldMetaImpl, item *typeItem) (*apply.TypeElement, error) {
+	// Function to get the schema of a field from its key
+	var fn schemaFn = func(key string) openapi.Schema {
+		if item.Type != nil && item.Type.Fields != nil {
+			return item.Type.Fields[key]
+		}
+		return nil
+	}
+
+	// Collect same fields from multiple maps into a map of elements
+	values, err := v.createMapValues(fn, meta, item.HasElementData, item.MapElementData)
+	if err != nil {
+		return nil, err
+	}
+
+	// Return the result
+	return &apply.TypeElement{
+		FieldMetaImpl:  meta,
+		HasElementData: item.HasElementData,
+		MapElementData: item.MapElementData,
+		Values:         values,
+	}, nil
+}

pkg/kubectl/apply/parse/util.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 parse
+
+import (
+	"fmt"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubernetes/pkg/kubectl/apply"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+	"reflect"
+	"strings"
+)
+
+// nilSafeLookup returns the value from the map if the map is non-nil
+func nilSafeLookup(key string, from map[string]interface{}) (interface{}, bool) {
+	if from != nil {
+		value, found := from[key]
+		return value, found
+	}
+	// Not present
+	return nil, false
+}
+
+// boundsSafeLookup returns the value from the slice if the slice is non-nil and
+// the index is in bounds.
+func boundsSafeLookup(index int, from []interface{}) (interface{}, bool) {
+	if from != nil && len(from) > index {
+		return from[index], true
+	}
+	return nil, false
+}
+
+// keysUnion returns a slice containing the union of the keys present in the arguments
+func keysUnion(maps ...map[string]interface{}) []string {
+	keys := map[string]interface{}{}
+	for _, m := range maps {
+		for k := range m {
+			keys[k] = nil
+		}
+	}
+	result := []string{}
+	for key := range keys {
+		result = append(result, key)
+	}
+	return result
+}
+
+// max returns the argument with the highest value
+func max(values ...int) int {
+	v := 0
+	for _, i := range values {
+		if i > v {
+			v = i
+		}
+	}
+	return v
+}
+
+// getType returns the type of the arguments.  If the arguments don't have matching
+// types, getType returns an error.  Nil types matching everything.
+func getType(args ...interface{}) (reflect.Type, error) {
+	var last interface{}
+	for _, next := range args {
+		// Skip nil values
+		if next == nil {
+			continue
+		}
+
+		// Set the first non-nil value we find and continue
+		if last == nil {
+			last = next
+			continue
+		}
+
+		// Verify the types of the values match
+		if reflect.TypeOf(last).Kind() != reflect.TypeOf(next).Kind() {
+			return nil, fmt.Errorf("missmatching non-nil types for the same field: %T %T", last, next)
+		}
+	}
+
+	return reflect.TypeOf(last), nil
+}
+
+// sliceCast casts i to a slice if it is non-nil, otherwise returns nil
+func sliceCast(i interface{}) []interface{} {
+	if i == nil {
+		return nil
+	}
+	return i.([]interface{})
+}
+
+// mapCast casts i to a map if it is non-nil, otherwise returns nil
+func mapCast(i interface{}) map[string]interface{} {
+	if i == nil {
+		return nil
+	}
+	return i.(map[string]interface{})
+}
+
+// getFieldMeta parses the metadata about the field from the openapi spec
+func getFieldMeta(s openapi.Schema, name string) (apply.FieldMetaImpl, error) {
+	m := apply.FieldMetaImpl{}
+	if s != nil {
+		ext := s.GetExtensions()
+		if s, found := ext["x-kubernetes-patch-strategy"]; found {
+			strategy, ok := s.(string)
+			if !ok {
+				return apply.FieldMetaImpl{}, fmt.Errorf("Expected string for x-kubernetes-patch-strategy by got %T", s)
+			}
+			// TODO: Support multi-strategy
+			m.MergeType = strategy
+		}
+		if k, found := ext["x-kubernetes-patch-merge-key"]; found {
+			key, ok := k.(string)
+			if !ok {
+				return apply.FieldMetaImpl{}, fmt.Errorf("Expected string for x-kubernetes-patch-merge-key by got %T", k)
+			}
+			m.MergeKeys = apply.MergeKeys(strings.Split(key, ","))
+		}
+	}
+	m.Name = name
+	return m, nil
+}
+
+// getCommonGroupVersionKind verifies that the recorded, local and remote all share
+// the same GroupVersionKind and returns the value
+func getCommonGroupVersionKind(recorded, local, remote map[string]interface{}) (schema.GroupVersionKind, error) {
+	recordedGVK, err := getGroupVersionKind(recorded)
+	if err != nil {
+		return schema.GroupVersionKind{}, err
+	}
+	localGVK, err := getGroupVersionKind(local)
+	if err != nil {
+		return schema.GroupVersionKind{}, err
+	}
+	remoteGVK, err := getGroupVersionKind(remote)
+	if err != nil {
+		return schema.GroupVersionKind{}, err
+	}
+
+	if !reflect.DeepEqual(recordedGVK, localGVK) || !reflect.DeepEqual(localGVK, remoteGVK) {
+		return schema.GroupVersionKind{},
+			fmt.Errorf("group version kinds do not match (recorded: %v local: %v remote: %v)",
+				recordedGVK, localGVK, remoteGVK)
+	}
+	return recordedGVK, nil
+}
+
+// getGroupVersionKind returns the GroupVersionKind of the object
+func getGroupVersionKind(config map[string]interface{}) (schema.GroupVersionKind, error) {
+	gvk := schema.GroupVersionKind{}
+	if gv, found := config["apiVersion"]; found {
+		casted, ok := gv.(string)
+		if !ok {
+			return gvk, fmt.Errorf("Expected string for apiVersion, found %T", gv)
+		}
+		groupversion := strings.Split(casted, "/")
+		gvk.Group = groupversion[0]
+		gvk.Version = groupversion[1]
+	} else {
+		return gvk, fmt.Errorf("Missing apiVersion in Kind %v", config)
+	}
+	if k, found := config["kind"]; found {
+		casted, ok := k.(string)
+		if !ok {
+			return gvk, fmt.Errorf("Expected string for kind, found %T", k)
+		}
+		gvk.Kind = casted
+	} else {
+		return gvk, fmt.Errorf("Missing kind in Kind %v", config)
+	}
+	return gvk, nil
+}

pkg/kubectl/apply/parse/visitor.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 parse
+
+import (
+	"k8s.io/kubernetes/pkg/kubectl/apply"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+)
+
+// ItemVisitor provides an interface for Items to Accept and call
+// the Visit function that corresponds to its actual type.
+type ItemVisitor interface {
+	// CreatePrimitiveElement builds an Element for a primitiveItem
+	CreatePrimitiveElement(*primitiveItem) (apply.Element, error)
+
+	// CreateListElement builds an Element for a listItem
+	CreateListElement(*listItem) (apply.Element, error)
+
+	// CreateMapElement builds an Element for a mapItem
+	CreateMapElement(*mapItem) (apply.Element, error)
+
+	// CreateTypeElement builds an Element for a typeItem
+	CreateTypeElement(*typeItem) (apply.Element, error)
+}
+
+// ElementBuildingVisitor creates an Elements from Items
+// An Element combines the values from the Item with the field metadata.
+type ElementBuildingVisitor struct {
+	resources openapi.Resources
+}
+
+// CreatePrimitiveElement creates a primitiveElement
+func (v ElementBuildingVisitor) CreatePrimitiveElement(item *primitiveItem) (apply.Element, error) {
+	return v.primitiveElement(item)
+}
+
+// CreateListElement creates a ListElement
+func (v ElementBuildingVisitor) CreateListElement(item *listItem) (apply.Element, error) {
+	meta, err := getFieldMeta(item.GetMeta(), item.Name)
+	if err != nil {
+		return nil, err
+	}
+	if meta.GetFieldMergeType() == "merge" {
+		return v.mergeListElement(meta, item)
+	}
+	return v.replaceListElement(meta, item)
+}
+
+// CreateMapElement creates a mapElement
+func (v ElementBuildingVisitor) CreateMapElement(item *mapItem) (apply.Element, error) {
+	meta, err := getFieldMeta(item.GetMeta(), item.Name)
+	if err != nil {
+		return nil, err
+	}
+	return v.mapElement(meta, item)
+}
+
+// CreateTypeElement creates a typeElement
+func (v ElementBuildingVisitor) CreateTypeElement(item *typeItem) (apply.Element, error) {
+	meta, err := getFieldMeta(item.GetMeta(), item.Name)
+	if err != nil {
+		return nil, err
+	}
+	return v.typeElement(meta, item)
+}

pkg/kubectl/apply/primitive_element.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 apply
+
+import (
+	"fmt"
+)
+
+// PrimitiveElement contains the recorded, local and remote values for a field
+// of type primitive
+type PrimitiveElement struct {
+	// FieldMetaImpl contains metadata about the field from openapi
+	FieldMetaImpl
+
+	// HasElementData contains whether the field was set
+	HasElementData
+
+	// RawElementData contains the values the field was set to
+	RawElementData
+}
+
+// Merge implements Element.Merge
+func (e PrimitiveElement) Merge(v Strategy) (Result, error) {
+	return v.MergePrimitive(e)
+}
+
+// String returns a string representation of the PrimitiveElement
+func (e PrimitiveElement) String() string {
+	return fmt.Sprintf("name: %s recorded: %v local: %v remote: %v", e.Name, e.Recorded, e.Local, e.Remote)
+}
+
+var _ Element = &PrimitiveElement{}

pkg/kubectl/apply/strategy/BUILD

+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "merge.go",
+        "merge_visitor.go",
+        "replace_visitor.go",
+        "retain_keys_visitor.go",
+        "strategic_visitor.go",
+    ],
+    visibility = ["//visibility:public"],
+    deps = ["//pkg/kubectl/apply:go_default_library"],
+)
+
+go_test(
+    name = "go_default_xtest",
+    srcs = [
+        "merge_map_list_test.go",
+        "merge_map_test.go",
+        "merge_primitive_list_test.go",
+        "merge_primitive_test.go",
+        "replace_map_list_test.go",
+        "replace_map_test.go",
+        "replace_primitive_list_test.go",
+        "suite_test.go",
+        "utils_test.go",
+    ],
+    data = [
+        ":swagger-spec",
+        "//api/openapi-spec:swagger-spec",
+    ],
+    deps = [
+        ":go_default_library",
+        "//pkg/kubectl/apply:go_default_library",
+        "//pkg/kubectl/apply/parse:go_default_library",
+        "//pkg/kubectl/cmd/util/openapi:go_default_library",
+        "//pkg/kubectl/cmd/util/openapi/testing:go_default_library",
+        "//vendor/github.com/ghodss/yaml:go_default_library",
+        "//vendor/github.com/onsi/ginkgo:go_default_library",
+        "//vendor/github.com/onsi/ginkgo/config:go_default_library",
+        "//vendor/github.com/onsi/ginkgo/types:go_default_library",
+        "//vendor/github.com/onsi/gomega:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/diff:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "swagger-spec",
+    srcs = glob([
+        "**/*.json",
+    ]),
+)

pkg/kubectl/apply/strategy/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 strategy

pkg/kubectl/apply/strategy/merge.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 strategy
+
+import "k8s.io/kubernetes/pkg/kubectl/apply"
+
+// Options controls how a merge will be executed
+type Options struct {
+	// FailOnConflict when true will fail patch creation if the Recorded and Remote
+	// have 2 fields set for the same value that cannot be merged.
+	// e.g. primitive values, list values with replace strategy, and map values with do
+	// strategy
+	FailOnConflict bool
+
+	// ListOrder controls the order of items in a list after it is merged
+	ListOrder ListOrder
+}
+
+// Create returns a new apply.Visitor for merging multiple objects together
+func Create(options Options) apply.Strategy {
+	return createDelegatingStrategy(options)
+}
+
+// ListOrder allows the caller to controller how ordering is determined when merging
+// lists
+// TODO: Implement this
+type ListOrder int
+
+const (
+	// RemoteOnlyLast appends items only appearing in the remote list to the end
+	RemoteOnlyLast ListOrder = iota
+	// RemoteOnlyFirst prepends items only appearing in the remote list to the beginning
+	RemoteOnlyFirst
+	// RemoteCollated will try to preserve the order of elements as much as possible by
+	// interleaving items
+	RemoteCollated
+)

pkg/kubectl/apply/strategy/merge_map_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 strategy_test
+
+import (
+	. "github.com/onsi/ginkgo"
+
+	"k8s.io/kubernetes/pkg/kubectl/apply/strategy"
+)
+
+var _ = Describe("Merging fields of type map with openapi for some fields", func() {
+	Context("where a field has been deleted", func() {
+		It("should delete the field", func() {
+			recorded := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+  replicas: 3
+  foo1:
+    bar: "baz1"
+    image: "1"
+`)
+			local := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+  replicas: 3
+  foo2: null
+`)
+			remote := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+  replicas: 3
+  foo1:
+    bar: "baz1"
+    image: "1"
+  foo2:
+    bar: "baz2"
+    image: "2"
+  foo3:
+    bar: "baz3"
+    image: "3"
+`)
+			expected := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+  replicas: 3
+  foo3:
+    bar: "baz3"
+    image: "3"
+`)
+			run(strategy.Create(strategy.Options{}), recorded, local, remote, expected)
+		})
+	})
+
+	Context("where a field is has been added", func() {
+		It("should add the field", func() {
+			recorded := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+  foo1:
+    bar: "baz1"
+    image: "1"
+`)
+			local := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+  replicas: 3
+  foo1:
+    bar: "baz1"
+    image: "1"
+  foo2:
+    bar: "baz2"
+    image: "2"
+`)
+			remote := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+`)
+			expected := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+  replicas: 3
+  foo1:
+    bar: "baz1"
+    image: "1"
+  foo2:
+    bar: "baz2"
+    image: "2"
+`)
+			run(strategy.Create(strategy.Options{}), recorded, local, remote, expected)
+		})
+	})
+
+	Context("where a field is has been updated", func() {
+		It("should update the field", func() {
+			recorded := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+  foo1:
+    bar: "baz1=1"
+    image: "1-1"
+`)
+			local := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+  replicas: 3
+  foo1:
+    bar: "baz1-1"
+    image: "1-1"
+  foo2:
+    bar: "baz2-1"
+    image: "2-1"
+`)
+			remote := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+  replicas: 2
+  foo1:
+    bar: "baz1-0"
+    image: "1-0"
+  foo2:
+    bar: "baz2-0"
+    image: "2-0"
+`)
+			expected := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+spec:
+  replicas: 3
+  foo1:
+    bar: "baz1-1"
+    image: "1-1"
+  foo2:
+    bar: "baz2-1"
+    image: "2-1"
+`)
+			run(strategy.Create(strategy.Options{}), recorded, local, remote, expected)
+		})
+	})
+})

pkg/kubectl/apply/strategy/merge_primitive_list_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 strategy_test
+
+import (
+	. "github.com/onsi/ginkgo"
+
+	"k8s.io/kubernetes/pkg/kubectl/apply/strategy"
+)
+
+var _ = Describe("Merging fields of type list-of-primitive with openapi", func() {
+	Context("where one of the items has been deleted", func() {
+		It("should delete the deleted item", func() {
+			recorded := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "b"
+  - "c"
+`)
+			local := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "c"
+`)
+			remote := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "b"
+  - "c"
+`)
+			expected := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "c"
+`)
+			run(strategy.Create(strategy.Options{}), recorded, local, remote, expected)
+		})
+	})
+
+	Context("where one of the items is only on the remote", func() {
+		It("should move the remote-only item to the end but keep it", func() {
+			recorded := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "b"
+`)
+			local := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "b"
+`)
+			remote := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "c"
+  - "b"
+  - "a"
+`)
+			expected := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "b"
+  - "c"
+`)
+			run(strategy.Create(strategy.Options{}), recorded, local, remote, expected)
+		})
+	})
+
+	Context("where one of the items is repeated", func() {
+		It("should de-duplicate the repeated items", func() {
+			recorded := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "b"
+`)
+			local := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "b"
+  - "a"
+`)
+			remote := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "b"
+`)
+			expected := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "b"
+`)
+			run(strategy.Create(strategy.Options{}), recorded, local, remote, expected)
+		})
+	})
+
+	Context("where some items are deleted and others are on remote only", func() {
+		It("should retain the correct items in the correct order", func() {
+			recorded := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "b"
+  - "c"
+`)
+			local := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "c"
+  - "a"
+`)
+			remote := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "d"
+  - "b"
+  - "c"
+  - "a"
+  - "e"
+`)
+			expected := create(`
+apiVersion: apps/v1beta1
+kind: Deployment
+metadata:
+  finalizers:
+  - "a"
+  - "c"
+  - "d"
+  - "e"
+`)
+			run(strategy.Create(strategy.Options{}), recorded, local, remote, expected)
+		})
+	})
+})

pkg/kubectl/apply/strategy/merge_visitor.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 strategy
+
+import (
+	"fmt"
+
+	"k8s.io/kubernetes/pkg/kubectl/apply"
+)
+
+func createMergeStrategy(options Options, strategic *delegatingStrategy) mergeStrategy {
+	return mergeStrategy{
+		strategic,
+		options,
+	}
+}
+
+// mergeStrategy creates a patch to merge a local file value into a remote field value
+type mergeStrategy struct {
+	strategic *delegatingStrategy
+	options   Options
+}
+
+// MergeList creates a patch to merge a local list field value into a remote list field value
+func (v mergeStrategy) MergeList(e apply.ListElement) (apply.Result, error) {
+	// No merge logic if adding or deleting a field
+	if result, done := v.doAddOrDelete(e); done {
+		return result, nil
+	}
+
+	// Merge each item in the list and append it to the list
+	merged := []interface{}{}
+	for _, value := range e.Values {
+		// Recursively merge the list element before adding the value to the list
+		result, err := value.Merge(v.strategic)
+		if err != nil {
+			return apply.Result{}, err
+		}
+
+		switch result.Operation {
+		case apply.SET:
+			// Keep the list item value
+			merged = append(merged, result.MergedResult)
+		case apply.DROP:
+			// Drop the list item value
+		default:
+			panic(fmt.Errorf("Unexpected result operation type %+v", result))
+		}
+	}
+
+	if len(merged) == 0 {
+		// If the list is empty, return a nil entry
+		return apply.Result{Operation: apply.SET, MergedResult: nil}, nil
+	}
+	// Return the merged list, and tell the caller to keep it
+	return apply.Result{Operation: apply.SET, MergedResult: merged}, nil
+}
+
+// MergeMap creates a patch to merge a local map field into a remote map field
+func (v mergeStrategy) MergeMap(e apply.MapElement) (apply.Result, error) {
+	return v.doMergeMap(e)
+}
+
+// MergeType creates a patch to merge a local map field into a remote map field
+func (v mergeStrategy) MergeType(e apply.TypeElement) (apply.Result, error) {
+	return v.doMergeMap(e)
+}
+
+// do merges a recorded, local and remote map into a new object
+func (v mergeStrategy) doMergeMap(e apply.MapValuesElement) (apply.Result, error) {
+	// No merge logic if adding or deleting a field
+	if result, done := v.doAddOrDelete(e); done {
+		return result, nil
+	}
+
+	// Merge each item in the list
+	merged := map[string]interface{}{}
+	for key, value := range e.GetValues() {
+		// Recursively merge the map element before adding the value to the map
+		result, err := value.Merge(v.strategic)
+		if err != nil {
+			return apply.Result{}, err
+		}
+
+		switch result.Operation {
+		case apply.SET:
+			// Keep the map item value
+			merged[key] = result.MergedResult
+		case apply.DROP:
+			// Drop the map item value
+		default:
+			panic(fmt.Errorf("Unexpected result operation type %+v", result))
+		}
+	}
+
+	// Return the merged map, and tell the caller to keep it
+	if len(merged) == 0 {
+		// Special case the empty map to set the field value to nil, but keep the field key
+		// This is how the tests expect the structures to look when parsed from yaml
+		return apply.Result{Operation: apply.SET, MergedResult: nil}, nil
+	}
+	return apply.Result{Operation: apply.SET, MergedResult: merged}, nil
+}
+
+func (v mergeStrategy) doAddOrDelete(e apply.Element) (apply.Result, bool) {
+	if apply.IsAdd(e) {
+		return apply.Result{Operation: apply.SET, MergedResult: e.GetLocal()}, true
+	}
+
+	// Delete the List
+	if apply.IsDrop(e) {
+		return apply.Result{Operation: apply.DROP}, true
+	}
+
+	return apply.Result{}, false
+}
+
+// MergePrimitive returns and error.  Primitive elements can't be merged, only replaced.
+func (v mergeStrategy) MergePrimitive(diff apply.PrimitiveElement) (apply.Result, error) {
+	return apply.Result{}, fmt.Errorf("Cannot merge primitive element %v", diff.Name)
+}
+
+// MergeEmpty
+func (v mergeStrategy) MergeEmpty(diff apply.EmptyElement) (apply.Result, error) {
+	return apply.Result{Operation: apply.SET}, nil
+}
+
+var _ apply.Strategy = &mergeStrategy{}

pkg/kubectl/apply/strategy/replace_map_list_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 strategy_test
+
+import (
+	. "github.com/onsi/ginkgo"
+
+	"k8s.io/kubernetes/pkg/kubectl/apply/strategy"
+)
+
+var _ = Describe("Replacing fields of type list without openapi", func() {
+	Context("where a field is has been updated", func() {
+		It("should replace the field", func() {
+			recorded := create(`
+apiVersion: apps/v1beta1
+kind: Foo
+spec:
+  bar:
+  - name: bar1
+    value: 1
+  - name: bar2
+    value: 2
+`)
+			local := create(`
+apiVersion: apps/v1beta1
+kind: Foo
+spec:
+  bar:
+  - name: bar1
+    value: 1
+  - name: bar2
+    value: 2
+`)
+			remote := create(`
+apiVersion: apps/v1beta1
+kind: Foo
+spec:
+  bar:
+  - name: bar1
+    value: 1
+  - name: bar3
+    value: 3
+  - name: bar4
+    value: 4
+`)
+			expected := create(`
+apiVersion: apps/v1beta1
+kind: Foo
+spec:
+  bar:
+  - name: bar1
+    value: 1
+  - name: bar2
+    value: 2
+`)
+			run(strategy.Create(strategy.Options{}), recorded, local, remote, expected)
+		})
+	})
+})

pkg/kubectl/apply/strategy/replace_map_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 strategy_test
+
+import (
+	. "github.com/onsi/ginkgo"
+
+	"k8s.io/kubernetes/pkg/kubectl/apply/strategy"
+)
+
+var _ = Describe("Replacing fields of type map with openapi for some fields", func() {
+	Context("where a field is has been updated", func() {
+		It("should update the field", func() {
+			recorded := create(`
+apiVersion: extensions/v1beta1
+kind: ReplicaSet
+spec:
+  template:
+    containers:
+    - name: container1
+      image: image1
+`)
+			local := create(`
+apiVersion: extensions/v1beta1
+kind: ReplicaSet
+spec:
+  template:
+    containers:
+    - name: container1
+      image: image1
+`)
+			remote := create(`
+apiVersion: extensions/v1beta1
+kind: ReplicaSet
+spec:
+  template:
+    containers:
+    - name: container1
+      image: image1
+    - name: container2
+      image: image2
+    - name: container3
+      image: image3
+`)
+			expected := create(`
+apiVersion: extensions/v1beta1
+kind: ReplicaSet
+spec:
+  template:
+    containers:
+    - name: container1
+      image: image1
+`)
+
+			// Use modified swagger for ReplicaSet spec
+			runWith(strategy.Create(strategy.Options{}), recorded, local, remote, expected, "test_swagger.json")
+		})
+	})
+})

pkg/kubectl/apply/strategy/replace_visitor.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 strategy
+
+import (
+	"k8s.io/kubernetes/pkg/kubectl/apply"
+)
+
+// replaceVisitor creates a patch to replace a remote field value with a local field value
+type replaceStrategy struct {
+	strategic *delegatingStrategy
+	options   Options
+}
+
+func createReplaceStrategy(options Options, strategic *delegatingStrategy) replaceStrategy {
+	return replaceStrategy{
+		strategic,
+		options,
+	}
+}
+
+// MergeList returns a result by merging the recorded, local and remote values
+// - replacing the remote value with the local value
+func (v replaceStrategy) MergeList(e apply.ListElement) (apply.Result, error) {
+	return v.doReplace(e)
+}
+
+// MergeMap returns a result by merging the recorded, local and remote values
+// - replacing the remote value with the local value
+func (v replaceStrategy) MergeMap(e apply.MapElement) (apply.Result, error) {
+	return v.doReplace(e)
+}
+
+// MergeType returns a result by merging the recorded, local and remote values
+// - replacing the remote value with the local value
+func (v replaceStrategy) MergeType(e apply.TypeElement) (apply.Result, error) {
+	return v.doReplace(e)
+}
+
+// MergePrimitive returns a result by merging the recorded, local and remote values
+// - replacing the remote value with the local value
+func (v replaceStrategy) MergePrimitive(e apply.PrimitiveElement) (apply.Result, error) {
+	return v.doReplace(e)
+}
+
+// MergeEmpty
+func (v replaceStrategy) MergeEmpty(e apply.EmptyElement) (apply.Result, error) {
+	return apply.Result{Operation: apply.SET}, nil
+}
+
+// replace returns the local value if specified, otherwise it returns the remote value
+// this works regardless of the approach
+func (v replaceStrategy) doReplace(e apply.Element) (apply.Result, error) {
+	// TODO: Check for conflicts
+	if result, done := v.doAddOrDelete(e); done {
+		return result, nil
+	}
+
+	if e.HasLocal() {
+		// Specified locally, set the local value
+		return apply.Result{Operation: apply.SET, MergedResult: e.GetLocal()}, nil
+	} else if e.HasRemote() {
+		// Not specified locally, set the remote value
+		return apply.Result{Operation: apply.SET, MergedResult: e.GetRemote()}, nil
+	} else {
+		// Only specified in the recorded, drop the field.
+		return apply.Result{Operation: apply.DROP, MergedResult: e.GetRemote()}, nil
+	}
+}
+
+// doAddOrDelete will check if the field should be either added or deleted.  If either is true, it will
+// true the operation and true.  Otherwise it will return false.
+func (v replaceStrategy) doAddOrDelete(e apply.Element) (apply.Result, bool) {
+	if apply.IsAdd(e) {
+		return apply.Result{Operation: apply.SET, MergedResult: e.GetLocal()}, true
+	}
+
+	// Delete the List
+	if apply.IsDrop(e) {
+		return apply.Result{Operation: apply.DROP}, true
+	}
+
+	return apply.Result{}, false
+}
+
+var _ apply.Strategy = &replaceStrategy{}

pkg/kubectl/apply/strategy/retain_keys_visitor.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 strategy
+
+// TODO: Write this

pkg/kubectl/apply/strategy/strategic_visitor.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 strategy
+
+import "k8s.io/kubernetes/pkg/kubectl/apply"
+
+// delegatingStrategy delegates merging fields to other visitor implementations
+// based on the merge strategy preferred by the field.
+type delegatingStrategy struct {
+	options Options
+	merge   mergeStrategy
+	replace replaceStrategy
+}
+
+// createDelegatingStrategy returns a new delegatingStrategy
+func createDelegatingStrategy(options Options) *delegatingStrategy {
+	v := &delegatingStrategy{
+		options: options,
+	}
+	v.replace = createReplaceStrategy(options, v)
+	v.merge = createMergeStrategy(options, v)
+	return v
+}
+
+// MergeList delegates visiting a list based on the field patch strategy.
+// Defaults to "replace"
+func (v delegatingStrategy) MergeList(diff apply.ListElement) (apply.Result, error) {
+	// TODO: Support retainkeys
+	switch diff.GetFieldMergeType() {
+	case "merge":
+		return v.merge.MergeList(diff)
+	case "replace":
+		return v.replace.MergeList(diff)
+	default:
+		return v.replace.MergeList(diff)
+	}
+}
+
+// MergeMap delegates visiting a map based on the field patch strategy.
+// Defaults to "merge"
+func (v delegatingStrategy) MergeMap(diff apply.MapElement) (apply.Result, error) {
+	// TODO: Support retainkeys
+	switch diff.GetFieldMergeType() {
+	case "merge":
+		return v.merge.MergeMap(diff)
+	case "replace":
+		return v.replace.MergeMap(diff)
+	default:
+		return v.merge.MergeMap(diff)
+	}
+}
+
+// MergeType delegates visiting a map based on the field patch strategy.
+// Defaults to "merge"
+func (v delegatingStrategy) MergeType(diff apply.TypeElement) (apply.Result, error) {
+	// TODO: Support retainkeys
+	switch diff.GetFieldMergeType() {
+	case "merge":
+		return v.merge.MergeType(diff)
+	case "replace":
+		return v.replace.MergeType(diff)
+	default:
+		return v.merge.MergeType(diff)
+	}
+}
+
+// MergePrimitive delegates visiting a primitive to the ReplaceVisitorSingleton.
+func (v delegatingStrategy) MergePrimitive(diff apply.PrimitiveElement) (apply.Result, error) {
+	// Always replace primitives
+	return v.replace.MergePrimitive(diff)
+}
+
+// MergeEmpty
+func (v delegatingStrategy) MergeEmpty(diff apply.EmptyElement) (apply.Result, error) {
+	return v.merge.MergeEmpty(diff)
+}
+
+var _ apply.Strategy = &delegatingStrategy{}

pkg/kubectl/apply/strategy/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 strategy_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/config"
+	. "github.com/onsi/ginkgo/types"
+	. "github.com/onsi/gomega"
+
+	"fmt"
+	"testing"
+)
+
+func TestOpenapi(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecsWithDefaultAndCustomReporters(t, "Openapi Suite", []Reporter{newlineReporter{}})
+}
+
+// Print a newline after the default newlineReporter due to issue
+// https://github.com/jstemmer/go-junit-report/issues/31
+type newlineReporter struct{}
+
+func (newlineReporter) SpecSuiteWillBegin(config GinkgoConfigType, summary *SuiteSummary) {}
+
+func (newlineReporter) BeforeSuiteDidRun(setupSummary *SetupSummary) {}
+
+func (newlineReporter) AfterSuiteDidRun(setupSummary *SetupSummary) {}
+
+func (newlineReporter) SpecWillRun(specSummary *SpecSummary) {}
+
+func (newlineReporter) SpecDidComplete(specSummary *SpecSummary) {}
+
+// SpecSuiteDidEnd Prints a newline between "35 Passed | 0 Failed | 0 Pending | 0 Skipped" and "--- PASS:"
+func (newlineReporter) SpecSuiteDidEnd(summary *SuiteSummary) { fmt.Printf("\n") }

pkg/kubectl/apply/strategy/utils_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 strategy_test
+
+import (
+	. "github.com/onsi/gomega"
+
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/ghodss/yaml"
+
+	"k8s.io/apimachinery/pkg/util/diff"
+	"k8s.io/kubernetes/pkg/kubectl/apply"
+	"k8s.io/kubernetes/pkg/kubectl/apply/parse"
+	"k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi"
+	tst "k8s.io/kubernetes/pkg/kubectl/cmd/util/openapi/testing"
+)
+
+// run parses the openapi and runs the tests
+func run(instance apply.Strategy, recorded, local, remote, expected map[string]interface{}) {
+	runWith(instance, recorded, local, remote, expected,
+		filepath.Join("..", "..", "..", "..", "api", "openapi-spec", "swagger.json"))
+}
+
+func runWith(instance apply.Strategy, recorded, local, remote, expected map[string]interface{}, swaggerPath string) {
+	fakeSchema := tst.Fake{Path: swaggerPath}
+	s, err := fakeSchema.OpenAPISchema()
+	Expect(err).To(BeNil())
+	resources, err := openapi.NewOpenAPIData(s)
+	Expect(err).To(BeNil())
+	parseFactory := parse.Factory{resources}
+
+	parsed, err := parseFactory.CreateElement(recorded, local, remote)
+	Expect(err).Should(Not(HaveOccurred()))
+
+	merged, err := parsed.Merge(instance)
+	Expect(err).ShouldNot(HaveOccurred())
+	Expect(merged.Operation).Should(Equal(apply.SET))
+	Expect(merged.MergedResult).Should(Equal(expected), diff.ObjectDiff(merged.MergedResult, expected))
+}
+
+// create parses the yaml string into a map[string]interface{}.  Verifies that the string does not have
+// any tab characters.
+func create(config string) map[string]interface{} {
+	result := map[string]interface{}{}
+
+	// The yaml parser will throw an obscure error if there are tabs in the yaml.  Check for this
+	Expect(strings.Contains(config, "\t")).To(
+		BeFalse(), fmt.Sprintf("Yaml %s cannot contain tabs", config))
+	Expect(yaml.Unmarshal([]byte(config), &result)).Should(
+		Not(HaveOccurred()), fmt.Sprintf("Could not parse config:\n\n%s\n", config))
+
+	return result
+}

pkg/kubectl/apply/type_element.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 apply
+
+// TypeElement contains the recorded, local and remote values for a field
+// that is a complex type
+type TypeElement struct {
+	// FieldMetaImpl contains metadata about the field from openapi
+	FieldMetaImpl
+
+	// HasElementData contains whether the field was set
+	HasElementData
+
+	// ListElementData contains the value a field was set to
+	MapElementData
+
+	// Values contains the combined recorded-local-remote value of each field in the type
+	// Values contains the values in mapElement.  Element must contain
+	// a Name matching its key in Values
+	Values map[string]Element
+}
+
+// Merge implements Element.Merge
+func (e TypeElement) Merge(v Strategy) (Result, error) {
+	return v.MergeType(e)
+}
+
+// GetValues implements Element.GetValues
+func (e TypeElement) GetValues() map[string]Element {
+	return e.Values
+}
+
+var _ Element = &TypeElement{}

pkg/kubectl/apply/visitor.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 apply
+
+// Strategy implements a strategy for merging recorded, local and remote values contained
+// in an element and returns the merged result.
+// Follows the visitor pattern
+type Strategy interface {
+	// MergeList is invoked by ListElements when Merge is called
+	MergeList(ListElement) (Result, error)
+
+	// MergeMap is invoked by MapElements when Merge is called
+	MergeMap(MapElement) (Result, error)
+
+	// MergeType is invoked by TypeElements when Merge is called
+	MergeType(TypeElement) (Result, error)
+
+	// MergePrimitive is invoked by PrimitiveElements when Merge is called
+	MergePrimitive(PrimitiveElement) (Result, error)
+
+	// MergeEmpty is invoked by EmptyElements when Merge is called
+	MergeEmpty(EmptyElement) (Result, error)
+}
+
+// Operation records whether a field should be set or dropped
+type Operation int
+
+const (
+	// ERROR is an error during merge
+	ERROR Operation = iota
+	// SET sets the field on an object
+	SET
+	// DROP drops the field from an object
+	DROP
+)
+
+// Result is the result of merging fields
+type Result struct {
+	// Operation is the operation that should be performed for the merged field
+	Operation Operation
+	// MergedResult is the new merged value
+	MergedResult interface{}
+}
+
+// MapValuesElement exposes how to get the field / key - value pairs out of a Map or Type Element
+type MapValuesElement interface {
+	Element
+	GetValues() map[string]Element
+}