Merge pull request #320 from covexo/issue-315

Issue 315

Author: Lukas Gentele

cmd/init.go

@@ -134,7 +134,7 @@ func (cmd *InitCmd) Run(cobraCmd *cobra.Command, args []string) {
 		}
 	}
 
-	configutil.Merge(config, &v1.Config{
+	configutil.Merge(&config, &v1.Config{
 		Version: configutil.String(configutil.CurrentConfigVersion),
 		DevSpace: &v1.DevSpaceConfig{
 			Deployments: &[]*v1.DeploymentConfig{},
@@ -152,7 +152,7 @@ func (cmd *InitCmd) Run(cobraCmd *cobra.Command, args []string) {
 				Auth: &v1.RegistryAuth{},
 			},
 		},
-	})
+	}, true)
 
 	imageMap := *config.Images
 	cmd.defaultImage = imageMap["default"]
@@ -259,21 +259,21 @@ func (cmd *InitCmd) useCloudProvider() bool {
 			err := cloud.Update(providerConfig, config, addToContext, true)
 			log.StopWait()
 			if err != nil {
-				log.Fatalf("Couldn't authenticate to devspace cloud: %v", err)
+				log.Fatalf("Couldn't authenticate to DevSpace Cloud: %v", err)
 			}
 
 			return true
 		}
 	} else {
 		useDevSpaceCloud := *stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
-			Question:               "Do you want to use the devspace cloud? (free ready-to-use kubernetes) (yes | no)",
+			Question:               "Do you want to use the DevSpace Cloud? (free ready-to-use Kubernetes) (yes | no)",
 			DefaultValue:           "yes",
 			ValidationRegexPattern: "^(yes)|(no)$",
 		}) == "yes"
 
 		if useDevSpaceCloud {
 			addToContext := *stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
-				Question:               "Do you want to add the devspace-cloud to the $HOME/.kube/config file? (yes | no)",
+				Question:               "Do you want to add the DevSpace Cloud to the $HOME/.kube/config file? (yes | no)",
 				DefaultValue:           "yes",
 				ValidationRegexPattern: "^(yes)|(no)$",
 			}) == "yes"
