Refactor tillernamespace

Author: FabianKramm

cmd/reset.go

@@ -261,7 +261,7 @@ func (cmd *ResetCmd) deleteRelease() error {
 	releaseName := *config.DevSpace.Release.Name
 
 	if cmd.kubectl == nil || cmd.helm == nil {
-		isDeployed := helmClient.IsTillerDeployed(cmd.kubectl, config.Services.Tiller)
+		isDeployed := helmClient.IsTillerDeployed(cmd.kubectl)
 
 		if isDeployed == false {
 			return nil
@@ -286,7 +286,7 @@ func (cmd *ResetCmd) deleteRegistry() error {
 	registryReleaseName := *config.Services.InternalRegistry.Release.Name
 
 	if cmd.kubectl == nil || cmd.helm == nil {
-		isDeployed := helmClient.IsTillerDeployed(cmd.kubectl, config.Services.Tiller)
+		isDeployed := helmClient.IsTillerDeployed(cmd.kubectl)
 
 		if isDeployed == false {
 			return nil

cmd/status.go

@@ -203,8 +203,7 @@ func (cmd *StatusCmd) getRegistryStatus() ([]string, error) {
 }
 
 func (cmd *StatusCmd) getTillerStatus() ([]string, error) {
-	config := configutil.GetConfig()
-	tillerPod, err := kubectl.GetPodsFromDeployment(cmd.kubectl, helmClient.TillerDeploymentName, *config.Services.Tiller.Release.Namespace)
+	tillerPod, err := kubectl.GetPodsFromDeployment(cmd.kubectl, helmClient.TillerDeploymentName, helmClient.GetTillerNamespace())
 
 	if err != nil {
 		return nil, err

cmd/up.go

@@ -293,7 +293,6 @@ func (cmd *UpCmd) initRegistries() {
 		log.StartWait("Initializing internal registry")
 		err := registry.InitInternalRegistry(cmd.kubectl, cmd.helm, config.Services.InternalRegistry, registryConf)
 		log.StopWait()
-
 		if err != nil {
 			log.Fatalf("Internal registry error: %v", err)
 		}
@@ -339,7 +338,7 @@ func (cmd *UpCmd) buildImages() bool {
 	config := configutil.GetConfig()
 	generatedConfig, err := generated.LoadConfig()
 	if err != nil {
-		log.Fatalf("Error loading .runtime.yaml: %v", err)
+		log.Fatalf("Error loading generated.yaml: %v", err)
 	}
 
 	for imageName, imageConf := range *config.Images {
@@ -355,7 +354,7 @@ func (cmd *UpCmd) buildImages() bool {
 
 	err = generated.SaveConfig(generatedConfig)
 	if err != nil {
-		log.Fatalf("Error saving .runtime.yaml: %v", err)
+		log.Fatalf("Error saving generated.yaml: %v", err)
 	}
 
 	return re
@@ -378,6 +377,10 @@ func (cmd *UpCmd) initHelm() {
 
 func (cmd *UpCmd) deployChart() {
 	config := configutil.GetConfig()
+	generatedConfig, err := generated.LoadConfig()
+	if err != nil {
+		log.Panic(err)
+	}
 
 	log.StartWait("Deploying helm chart")
 	defer log.StopWait()
@@ -389,7 +392,7 @@ func (cmd *UpCmd) deployChart() {
 	values := map[interface{}]interface{}{}
 	overwriteValues := map[interface{}]interface{}{}
 
-	err := yamlutil.ReadYamlFromFile(chartPath+"values.yaml", values)
+	err = yamlutil.ReadYamlFromFile(chartPath+"values.yaml", values)
 	if err != nil {
 		log.Fatalf("Couldn't deploy chart, error reading from chart values %s: %v", chartPath+"values.yaml", err)
 	}
@@ -398,7 +401,7 @@ func (cmd *UpCmd) deployChart() {
 
 	for imageName, imageConf := range *config.Images {
 		container := map[string]interface{}{}
-		container["image"] = registry.GetImageURL(imageConf, true)
+		container["image"] = registry.GetImageURL(imageName, generatedConfig, imageConf, true)
 
 		if cmd.flags.noSleep {
 			container["command"] = []string{}

pkg/devspace/config/configutil/make.go

@@ -17,11 +17,6 @@ func makeConfig() *v1.Config {
 		},
 		Images:     &map[string]*v1.ImageConfig{},
 		Registries: &map[string]*v1.RegistryConfig{},
-		Services: &v1.ServiceConfig{
-			Tiller: &v1.TillerConfig{
-				AppNamespaces: &[]*string{},
-				Release:       &v1.Release{},
-			},
-		},
+		Services:   &v1.ServiceConfig{},
 	}
 }

pkg/devspace/config/configutil/save.go

@@ -16,14 +16,13 @@ import (
 func SaveConfig() error {
 	workdir, _ := os.Getwd()
 	configMapRaw, overwriteMapRaw, err := getConfigAndOverwriteMaps(config, configRaw, overwriteConfig, overwriteConfigRaw)
-
-	configMap, _ := configMapRaw.(map[interface{}]interface{})
-	overwriteMap, _ := overwriteMapRaw.(map[interface{}]interface{})
-
 	if err != nil {
 		return err
 	}
 
+	configMap, _ := configMapRaw.(map[interface{}]interface{})
+	overwriteMap, _ := overwriteMapRaw.(map[interface{}]interface{})
+
 	configYaml, err := yaml.Marshal(configMap)
 	if err != nil {
 		return err

pkg/devspace/deploy/helm/client.go

@@ -40,8 +40,7 @@ type HelmClientWrapper struct {
 // NewClient creates a new helm client
 func NewClient(kubectlClient *kubernetes.Clientset, upgradeTiller bool) (*HelmClientWrapper, error) {
 	config := configutil.GetConfig()
-	tillerConfig := config.Services.Tiller
-	tillerNamespace := *config.Services.Tiller.Release.Namespace
+	tillerNamespace := GetTillerNamespace()
 
 	kubeconfig, err := kubectl.GetClientConfig()
 	if err != nil {
@@ -127,6 +126,15 @@ func NewClient(kubectlClient *kubernetes.Clientset, upgradeTiller bool) (*HelmCl
 		}
 	}
 
+	tillerConfig := config.Services.Tiller
+	if tillerConfig == nil {
+		tillerConfig = &v1.TillerConfig{
+			Release: &v1.Release{
+				Namespace: &tillerNamespace,
+			},
+		}
+	}
+
 	wrapper := &HelmClientWrapper{
 		Client: client,
 		Settings: &helmenvironment.EnvSettings{

pkg/devspace/deploy/helm/rbac.go

@@ -22,8 +22,7 @@ const TillerRoleManagerName = "tiller-config-manager"
 var alreadyExistsRegexp = regexp.MustCompile(".* already exists$")
 
 func createTillerRBAC(kubectlClient *kubernetes.Clientset, dsConfig *v1.Config) error {
-	tillerConfig := dsConfig.Services.Tiller
-	tillerNamespace := *dsConfig.Services.Tiller.Release.Namespace
+	tillerNamespace := GetTillerNamespace()
 
 	// Create service account
 	err := createTillerServiceAccount(kubectlClient, tillerNamespace)
@@ -39,23 +38,29 @@ func createTillerRBAC(kubectlClient *kubernetes.Clientset, dsConfig *v1.Config)
 		}
 	}
 
-	// Tiller does need full access to all namespaces is should deploy to and therefore we create the roles & rolebindings
-	appNamespaces := []*string{
-		dsConfig.DevSpace.Release.Namespace,
-	}
+	tillerConfig := dsConfig.Services.Tiller
+	if tillerConfig != nil {
+		// Tiller does need full access to all namespaces is should deploy to and therefore we create the roles & rolebindings
+		appNamespaces := []*string{
+			dsConfig.DevSpace.Release.Namespace,
+		}
 
-	// Check if there is an internal registry
-	if dsConfig.Services.InternalRegistry != nil && dsConfig.Services.InternalRegistry.Release.Namespace != nil {
-		// Tiller needs access to the internal registry namespace
-		appNamespaces = append(appNamespaces, dsConfig.Services.InternalRegistry.Release.Namespace)
-	}
+		// Check if there is an internal registry
+		if dsConfig.Services.InternalRegistry != nil && dsConfig.Services.InternalRegistry.Release != nil && dsConfig.Services.InternalRegistry.Release.Namespace != nil {
+			// Tiller needs access to the internal registry namespace
+			appNamespaces = append(appNamespaces, dsConfig.Services.InternalRegistry.Release.Namespace)
+		}
 
-	// Persist the app namespaces to the config
-	tillerConfig.AppNamespaces = &appNamespaces
-	for _, appNamespace := range *tillerConfig.AppNamespaces {
-		err = addDeployAccessToTiller(kubectlClient, tillerNamespace, *appNamespace)
-		if err != nil {
-			return err
+		if tillerConfig.AppNamespaces != nil {
+			appNamespaces = append(appNamespaces, *tillerConfig.AppNamespaces...)
+		}
+
+		// Persist the app namespaces to the config
+		for _, appNamespace := range appNamespaces {
+			err = addDeployAccessToTiller(kubectlClient, tillerNamespace, *appNamespace)
+			if err != nil {
+				return err
+			}
 		}
 	}
 

pkg/devspace/deploy/helm/tiller.go

@@ -28,7 +28,7 @@ repositories:
 `
 
 func ensureTiller(kubectlClient *kubernetes.Clientset, config *v1.Config, upgrade bool) error {
-	tillerNamespace := *config.Services.Tiller.Release.Namespace
+	tillerNamespace := GetTillerNamespace()
 	tillerOptions := &helminstaller.Options{
 		Namespace:      tillerNamespace,
 		MaxHistory:     10,
@@ -67,15 +67,15 @@ func ensureTiller(kubectlClient *kubernetes.Clientset, config *v1.Config, upgrad
 		}
 	}
 
-	return waitUntilTillerIsStarted(kubectlClient, tillerNamespace)
+	return waitUntilTillerIsStarted(kubectlClient)
 }
 
 func createTiller(kubectlClient *kubernetes.Clientset, dsConfig *v1.Config, tillerOptions *helminstaller.Options) error {
 	log.StartWait("Installing Tiller server")
 	defer log.StopWait()
 
 	// If the service account is already there we do not create it or any roles/rolebindings
-	_, err := kubectlClient.CoreV1().ServiceAccounts(*dsConfig.Services.Tiller.Release.Namespace).Get(TillerServiceAccountName, metav1.GetOptions{})
+	_, err := kubectlClient.CoreV1().ServiceAccounts(GetTillerNamespace()).Get(TillerServiceAccountName, metav1.GetOptions{})
 	if err != nil {
 		err = createTillerRBAC(kubectlClient, dsConfig)
 		if err != nil {
@@ -87,15 +87,15 @@ func createTiller(kubectlClient *kubernetes.Clientset, dsConfig *v1.Config, till
 	return helminstaller.Install(kubectlClient, tillerOptions)
 }
 
-func waitUntilTillerIsStarted(kubectlClient *kubernetes.Clientset, tillerNamespace string) error {
+func waitUntilTillerIsStarted(kubectlClient *kubernetes.Clientset) error {
 	tillerWaitingTime := 2 * 60 * time.Second
 	tillerCheckInterval := 5 * time.Second
 
 	log.StartWait("Waiting for tiller to start")
 	defer log.StopWait()
 
 	for tillerWaitingTime > 0 {
-		tillerDeployment, err := kubectlClient.ExtensionsV1beta1().Deployments(tillerNamespace).Get(TillerDeploymentName, metav1.GetOptions{})
+		tillerDeployment, err := kubectlClient.ExtensionsV1beta1().Deployments(GetTillerNamespace()).Get(TillerDeploymentName, metav1.GetOptions{})
 		if err != nil {
 			continue
 		}
@@ -142,11 +142,24 @@ func addAppNamespaces(appNamespaces *[]*string, namespaces []*string) {
 	appNamespaces = &newAppNamespaces
 }
 
+// GetTillerNamespace retrieves the tillernamespace
+func GetTillerNamespace() string {
+	config := configutil.GetConfig()
+	if config.DevSpace.Release == nil || config.DevSpace.Release.Namespace == nil {
+		log.Panic("Cannot get tiller namespace when helm is not configured")
+	}
+
+	if config.Services == nil || config.Services.Tiller == nil || config.Services.Tiller.Release == nil || config.Services.Tiller.Release.Namespace == nil {
+		return *config.DevSpace.Release.Namespace
+	}
+
+	return *config.Services.Tiller.Release.Namespace
+}
+
 // IsTillerDeployed determines if we could connect to a tiller server
-func IsTillerDeployed(kubectlClient *kubernetes.Clientset, tillerConfig *v1.TillerConfig) bool {
-	tillerNamespace := *tillerConfig.Release.Namespace
+func IsTillerDeployed(kubectlClient *kubernetes.Clientset) bool {
+	tillerNamespace := GetTillerNamespace()
 	deployment, err := kubectlClient.ExtensionsV1beta1().Deployments(tillerNamespace).Get(TillerDeploymentName, metav1.GetOptions{})
-
 	if err != nil {
 		return false
 	}
@@ -162,8 +175,7 @@ func IsTillerDeployed(kubectlClient *kubernetes.Clientset, tillerConfig *v1.Till
 func DeleteTiller(kubectlClient *kubernetes.Clientset) error {
 	config := configutil.GetConfig()
 
-	tillerConfig := config.Services.Tiller
-	tillerNamespace := *tillerConfig.Release.Namespace
+	tillerNamespace := GetTillerNamespace()
 	errs := make([]error, 0, 1)
 	propagationPolicy := metav1.DeletePropagationForeground
 
@@ -186,8 +198,16 @@ func DeleteTiller(kubectlClient *kubernetes.Clientset) error {
 			errs = append(errs, err)
 		}
 
-		roleNamespace := append(*tillerConfig.AppNamespaces, &tillerNamespace)
-		for _, appNamespace := range roleNamespace {
+		appNamespaces := []*string{
+			config.DevSpace.Release.Namespace,
+			&tillerNamespace,
+		}
+
+		if config.Services.InternalRegistry != nil && config.Services.InternalRegistry.Release != nil && config.Services.InternalRegistry.Release.Namespace != nil {
+			appNamespaces = append(appNamespaces, config.Services.InternalRegistry.Release.Namespace)
+		}
+
+		for _, appNamespace := range appNamespaces {
 			err = kubectlClient.RbacV1beta1().Roles(*appNamespace).Delete(TillerRoleName, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy})
 			if err != nil && strings.HasSuffix(err.Error(), "not found") == false {
 				errs = append(errs, err)