fix init nil pointer and improve config save and split

Author: 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{},

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")
 		}
 
+		if configRaw.Version == nil || *configRaw.Version != CurrentConfigVersion {
+			log.Fatal("Your config is out of date. Please run `devspace init -r` to update your config")
+		}
+
 		//ignore error as overwrite.yaml is optional
-		loadConfig(overwriteConfigRaw, OverwriteConfigPath)
+		loadConfig(overwriteConfig, OverwriteConfigPath)
 
 		Merge(&config, configRaw)
-		Merge(&overwriteConfig, overwriteConfigRaw)
 		Merge(&config, overwriteConfig)
 
-		if config.Version == nil || *config.Version != CurrentConfigVersion {
-			log.Fatal("Your config is out of date. Please run `devspace init -r` to update your config")
-		}
-
-		SetDefaults(config)
+		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

@@ -13,24 +13,18 @@ type pointerInterface struct {
 // 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)
+	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()
 		overwriteObjectType := reflect.TypeOf(overwriteObject)
 		overwriteObjectKind := overwriteObjectType.Kind()
 		objectPointerRef := reflect.ValueOf(objectPointerReal)
+
 		var objectRef reflect.Value
 
 		if !objectPointerRef.IsNil() {
@@ -90,6 +84,9 @@ func merge(objectPointer interface{}, overwriteObjectPointer interface{}, object
 				}
 			}
 		default:
+			objectPointerUnsafe := (*(*pointerInterface)(unsafe.Pointer(&object))).Data
+			overwriteObjectPointerUnsafe := (*(*pointerInterface)(unsafe.Pointer(&overwriteObject))).Data
+
 			*(*unsafe.Pointer)(objectPointerUnsafe) = overwriteObjectPointerUnsafe
 		}
 	}