fix issue #314 and improve config split, merge and save

Author: gentele

cmd/init.go

@@ -152,7 +152,7 @@ func (cmd *InitCmd) Run(cobraCmd *cobra.Command, args []string) {
 				Auth: &v1.RegistryAuth{},
 			},
 		},
-	})
+	}, false)
 
 	imageMap := *config.Images
 	cmd.defaultImage = imageMap["default"]

pkg/devspace/config/configutil/get.go

@@ -1,6 +1,7 @@
 package configutil
 
 import (
+	"fmt"
 	"os"
 	"sync"
 
@@ -89,8 +90,44 @@ func GetConfig() *v1.Config {
 		//ignore error as overwrite.yaml is optional
 		loadConfig(overwriteConfig, OverwriteConfigPath)
 
-		Merge(&config, configRaw)
-		Merge(&config, overwriteConfig)
+		configImages := *config.Images
+		configImageDefault := configImages["default"]
+		configRawImages := *configRaw.Images
+		configRawImageDefault := configRawImages["default"]
+
+		fmt.Println(configRawImageDefault.Name)
+
+		fmt.Println("")
+		fmt.Println("merge config")
+
+		Merge(&config, configRaw, false)
+
+		configImages = *config.Images
+		configImageDefault = configImages["default"]
+		configRawImages = *configRaw.Images
+		configRawImageDefault = configRawImages["default"]
+
+		fmt.Println(configImageDefault.Name)
+		fmt.Println(configRawImageDefault.Name)
+
+		fmt.Println("")
+		fmt.Println("merge overwrite config")
+
+		Merge(&config, overwriteConfig, true)
+
+		configImages = *config.Images
+		configImageDefault = configImages["default"]
+		configRawImages = *configRaw.Images
+		configRawImageDefault = configRawImages["default"]
+
+		fmt.Println(configImageDefault.Name)
+		fmt.Println(configRawImageDefault.Name)
+
+		configOverwriteImages := *configRaw.Images
+		configOverwriteImageDefault := configOverwriteImages["default"]
+
+		fmt.Println(configOverwriteImageDefault.Name)
+		fmt.Println(*configOverwriteImageDefault.Name)
 
 		SetDefaultsOnce()
 	})

pkg/devspace/config/configutil/merge.go

