Issue 101

cmd/add.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"fmt"
+	"os"
 	"strconv"
 	"strings"
 
@@ -17,7 +18,6 @@ type AddCmd struct {
 	syncFlags *addSyncCmdFlags
 	portFlags *addPortCmdFlags
 	dsConfig  *v1.DevSpaceConfig
-	workdir   string
 }
 
 // AddCmdFlags holds the possible flags for the add command
@@ -138,14 +138,28 @@ func (cmd *AddCmd) RunAddSync(cobraCmd *cobra.Command, args []string) {
 		}
 	}
 
-	config.DevSpace.Sync = append(config.DevSpace.Sync, &v1.SyncConfig{
+	workdir, err := os.Getwd()
+
+	if err != nil {
+		log.Fatalf("Unable to determine current workdir: %s", err.Error())
+	}
+	cmd.syncFlags.LocalPath = strings.TrimPrefix(cmd.syncFlags.LocalPath, workdir)
+	cmd.syncFlags.LocalPath = "./" + strings.TrimPrefix(cmd.syncFlags.LocalPath, "./")
+
+	if cmd.syncFlags.ContainerPath[0] != '/' {
+		log.Fatal("ContainerPath (--container) must start with '/'. Info: There is an issue with MINGW based terminals like git bash.")
+	}
+
+	syncConfig := append(*config.DevSpace.Sync, &v1.SyncConfig{
 		ResourceType:  configutil.String(cmd.syncFlags.ResourceType),
-		LabelSelector: labelSelectorMap,
+		LabelSelector: &labelSelectorMap,
 		ContainerPath: configutil.String(cmd.syncFlags.ContainerPath),
 		LocalSubPath:  configutil.String(cmd.syncFlags.LocalPath),
-		ExcludePaths:  excludedPaths,
+		ExcludePaths:  &excludedPaths,
 	})
 
+	config.DevSpace.Sync = &syncConfig
+
 	err = configutil.SaveConfig()
 
 	if err != nil {
@@ -186,19 +200,30 @@ func (cmd *AddCmd) insertOrReplacePortMapping(labelSelectorMap map[string]*strin
 	config := configutil.GetConfig(false)
 
 	// Check if we should add to existing port mapping
-	for _, v := range config.DevSpace.PortForwarding {
-		if *v.ResourceType == cmd.portFlags.ResourceType && isMapEqual(v.LabelSelector, labelSelectorMap) {
-			v.PortMappings = append(v.PortMappings, portMappings...)
+	for _, v := range *config.DevSpace.PortForwarding {
+		var selectors map[string]*string
+
+		if v.LabelSelector != nil {
+			selectors = *v.LabelSelector
+		} else {
+			selectors = map[string]*string{}
+		}
+
+		if *v.ResourceType == cmd.portFlags.ResourceType && isMapEqual(selectors, labelSelectorMap) {
+			portMap := append(*v.PortMappings, portMappings...)
+
+			v.PortMappings = &portMap
 
 			return
 		}
 	}
-
-	config.DevSpace.PortForwarding = append(config.DevSpace.PortForwarding, &v1.PortForwardingConfig{
+	portMap := append(*config.DevSpace.PortForwarding, &v1.PortForwardingConfig{
 		ResourceType:  configutil.String(cmd.portFlags.ResourceType),
-		LabelSelector: labelSelectorMap,
-		PortMappings:  portMappings,
+		LabelSelector: &labelSelectorMap,
+		PortMappings:  &portMappings,
 	})
+
+	config.DevSpace.PortForwarding = &portMap
 }
 
 func isMapEqual(map1 map[string]*string, map2 map[string]*string) bool {

cmd/init.go

@@ -226,7 +226,7 @@ func (cmd *InitCmd) determineAppConfig() {
 			cmd.addPortForwarding(portInt)
 		}
 	}
-	cmd.addSyncPath()
+	cmd.addDefaultSyncConfig()
 
 	/* TODO
 	cmd.appConfig.External.Domain = stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
@@ -237,42 +237,45 @@ func (cmd *InitCmd) determineAppConfig() {
 }
 
 func (cmd *InitCmd) addPortForwarding(port int) {
-OUTER:
-	for _, portForwarding := range cmd.config.DevSpace.PortForwarding {
-		for _, portMapping := range portForwarding.PortMappings {
+	for _, portForwarding := range *cmd.config.DevSpace.PortForwarding {
+		for _, portMapping := range *portForwarding.PortMappings {
 			if *portMapping.RemotePort == port {
-				cmd.config.DevSpace.PortForwarding = append(cmd.config.DevSpace.PortForwarding, &v1.PortForwardingConfig{
-					PortMappings: []*v1.PortMapping{
-						{
-							LocalPort:  &port,
-							RemotePort: &port,
-						},
-					},
-					ResourceType: configutil.String("pod"),
-					LabelSelector: map[string]*string{
-						"release": cmd.config.DevSpace.Release.Name,
-					},
-				})
-				break OUTER
+				return
 			}
 		}
 	}
+
+	portForwarding := append(*cmd.config.DevSpace.PortForwarding, &v1.PortForwardingConfig{
+		PortMappings: &[]*v1.PortMapping{
+			{
+				LocalPort:  &port,
+				RemotePort: &port,
+			},
+		},
+		ResourceType: configutil.String("pod"),
+		LabelSelector: &map[string]*string{
+			"release": cmd.config.DevSpace.Release.Name,
+		},
+	})
+	cmd.config.DevSpace.PortForwarding = &portForwarding
 }
 
-func (cmd *InitCmd) addSyncPath() {
-	for _, syncPath := range cmd.config.DevSpace.Sync {
+func (cmd *InitCmd) addDefaultSyncConfig() {
+	for _, syncPath := range *cmd.config.DevSpace.Sync {
 		if *syncPath.LocalSubPath == "./" || *syncPath.ContainerPath == "/app" {
-			cmd.config.DevSpace.Sync = append(cmd.config.DevSpace.Sync, &v1.SyncConfig{
-				ContainerPath: configutil.String("/app"),
-				LocalSubPath:  configutil.String("./"),
-				ResourceType:  configutil.String("pod"),
-				LabelSelector: map[string]*string{
-					"release": cmd.config.DevSpace.Release.Name,
-				},
-			})
-			break
+			return
 		}
 	}
+
+	syncConfig := append(*cmd.config.DevSpace.Sync, &v1.SyncConfig{
+		ContainerPath: configutil.String("/app"),
+		LocalSubPath:  configutil.String("./"),
+		ResourceType:  configutil.String("pod"),
+		LabelSelector: &map[string]*string{
+			"release": cmd.config.DevSpace.Release.Name,
+		},
+	})
+	cmd.config.DevSpace.Sync = &syncConfig
 }
 
 func (cmd *InitCmd) reconfigure() {
@@ -352,7 +355,7 @@ func (cmd *InitCmd) reconfigure() {
 
 func (cmd *InitCmd) reconfigureRegistry() {
 	overwriteConfig := configutil.GetOverwriteConfig()
-	registryConfig := overwriteConfig.Services.Registry
+	registryConfig := cmd.config.Services.Registry
 
 	enableAutomaticBuilds := stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
 		Question:               "Do you want to enable automatic Docker image building?",
@@ -405,10 +408,39 @@ func (cmd *InitCmd) reconfigureRegistry() {
 				}
 				registryUser.Password = &randomPassword
 			}
-			registryReleaseValues := registryConfig.Internal.Release.Values
+			var registryReleaseValues map[interface{}]interface{}
 
-			if registryReleaseValues == nil {
+			if registryConfig.Internal.Release.Values != nil {
+				registryReleaseValues = *registryConfig.Internal.Release.Values
+			} else {
 				registryReleaseValues = map[interface{}]interface{}{}
+
+				registryDomain := stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
+					Question:               "Which domain should your container registry be using? (optional, requires an ingress controller)",
+					ValidationRegexPattern: "^(([a-z0-9]([a-z0-9-]{0,120}[a-z0-9])?\\.)+[a-z0-9]{2,})?$",
+				})
+
+				if *registryDomain != "" {
+					registryReleaseValues = map[interface{}]interface{}{
+						"Ingress": map[string]interface{}{
+							"Enabled": true,
+							"Hosts": []string{
+								*registryDomain,
+							},
+							"Annotations": map[string]string{
+								"Kubernetes.io/tls-acme": "true",
+							},
+							"Tls": []map[string]interface{}{
+								map[string]interface{}{
+									"SecretName": "tls-devspace-registry",
+									"Hosts": []string{
+										*registryDomain,
+									},
+								},
+							},
+						},
+					}
+				}
 			}
 			secrets, registryHasSecrets := registryReleaseValues["secrets"]
 
@@ -425,6 +457,7 @@ func (cmd *InitCmd) reconfigureRegistry() {
 					secretMap["htpasswd"] = ""
 				}
 			}
+			registryConfig.Internal.Release.Values = &registryReleaseValues
 		}
 	}
 }
@@ -439,12 +472,15 @@ func (cmd *InitCmd) determineLanguage() {
 	}
 
 	if len(cmd.chartGenerator.Language) == 0 {
+		log.StartWait("Detecting programming language")
+
 		cmd.chartGenerator.Language, _ = cmd.chartGenerator.GetLanguage()
 		supportedLanguages, err := cmd.chartGenerator.GetSupportedLanguages()
 
 		if cmd.chartGenerator.Language == "" {
 			cmd.chartGenerator.Language = "none"
 		}
+		log.StopWait()
 
 		if err != nil {
 			log.Fatalf("Unable to get supported languages: %s", err.Error())

cmd/list.go

@@ -78,7 +78,7 @@ func init() {
 func (cmd *ListCmd) RunListSync(cobraCmd *cobra.Command, args []string) {
 	config := configutil.GetConfig(false)
 
-	if len(config.DevSpace.Sync) == 0 {
+	if len(*config.DevSpace.Sync) == 0 {
 		log.Write("No sync paths are configured. Run `devspace add sync` to add new sync path\n")
 		return
 	}
@@ -91,13 +91,13 @@ func (cmd *ListCmd) RunListSync(cobraCmd *cobra.Command, args []string) {
 		"Excluded Paths",
 	}
 
-	syncPaths := make([][]string, 0, len(config.DevSpace.Sync))
+	syncPaths := make([][]string, 0, len(*config.DevSpace.Sync))
 
 	// Transform values into string arrays
-	for _, value := range config.DevSpace.Sync {
+	for _, value := range *config.DevSpace.Sync {
 		selector := ""
 
-		for k, v := range value.LabelSelector {
+		for k, v := range *value.LabelSelector {
 			if len(selector) > 0 {
 				selector += ", "
 			}
@@ -107,7 +107,7 @@ func (cmd *ListCmd) RunListSync(cobraCmd *cobra.Command, args []string) {
 
 		excludedPaths := ""
 
-		for _, v := range value.ExcludePaths {
+		for _, v := range *value.ExcludePaths {
 			if len(excludedPaths) > 0 {
 				excludedPaths += ", "
 			}
@@ -131,7 +131,7 @@ func (cmd *ListCmd) RunListSync(cobraCmd *cobra.Command, args []string) {
 func (cmd *ListCmd) RunListPort(cobraCmd *cobra.Command, args []string) {
 	config := configutil.GetConfig(false)
 
-	if len(config.DevSpace.PortForwarding) == 0 {
+	if len(*config.DevSpace.PortForwarding) == 0 {
 		log.Write("No ports are forwarded. Run `devspace add port` to add a port that should be forwarded\n")
 		return
 	}
@@ -142,13 +142,13 @@ func (cmd *ListCmd) RunListPort(cobraCmd *cobra.Command, args []string) {
 		"Ports (Local:Remote)",
 	}
 
-	portForwards := make([][]string, 0, len(config.DevSpace.PortForwarding))
+	portForwards := make([][]string, 0, len(*config.DevSpace.PortForwarding))
 
 	// Transform values into string arrays
-	for _, value := range config.DevSpace.PortForwarding {
+	for _, value := range *config.DevSpace.PortForwarding {
 		selector := ""
 
-		for k, v := range value.LabelSelector {
+		for k, v := range *value.LabelSelector {
 			if len(selector) > 0 {
 				selector += ", "
 			}
@@ -158,7 +158,7 @@ func (cmd *ListCmd) RunListPort(cobraCmd *cobra.Command, args []string) {
 
 		portMappings := ""
 
-		for _, v := range value.PortMappings {
+		for _, v := range *value.PortMappings {
 			if len(portMappings) > 0 {
 				portMappings += ", "
 			}

cmd/remove.go

@@ -120,20 +120,20 @@ func (cmd *RemoveCmd) RunRemoveSync(cobraCmd *cobra.Command, args []string) {
 		return
 	}
 
-	newSyncPaths := make([]*v1.SyncConfig, 0, len(config.DevSpace.Sync)-1)
+	newSyncPaths := make([]*v1.SyncConfig, 0, len(*config.DevSpace.Sync)-1)
 
-	for _, v := range config.DevSpace.Sync {
+	for _, v := range *config.DevSpace.Sync {
 		if cmd.syncFlags.RemoveAll ||
 			cmd.syncFlags.LocalPath == *v.LocalSubPath ||
 			cmd.syncFlags.ContainerPath == *v.ContainerPath ||
-			isMapEqual(labelSelectorMap, v.LabelSelector) {
+			isMapEqual(labelSelectorMap, *v.LabelSelector) {
 			continue
 		}
 
 		newSyncPaths = append(newSyncPaths, v)
 	}
 
-	config.DevSpace.Sync = newSyncPaths
+	config.DevSpace.Sync = &newSyncPaths
 
 	err = configutil.SaveConfig()
 
@@ -166,16 +166,16 @@ func (cmd *RemoveCmd) RunRemovePort(cobraCmd *cobra.Command, args []string) {
 	}
 
 	ports := strings.Split(argPorts, ",")
-	newPortForwards := make([]*v1.PortForwardingConfig, 0, len(config.DevSpace.PortForwarding)-1)
+	newPortForwards := make([]*v1.PortForwardingConfig, 0, len(*config.DevSpace.PortForwarding)-1)
 
 OUTER:
-	for _, v := range config.DevSpace.PortForwarding {
+	for _, v := range *config.DevSpace.PortForwarding {
 		if cmd.portFlags.RemoveAll ||
-			isMapEqual(labelSelectorMap, v.LabelSelector) {
+			isMapEqual(labelSelectorMap, *v.LabelSelector) {
 			continue
 		}
 
-		for _, pm := range v.PortMappings {
+		for _, pm := range *v.PortMappings {
 			if containsPort(strconv.Itoa(*pm.LocalPort), ports) || containsPort(strconv.Itoa(*pm.RemotePort), ports) {
 				continue OUTER
 			}
@@ -184,7 +184,7 @@ OUTER:
 		newPortForwards = append(newPortForwards, v)
 	}
 
-	config.DevSpace.PortForwarding = newPortForwards
+	config.DevSpace.PortForwarding = &newPortForwards
 
 	err = configutil.SaveConfig()