Breaking config changes

Author: FabianKramm

cmd/add.go

@@ -312,7 +312,7 @@ func (cmd *AddCmd) RunAddSync(cobraCmd *cobra.Command, args []string) {
 	config := configutil.GetConfig()
 
 	if cmd.syncFlags.Selector == "" {
-		cmd.syncFlags.Selector = "release=" + *config.DevSpace.Release.Name
+		cmd.syncFlags.Selector = "release=" + *configutil.GetDefaultDevSpaceDefaultReleaseName(config)
 	}
 
 	labelSelectorMap, err := parseSelectors(cmd.syncFlags.Selector)
@@ -365,25 +365,22 @@ func (cmd *AddCmd) RunAddPort(cobraCmd *cobra.Command, args []string) {
 	config := configutil.GetConfig()
 
 	if cmd.portFlags.Selector == "" {
-		cmd.portFlags.Selector = "release=" + *config.DevSpace.Release.Name
+		cmd.portFlags.Selector = "release=" + *configutil.GetDefaultDevSpaceDefaultReleaseName(config)
 	}
 
 	labelSelectorMap, err := parseSelectors(cmd.portFlags.Selector)
-
 	if err != nil {
 		log.Fatalf("Error parsing selectors: %s", err.Error())
 	}
 
 	portMappings, err := parsePortMappings(args[0])
-
 	if err != nil {
 		log.Fatalf("Error parsing port mappings: %s", err.Error())
 	}
 
 	cmd.insertOrReplacePortMapping(labelSelectorMap, portMappings)
 
 	err = configutil.SaveConfig()
-
 	if err != nil {
 		log.Fatalf("Couldn't save config file: %s", err.Error())
 	}

cmd/down.go

@@ -3,8 +3,10 @@ package cmd
 import (
 	"github.com/covexo/devspace/pkg/devspace/config/configutil"
 	helmClient "github.com/covexo/devspace/pkg/devspace/deploy/helm"
+	deployKubectl "github.com/covexo/devspace/pkg/devspace/deploy/kubectl"
 	"github.com/covexo/devspace/pkg/devspace/kubectl"
 	"github.com/covexo/devspace/pkg/util/log"
+	"k8s.io/client-go/kubernetes"
 
 	"github.com/spf13/cobra"
 )
@@ -43,30 +45,72 @@ your project, use: devspace reset
 // Run executes the down command logic
 func (cmd *DownCmd) Run(cobraCmd *cobra.Command, args []string) {
 	log.StartFileLogging()
-	config := configutil.GetConfig()
-
-	releaseName := *config.DevSpace.Release.Name
 	kubectl, err := kubectl.NewClient()
-
 	if err != nil {
 		log.Fatalf("Unable to create new kubectl client: %s", err.Error())
 	}
 
-	client, err := helmClient.NewClient(kubectl, false)
+	deleteDevSpace(kubectl)
+}
 
-	if err != nil {
-		log.Fatalf("Unable to initialize helm client: %s", err.Error())
-	}
+func deleteDevSpace(kubectl *kubernetes.Clientset) {
+	var err error
+	var client *helmClient.ClientWrapper
+
+	config := configutil.GetConfig()
+
+	if config.DevSpace.Deploy != nil {
+		for _, deployConfig := range *config.DevSpace.Deploy {
+			// Delete kubectl engine
+			if deployConfig.Engine != nil && deployConfig.Engine.Kubectl != nil {
+				kubectlDeployConfig, err := deployKubectl.New(config, deployConfig)
+				if err != nil {
+					log.Warnf("Unable to create kubectl deploy config: %v", err)
+					continue
+				}
+
+				log.StartWait("Deleting kubectl deployment")
+				err = kubectlDeployConfig.Delete()
+				log.StopWait()
+				if err != nil {
+					log.Warnf("Error deleting kubectl manifests: %v", err)
+				}
+
+				log.Donef("Successfully deleted kubectl deployment")
+			} else {
+				// Delete with helm engine
+				defaultReleaseName := configutil.GetDefaultDevSpaceDefaultReleaseName(config)
+
+				releaseName := defaultReleaseName
+				if deployConfig.Engine != nil && deployConfig.Engine.Helm != nil && deployConfig.Engine.Helm.Release != nil {
+					releaseName = deployConfig.Engine.Helm.Release
+				}
+
+				if client == nil {
+					isDeployed := helmClient.IsTillerDeployed(kubectl)
+					if isDeployed == false {
+						continue
+					}
+
+					client, err = helmClient.NewClient(kubectl, false)
+					if err != nil {
+						log.Warnf("Unable to initialize helm client: %s", err.Error())
+						continue
+					}
+				}
 
-	log.StartWait("Deleting release " + releaseName)
-	res, err := client.DeleteRelease(releaseName, true)
-	log.StopWait()
+				log.StartWait("Deleting release " + *releaseName)
+				res, err := client.DeleteRelease(*releaseName, true)
+				log.StopWait()
 
-	if res != nil && res.Info != "" {
-		log.Donef("Successfully deleted release %s: %s", releaseName, res.Info)
-	} else if err != nil {
-		log.Donef("Error deleting release %s: %s", releaseName, err.Error())
-	} else {
-		log.Donef("Successfully deleted release %s", releaseName)
+				if res != nil && res.Info != "" {
+					log.Donef("Successfully deleted release %s: %s", releaseName, res.Info)
+				} else if err != nil {
+					log.Warnf("Error deleting release %s: %s", releaseName, err.Error())
+				} else {
+					log.Donef("Successfully deleted release %s", releaseName)
+				}
+			}
+		}
 	}
 }

cmd/init.go

@@ -122,10 +122,7 @@ func (cmd *InitCmd) Run(cobraCmd *cobra.Command, args []string) {
 	configutil.Merge(config, &v1.Config{
 		Version: configutil.String("v1"),
 		DevSpace: &v1.DevSpaceConfig{
-			Release: &v1.Release{
-				Name:      configutil.String("devspace"),
-				Namespace: configutil.String("default"),
-			},
+			Deploy: &[]*v1.DeployConfig{},
 		},
 		Images: &map[string]*v1.ImageConfig{
 			"default": &v1.ImageConfig{
@@ -200,12 +197,15 @@ func (cmd *InitCmd) initChartGenerator() {
 
 func (cmd *InitCmd) configureDevSpace() {
 	config := configutil.GetConfig()
-
-	config.DevSpace.Release.Namespace = stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
+	namespace := stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
 		Question:               "Which Kubernetes namespace should your application run in?",
-		DefaultValue:           *config.DevSpace.Release.Namespace,
+		DefaultValue:           "default",
 		ValidationRegexPattern: v1.Kubernetes.RegexPatterns.Name,
 	})
+
+	*config.DevSpace.Deploy = append(*config.DevSpace.Deploy, &v1.DeployConfig{
+		Namespace: namespace,
+	})
 }
 
 func (cmd *InitCmd) addDefaultSyncConfig() {
@@ -235,7 +235,7 @@ func (cmd *InitCmd) addDefaultSyncConfig() {
 		LocalSubPath:  configutil.String("./"),
 		ResourceType:  nil,
 		LabelSelector: &map[string]*string{
-			"release": config.DevSpace.Release.Name,
+			"release": configutil.GetDefaultDevSpaceDefaultReleaseName(config),
 		},
 		UploadExcludePaths: &uploadExcludePaths,
 	})

cmd/reset.go

@@ -77,18 +77,11 @@ func (cmd *ResetCmd) Run(cobraCmd *cobra.Command, args []string) {
 			log.Failf("Failed to initialize kubectl client: %v", err)
 		}
 	}
+
 	cmd.determineResetExtent()
 
 	if cmd.flags.deleteRelease {
-		log.StartWait("Deleting devspace release")
 		err = cmd.deleteRelease()
-		log.StopWait()
-
-		if err != nil {
-			log.Failf("Error deleting release: %s", err.Error())
-		} else {
-			log.Done("Successfully deleted release")
-		}
 	}
 
 	if cmd.flags.deleteRegistry {
@@ -255,28 +248,8 @@ func (cmd *ResetCmd) shouldContinue() bool {
 }
 
 func (cmd *ResetCmd) deleteRelease() error {
-	var err error
-	config := configutil.GetConfig()
-
-	releaseName := *config.DevSpace.Release.Name
-
-	if cmd.kubectl == nil || cmd.helm == nil {
-		isDeployed := helmClient.IsTillerDeployed(cmd.kubectl)
-
-		if isDeployed == false {
-			return nil
-		}
-
-		cmd.helm, err = helmClient.NewClient(cmd.kubectl, false)
-
-		if err != nil {
-			return err
-		}
-	}
-
-	_, err = cmd.helm.DeleteRelease(releaseName, true)
-
-	return err
+	deleteDevSpace(cmd.kubectl)
+	return nil
 }
 
 func (cmd *ResetCmd) deleteRegistry() error {

pkg/devspace/cloud/config.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/covexo/devspace/pkg/devspace/config/v1"
 	homedir "github.com/mitchellh/go-homedir"
 	yaml "gopkg.in/yaml.v2"
 )
@@ -104,3 +105,13 @@ func SaveCloudConfig(config ProviderConfig) error {
 
 	return ioutil.WriteFile(cfgPath, out, 0600)
 }
+
+// UpdateDevSpaceConfig sets the devspace config to the correct namespaces
+func UpdateDevSpaceConfig(dsConfig *v1.Config, namespace string) error {
+	// Exchange namespaces
+	for _, deployConfig := range *dsConfig.DevSpace.Deployments {
+		deployConfig.Namespace = &namespace
+	}
+
+	return nil
+}

pkg/devspace/cloud/login.go

@@ -130,7 +130,10 @@ func Update(providerConfig ProviderConfig, dsConfig *v1.Config, useKubeContext,
 		return err
 	}
 
-	dsConfig.DevSpace.Release.Namespace = &namespace
+	err = UpdateDevSpaceConfig(dsConfig, namespace)
+	if err != nil {
+		return err
+	}
 
 	if useKubeContext {
 		kubeContext := DevSpaceKubeContextName + "-" + namespace
@@ -170,15 +173,13 @@ func UpdateKubeConfig(contextName, namespace string, cluster *api.Cluster, authI
 	config.Clusters[contextName] = cluster
 	config.AuthInfos[contextName] = authInfo
 
-	// Check if we need to add the context
-	if _, ok := config.Contexts[contextName]; !ok {
-		context := api.NewContext()
-		context.Cluster = contextName
-		context.AuthInfo = contextName
-		context.Namespace = namespace
+	// Update kube context
+	context := api.NewContext()
+	context.Cluster = contextName
+	context.AuthInfo = contextName
+	context.Namespace = namespace
 
-		config.Contexts[contextName] = context
-	}
+	config.Contexts[contextName] = context
 
 	return kubeconfig.WriteKubeConfig(config, clientcmd.RecommendedHomeFile)
 }

pkg/devspace/config/configutil/get.go

@@ -78,10 +78,6 @@ func GetConfig() *v1.Config {
 		merge(config, configRaw, unsafe.Pointer(&config), unsafe.Pointer(configRaw))
 		merge(overwriteConfig, overwriteConfigRaw, unsafe.Pointer(&overwriteConfig), unsafe.Pointer(overwriteConfigRaw))
 		merge(config, overwriteConfig, unsafe.Pointer(&config), unsafe.Pointer(overwriteConfig))
-
-		if config.DevSpace.Release != nil && config.DevSpace.Release.Namespace == nil {
-			config.DevSpace.Release.Namespace = String("default")
-		}
 	})
 
 	return config

pkg/devspace/config/configutil/make.go

@@ -12,11 +12,10 @@ func makeConfig() *v1.Config {
 		DevSpace: &v1.DevSpaceConfig{
 			Terminal:       &v1.Terminal{},
 			PortForwarding: &[]*v1.PortForwardingConfig{},
-			Release:        &v1.Release{},
+			Deployments:    &[]*v1.DeploymentConfig{},
 			Sync:           &[]*v1.SyncConfig{},
 		},
 		Images:     &map[string]*v1.ImageConfig{},
 		Registries: &map[string]*v1.RegistryConfig{},
-		Services:   &v1.ServiceConfig{},
 	}
 }

pkg/devspace/config/generated/config.go

@@ -10,7 +10,7 @@ import (
 
 // Config specifies the runtime config struct
 type Config struct {
-	HelmChartHash          string            `yaml:"chartHash"`
+	ChartHashs             map[string]string `yaml:"chartHashs"`
 	DockerLatestTimestamps map[string]int64  `yaml:"dockerLatestTimestamps"`
 	ImageTags              map[string]string `yaml:"imageTags"`
 }

pkg/devspace/config/v1/deployments.go

@@ -0,0 +1,22 @@
+package v1
+
+// DeploymentConfig defines the configuration how the devspace should be deployed
+type DeploymentConfig struct {
+	Name      *string        `yaml:"name"`
+	Namespace *string        `yaml:"namespace"`
+	Helm      *HelmConfig    `yaml:"helm,omitempty"`
+	Kubectl   *KubectlConfig `yaml:"kubectl,omitempty"`
+}
+
+// HelmConfig defines the specific helm options used during deployment
+type HelmConfig struct {
+	ReleaseName *string                      `yaml:"releaseName,omitempty"`
+	ChartPath   *string                      `yaml:"chartPath,omitempty"`
+	Values      *map[interface{}]interface{} `yaml:"values,omitempty"`
+}
+
+// KubectlConfig defines the specific kubectl options used during deployment
+type KubectlConfig struct {
+	CmdPath   *string    `yaml:"cmdPath,omitempty"`
+	Manifests *[]*string `yaml:"manifests,omitempty"`
+}