Introduce ResId and ResMap.

pkg/resmap/resmap.go

@@ -0,0 +1,247 @@
+package resmap
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+
+	"github.com/ghodss/yaml"
+	"github.com/golang/glog"
+	"github.com/kubernetes-sigs/kustomize/pkg/loader"
+	"github.com/kubernetes-sigs/kustomize/pkg/resource"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	k8syaml "k8s.io/apimachinery/pkg/util/yaml"
+)
+
+// ResMap is a map from ResId to Resource
+type ResMap map[resource.ResId]*resource.Resource
+
+// EncodeAsYaml encodes a ResMap to YAML; encoded objects separated by `---`.
+func (m ResMap) EncodeAsYaml() ([]byte, error) {
+	ids := []resource.ResId{}
+	for gvkn := range m {
+		ids = append(ids, gvkn)
+	}
+	sort.Sort(IdSlice(ids))
+
+	firstObj := true
+	var b []byte
+	buf := bytes.NewBuffer(b)
+	for _, id := range ids {
+		obj := m[id].Unstruct()
+		out, err := yaml.Marshal(obj)
+		if err != nil {
+			return nil, err
+		}
+		if firstObj {
+			firstObj = false
+		} else {
+			_, err = buf.WriteString("---\n")
+			if err != nil {
+				return nil, err
+			}
+		}
+		_, err = buf.Write(out)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return buf.Bytes(), nil
+}
+
+func (m1 ResMap) ErrorIfNotEqual(m2 ResMap) error {
+	if len(m1) != len(m2) {
+		keySet1 := []resource.ResId{}
+		keySet2 := []resource.ResId{}
+		for id := range m1 {
+			keySet1 = append(keySet1, id)
+		}
+		for id := range m2 {
+			keySet2 = append(keySet2, id)
+		}
+		return fmt.Errorf("maps has different number of entries: %#v doesn't equals %#v", keySet1, keySet2)
+	}
+	for id, obj1 := range m1 {
+		obj2, found := m2[id]
+		if !found {
+			return fmt.Errorf("%#v doesn't exist in %#v", id, m2)
+		}
+		if !reflect.DeepEqual(obj1.Unstruct(), obj2.Unstruct()) {
+			return fmt.Errorf("%#v doesn't match %#v", obj1.Unstruct(), obj2.Unstruct())
+		}
+	}
+	return nil
+}
+
+func (m ResMap) insert(newName string, obj *unstructured.Unstructured) error {
+	oldName := obj.GetName()
+	gvk := obj.GroupVersionKind()
+	id := resource.NewResId(gvk, oldName)
+
+	if _, found := m[id]; found {
+		return fmt.Errorf("The <name: %q, GroupVersionKind: %v> already exists in the map", oldName, gvk)
+	}
+	obj.SetName(newName)
+	m[id] = resource.NewBehaviorlessResource(obj)
+	return nil
+}
+
+// NewResourceSliceFromPatches returns a slice of Resources given a patch path slice from kustomization file.
+func NewResourceSliceFromPatches(
+	loader loader.Loader, paths []string) ([]*resource.Resource, error) {
+	result := []*resource.Resource{}
+	for _, path := range paths {
+		content, err := loader.Load(path)
+		if err != nil {
+			return nil, err
+		}
+
+		res, err := newResourceSliceFromBytes(content)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, res...)
+	}
+	return result, nil
+}
+
+// NewResMapFromFiles returns a ResMap given a resource path slice.
+func NewResMapFromFiles(loader loader.Loader, paths []string) (ResMap, error) {
+	result := []ResMap{}
+	for _, path := range paths {
+		content, err := loader.Load(path)
+		if err != nil {
+			return nil, err
+		}
+
+		res, err := newResMapFromBytes(content)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, res)
+	}
+	return Merge(result...)
+}
+
+// newResMapFromBytes decodes a list of objects in byte array format.
+func newResMapFromBytes(b []byte) (ResMap, error) {
+	resources, err := newResourceSliceFromBytes(b)
+	if err != nil {
+		return nil, err
+	}
+
+	result := ResMap{}
+	for _, res := range resources {
+		gvkn := res.Id()
+		if _, found := result[gvkn]; found {
+			return result, fmt.Errorf("GroupVersionKindName: %#v already exists b the map", gvkn)
+		}
+		result[gvkn] = res
+	}
+	return result, nil
+}
+
+func newResMapFromResourceSlice(resources []*resource.Resource) (ResMap, error) {
+	result := ResMap{}
+	for _, res := range resources {
+		gvkn := res.Id()
+		if _, found := result[gvkn]; found {
+			return nil, fmt.Errorf("duplicated %#v is not allowed", gvkn)
+		}
+		result[gvkn] = res
+	}
+	return result, nil
+}
+
+func newResourceSliceFromBytes(in []byte) ([]*resource.Resource, error) {
+	decoder := k8syaml.NewYAMLOrJSONDecoder(bytes.NewReader(in), 1024)
+	result := []*resource.Resource{}
+
+	var err error
+	for {
+		var out unstructured.Unstructured
+		err = decoder.Decode(&out)
+		if err != nil {
+			break
+		}
+		result = append(result, resource.NewBehaviorlessResource(&out))
+	}
+	if err != io.EOF {
+		return nil, err
+	}
+	return result, nil
+}
+
+// Merge combines many maps to one.
+func Merge(maps ...ResMap) (ResMap, error) {
+	result := ResMap{}
+	for _, m := range maps {
+		for gvkn, obj := range m {
+			if _, found := result[gvkn]; found {
+				return nil, fmt.Errorf("there is already an entry: %q", gvkn)
+			}
+			result[gvkn] = obj
+		}
+	}
+
+	return result, nil
+}
+
+const behaviorCreate = "create"
+const behaviorReplace = "replace"
+const behaviorMerge = "merge"
+
+// MergeWithOverride merges the entries in the ResMap slice with Override.
+// If there is already an entry with the same Id , different actions are performed
+// according to value of behavior field:
+// 'create': create a new one;
+// 'replace': replace the data only; keep the labels and annotations
+// 'merge': merge the data; keep the labels and annotations
+func MergeWithOverride(maps ...ResMap) (ResMap, error) {
+	result := ResMap{}
+	for _, m := range maps {
+		for gvkn, resource := range m {
+			if _, found := result[gvkn]; found {
+				switch resource.Behavior() {
+				case "", behaviorCreate:
+					return nil, fmt.Errorf("Create an existing gvkn %#v is not allowed", gvkn)
+				case behaviorReplace:
+					glog.V(4).Infof("Replace object %v by %v", result[gvkn].Unstruct().Object, resource.Unstruct().Object)
+					resource.Replace(result[gvkn])
+					result[gvkn] = resource
+				case behaviorMerge:
+					glog.V(4).Infof("Merge object %v with %v", result[gvkn].Unstruct().Object, resource.Unstruct().Object)
+					resource.Merge(result[gvkn])
+					result[gvkn] = resource
+					glog.V(4).Infof("The merged object is %v", result[gvkn].Unstruct().Object)
+				default:
+					return nil, fmt.Errorf("The behavior of %#v must be one of merge and replace since it already exists in the base", gvkn)
+				}
+			} else {
+				switch resource.Behavior() {
+				case "", behaviorCreate:
+					result[gvkn] = resource
+				case behaviorMerge, behaviorReplace:
+					return nil, fmt.Errorf("No merge or replace is allowed for non existing gvkn %#v", gvkn)
+				default:
+					return nil, fmt.Errorf("The behavior of %#v must be create since it doesn't exist", gvkn)
+				}
+			}
+		}
+	}
+	return result, nil
+}
+
+func newUnstructuredFromObject(in runtime.Object) (*unstructured.Unstructured, error) {
+	marshaled, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	var out unstructured.Unstructured
+	err = out.UnmarshalJSON(marshaled)
+	return &out, err
+}