@@ -3,6 +3,8 @@ package configutil
 import (
 	"reflect"
 	"unsafe"
+
+	"gopkg.in/yaml.v2"
 )
 
 type pointerInterface struct {
@@ -12,7 +14,7 @@ type pointerInterface struct {
 // Merge deeply merges two objects
 // object MUST be a pointer of a pointer
 // overwriteObject MUST be a pointer
-func Merge(object interface{}, overwriteObject interface{}) {
+func Merge(object interface{}, overwriteObject interface{}, unifyPointers bool) {
 	overwriteObjectRef := reflect.ValueOf(overwriteObject)
 
 	if !overwriteObjectRef.IsNil() {
@@ -21,6 +23,13 @@ func Merge(object interface{}, overwriteObject interface{}) {
 		}
 		objectPointerReal := reflect.ValueOf(object).Elem().Interface()
 		overwriteObject := overwriteObjectRef.Interface()
+
+		if !unifyPointers {
+			overwriteObject = deepCopy(overwriteObject)
+
+			// ensure deepCopy only runs once
+			unifyPointers = true
+		}
 		overwriteObjectType := reflect.TypeOf(overwriteObject)
 		overwriteObjectKind := overwriteObjectType.Kind()
 		objectPointerRef := reflect.ValueOf(objectPointerReal)
@@ -53,10 +62,10 @@ func Merge(object interface{}, overwriteObject interface{}) {
 					overwriteValue := getMapValue(overwriteObject, key, genericPointerType)
 					valuePointerRef := objectRef.MapIndex(keyRef)
 
-					if isZero(valuePointerRef) == false {
+					if isZero(valuePointerRef) == false && !isTrivialDataType(valuePointerRef) {
 						valuePointer := valuePointerRef.Interface()
 
-						Merge(&valuePointer, overwriteValue)
+						Merge(&valuePointer, overwriteValue, unifyPointers)
 					} else {
 						keyRef := reflect.ValueOf(key)
 						overwriteValueRef := reflect.ValueOf(overwriteValue)
@@ -68,18 +77,17 @@ func Merge(object interface{}, overwriteObject interface{}) {
 		case reflect.Struct:
 			for i := 0; i < overwriteObjectRef.NumField(); i++ {
 				overwriteValueRef := overwriteObjectRef.Field(i)
-				overwriteValuePointerRef := reflect.ValueOf(overwriteValueRef.Interface())
 
-				if !overwriteValuePointerRef.IsNil() {
+				if !overwriteValueRef.IsNil() {
 					overwriteValue := overwriteValueRef.Interface()
 					valuePointerRef := objectRef.Field(i)
 
-					if valuePointerRef.IsNil() {
-						valuePointerRef.Set(reflect.ValueOf(overwriteValue))
+					if valuePointerRef.IsNil() || isTrivialDataType(valuePointerRef) {
+						valuePointerRef.Set(overwriteValueRef)
 					} else {
 						valuePointer := valuePointerRef.Interface()
 
-						Merge(&valuePointer, overwriteValue)
+						Merge(&valuePointer, overwriteValue, unifyPointers)
 					}
 				}
 			}
@@ -91,3 +99,32 @@ func Merge(object interface{}, overwriteObject interface{}) {
 		}
 	}
 }
+
+func isTrivialDataType(value reflect.Value) bool {
+	valueType := value.Type()
+
+	if valueType.Kind() == reflect.Ptr {
+		valueType = valueType.Elem()
+	}
+
+	switch valueType.Kind() {
+	case reflect.Slice:
+		return false
+	case reflect.Map:
+		return false
+	case reflect.Struct:
+		return false
+	}
+	return true
+}
+
+func deepCopy(from interface{}) interface{} {
+	yamlData, _ := yaml.Marshal(from)
+	objectType := reflect.TypeOf(from)
+
+	copy := reflect.New(objectType).Interface()
+
+	yaml.Unmarshal(yamlData, copy)
+
+	return copy
+}

pkg/devspace/config/configutil/save.go

@@ -16,8 +16,8 @@ func SaveConfig() error {
 	// default and overwrite values
 	configToIgnore := makeConfig()
 
-	Merge(&configToIgnore, defaultConfig)
-	Merge(&configToIgnore, overwriteConfig)
+	Merge(&configToIgnore, defaultConfig, true)
+	Merge(&configToIgnore, overwriteConfig, true)
 
 	// generates config without default and overwrite values
 	configMapRaw, _, err := splitConfigs(config, configRaw, configToIgnore)

pkg/devspace/config/configutil/split.go

@@ -142,7 +142,7 @@ func splitConfigs(config interface{}, configRaw interface{}, overwriteConfig int
 				fieldRaw := objectRawValueRef.Field(i).Elem()
 				overwriteField := overwriteValueRef.Field(i).Elem()
 
-				fieldValue := field.Interface()
+				fieldValue := reflect.New(fieldType).Interface()
 				fieldRawValue := reflect.New(fieldType).Interface()
 				overwriteFieldValue := reflect.New(fieldType).Interface()
 
@@ -151,6 +151,7 @@ func splitConfigs(config interface{}, configRaw interface{}, overwriteConfig int
 				isFieldRawNil := true
 
 				if !isZero(field) {
+					fieldValue = field.Elem().Interface()
 					isFieldNil = false
 				}
 
@@ -166,20 +167,14 @@ func splitConfigs(config interface{}, configRaw interface{}, overwriteConfig int
 				var fieldValueClean, overwriteFieldValueClean interface{}
 				var err error
 
-				fieldKind := fieldType.Kind()
-
-				if fieldKind == reflect.Map || fieldKind == reflect.Slice || fieldKind == reflect.Struct {
-					fieldValueClean, overwriteFieldValueClean, err = splitConfigs(
-						fieldValue,
-						fieldRawValue,
-						overwriteFieldValue,
-					)
+				if isTrivialDataType(field) {
+					saveField := ((!isFieldNil && !saveOverwriteField) || !isFieldRawNil)
 
-					if err != nil {
-						return nil, nil, err
+					if saveField && saveOverwriteField {
+						if isTrivialOverwrite(fieldValue, overwriteFieldValue, fieldRawValue) {
+							fieldValue = fieldRawValue
+						}
 					}
-				} else {
-					saveField := ((!isFieldNil && !saveOverwriteField) || !isFieldRawNil)
 
 					if saveField {
 						fieldValueClean = fieldValue
@@ -188,6 +183,16 @@ func splitConfigs(config interface{}, configRaw interface{}, overwriteConfig int
 					if saveOverwriteField {
 						overwriteFieldValueClean = overwriteFieldValue
 					}
+				} else {
+					fieldValueClean, overwriteFieldValueClean, err = splitConfigs(
+						fieldValue,
+						fieldRawValue,
+						overwriteFieldValue,
+					)
+
+					if err != nil {
+						return nil, nil, err
+					}
 				}
 
 				if fieldValueClean != nil {
@@ -212,6 +217,10 @@ func splitConfigs(config interface{}, configRaw interface{}, overwriteConfig int
 		saveOverwriteValue := !isOverwriteObjectNil
 		saveValue := ((!isObjectNil && !saveOverwriteValue) || !isObjectRawNil)
 
+		if saveValue && saveOverwriteValue {
+			saveValue = !isTrivialOverwrite(objectValueRef, overwriteObject, objectRawValue)
+		}
+
 		//TODO: Determine overwritten values and set objectValue accordingly
 
 		if saveValue && saveOverwriteValue {
@@ -225,6 +234,18 @@ func splitConfigs(config interface{}, configRaw interface{}, overwriteConfig int
 	}
 }
 
+func isTrivialOverwrite(objectValue, overwriteValue, objectRawValue interface{}) bool {
+	objectValueRef := reflect.ValueOf(objectValue)
+
+	if isTrivialDataType(objectValueRef) {
+		if reflect.DeepEqual(objectValue, overwriteValue) && !reflect.DeepEqual(objectValue, objectRawValue) {
+			// do not save the value if it is equal to the overwriteValue and is different than rawValue
+			return true
+		}
+	}
+	return false
+}
+
 func getMapValue(valueMap interface{}, key interface{}, refType reflect.Type) interface{} {
 	valueMapValue, _ := getPointerValue(valueMap)
 	mapRef := reflect.ValueOf(valueMapValue)