@@ -284,7 +284,7 @@ func (cmd *InitCmd) useCloudProvider() bool {
 			err := cloud.Update(providerConfig, config, addToContext, true)
 			log.StopWait()
 			if err != nil {
-				log.Fatalf("Couldn't authenticate to devspace cloud: %v", err)
+				log.Fatalf("Couldn't authenticate to DevSpace Cloud: %v", err)
 			}
 
 			return true

cmd/up.go

@@ -121,8 +121,7 @@ func (cmd *UpCmd) Run(cobraCmd *cobra.Command, args []string) {
 		initCmd.Run(nil, []string{})
 
 		// Ensure that config is initialized correctly
-		config := configutil.GetConfig()
-		configutil.SetDefaults(config)
+		configutil.SetDefaultsOnce()
 	}
 
 	// Create kubectl client

pkg/devspace/config/configutil/get.go

@@ -31,13 +31,14 @@ const DefaultDevspaceDeploymentName = "devspace-default"
 const CurrentConfigVersion = "v1alpha1"
 
 // Global config vars
-var config *v1.Config
-var configRaw *v1.Config
-var overwriteConfig *v1.Config
-var overwriteConfigRaw *v1.Config
+var config *v1.Config          // merged config
+var configRaw *v1.Config       // config from .devspace/config.yaml
+var overwriteConfig *v1.Config // overwrite config from .devspace/config.yaml
+var defaultConfig *v1.Config   // default config values
 
 // Thread-safety helper
 var getConfigOnce sync.Once
+var setDefaultsOnce sync.Once
 
 // ConfigExists checks whether the yaml file for the config exists
 func ConfigExists() (bool, error) {
@@ -57,9 +58,10 @@ func ConfigExists() (bool, error) {
 func InitConfig() *v1.Config {
 	getConfigOnce.Do(func() {
 		config = makeConfig()
+		overwriteConfig = makeConfig()
 		configRaw = makeConfig()
 		overwriteConfig = makeConfig()
-		overwriteConfigRaw = makeConfig()
+		defaultConfig = makeConfig()
 	})
 
 	return config
@@ -69,28 +71,28 @@ func InitConfig() *v1.Config {
 func GetConfig() *v1.Config {
 	getConfigOnce.Do(func() {
 		config = makeConfig()
+		overwriteConfig = makeConfig()
 		configRaw = makeConfig()
 		overwriteConfig = makeConfig()
-		overwriteConfigRaw = makeConfig()
+		defaultConfig = makeConfig()
 
 		err := loadConfig(configRaw, ConfigPath)
 		if err != nil {
 			log.Errorf("Loading config: %v", err)
 			log.Fatal("Please run `devspace init -r` to repair your config")
 		}
 
-		//ignore error as overwrite.yaml is optional
-		loadConfig(overwriteConfigRaw, OverwriteConfigPath)
-
-		Merge(&config, configRaw)
-		Merge(&overwriteConfig, overwriteConfigRaw)
-		Merge(&config, overwriteConfig)
-
-		if config.Version == nil || *config.Version != CurrentConfigVersion {
+		if configRaw.Version == nil || *configRaw.Version != CurrentConfigVersion {
 			log.Fatal("Your config is out of date. Please run `devspace init -r` to update your config")
 		}
 
-		SetDefaults(config)
+		//ignore error as overwrite.yaml is optional
+		loadConfig(overwriteConfig, OverwriteConfigPath)
+
+		Merge(&config, configRaw, false)
+		Merge(&config, overwriteConfig, true)
+
+		SetDefaultsOnce()
 	})
 
 	return config
@@ -103,67 +105,78 @@ func GetOverwriteConfig() *v1.Config {
 	return overwriteConfig
 }
 
-// SetDefaults ensures that specific values are set in the config
-func SetDefaults(config *v1.Config) {
-	defaultNamespace, err := GetDefaultNamespace(config)
-	if err != nil {
-		log.Fatalf("Error retrieving default namespace: %v", err)
-	}
-
-	// Initialize Namespaces
-	if config.DevSpace != nil {
-		needTiller := config.InternalRegistry != nil
+// SetDefaultsOnce ensures that specific values are set in the config
+func SetDefaultsOnce() {
+	setDefaultsOnce.Do(func() {
+		defaultNamespace, err := GetDefaultNamespace(config)
+		if err != nil {
+			log.Fatalf("Error retrieving default namespace: %v", err)
+		}
 
-		if config.DevSpace.Deployments != nil {
-			for index, deployConfig := range *config.DevSpace.Deployments {
-				if deployConfig.Name == nil {
-					log.Fatalf("Error in config: Unnamed deployment at index %d", index)
-				}
-				if deployConfig.Namespace == nil {
-					deployConfig.Namespace = String("")
-				}
-				if deployConfig.Helm != nil {
-					needTiller = true
+		// Initialize Namespaces
+		if config.DevSpace != nil {
+			needTiller := config.InternalRegistry != nil
+
+			if config.DevSpace.Deployments != nil {
+				for index, deployConfig := range *config.DevSpace.Deployments {
+					if deployConfig.Name == nil {
+						log.Fatalf("Error in config: Unnamed deployment at index %d", index)
+					}
+
+					if deployConfig.Namespace == nil {
+						defaultDeployments := *defaultConfig.DevSpace.Deployments
+						defaultValue := String("")
+
+						defaultDeployments = append(defaultDeployments, &v1.DeploymentConfig{
+							Namespace: defaultValue,
+						})
+						defaultConfig.DevSpace.Deployments = &defaultDeployments
+						deployConfig.Namespace = defaultValue
+					}
+
+					if deployConfig.Helm != nil {
+						needTiller = true
+					}
 				}
 			}
-		}
 
-		if config.DevSpace.Sync != nil {
-			for _, syncPath := range *config.DevSpace.Sync {
-				if syncPath.Namespace == nil {
-					syncPath.Namespace = String("")
+			if config.DevSpace.Sync != nil {
+				for _, syncPath := range *config.DevSpace.Sync {
+					if syncPath.Namespace == nil {
+						syncPath.Namespace = String("")
+					}
 				}
 			}
-		}
 
-		if config.DevSpace.Ports != nil {
-			for _, portForwarding := range *config.DevSpace.Ports {
-				if portForwarding.Namespace == nil {
-					portForwarding.Namespace = String("")
+			if config.DevSpace.Ports != nil {
+				for _, portForwarding := range *config.DevSpace.Ports {
+					if portForwarding.Namespace == nil {
+						portForwarding.Namespace = String("")
+					}
 				}
 			}
-		}
 
-		if needTiller && config.Tiller == nil {
-			config.Tiller = &v1.TillerConfig{
-				Namespace: &defaultNamespace,
+			if needTiller && config.Tiller == nil {
+				config.Tiller = &v1.TillerConfig{
+					Namespace: &defaultNamespace,
+				}
 			}
 		}
-	}
 
-	if config.Images != nil {
-		for _, buildConfig := range *config.Images {
-			if buildConfig.Build != nil && buildConfig.Build.Kaniko != nil {
-				if buildConfig.Build.Kaniko.Namespace == nil {
-					buildConfig.Build.Kaniko.Namespace = String("")
+		if config.Images != nil {
+			for _, buildConfig := range *config.Images {
+				if buildConfig.Build != nil && buildConfig.Build.Kaniko != nil {
+					if buildConfig.Build.Kaniko.Namespace == nil {
+						buildConfig.Build.Kaniko.Namespace = String("")
+					}
 				}
 			}
 		}
-	}
 
-	if config.InternalRegistry != nil {
-		config.InternalRegistry.Namespace = &defaultNamespace
-	}
+		if config.InternalRegistry != nil {
+			config.InternalRegistry.Namespace = &defaultNamespace
+		}
+	})
 }
 
 // GetDefaultNamespace retrieves the default namespace where to operate in, either from devspace config or kube config

pkg/devspace/config/configutil/merge.go

@@ -3,6 +3,8 @@ package configutil
 import (
 	"reflect"
 	"unsafe"
+
+	"gopkg.in/yaml.v2"
 )
 
 type pointerInterface struct {
@@ -12,25 +14,26 @@ 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{}) {
-	objectPointerUnsafe := (*(*pointerInterface)(unsafe.Pointer(&object))).Data
-	overwriteObjectPointerUnsafe := (*(*pointerInterface)(unsafe.Pointer(&overwriteObject))).Data
-
-	merge(object, overwriteObject, objectPointerUnsafe, overwriteObjectPointerUnsafe)
-}
-
-func merge(objectPointer interface{}, overwriteObjectPointer interface{}, objectPointerUnsafe unsafe.Pointer, overwriteObjectPointerUnsafe unsafe.Pointer) {
-	overwriteObjectRef := reflect.ValueOf(overwriteObjectPointer)
+func Merge(object interface{}, overwriteObject interface{}, unifyPointers bool) {
+	overwriteObjectRef := reflect.ValueOf(overwriteObject)
 
 	if !overwriteObjectRef.IsNil() {
 		if overwriteObjectRef.Kind() == reflect.Ptr {
 			overwriteObjectRef = overwriteObjectRef.Elem()
 		}
-		objectPointerReal := reflect.ValueOf(objectPointer).Elem().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)
+
 		var objectRef reflect.Value
 
 		if !objectPointerRef.IsNil() {
@@ -59,10 +62,10 @@ func merge(objectPointer interface{}, overwriteObjectPointer interface{}, object
 					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)
@@ -74,23 +77,54 @@ func merge(objectPointer interface{}, overwriteObjectPointer interface{}, object
 		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)
 					}
 				}
 			}
 		default:
+			objectPointerUnsafe := (*(*pointerInterface)(unsafe.Pointer(&object))).Data
+			overwriteObjectPointerUnsafe := (*(*pointerInterface)(unsafe.Pointer(&overwriteObject))).Data
+
 			*(*unsafe.Pointer)(objectPointerUnsafe) = overwriteObjectPointerUnsafe
 		}
 	}
 }
+
+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
+}