Implement new pod waiting strategy

Author: FabianKramm

cmd/add.go

@@ -44,17 +44,20 @@ type addSyncCmdFlags struct {
 	LocalPath     string
 	ContainerPath string
 	ExcludedPaths string
+	Namespace     string
 }
 
 type addPortCmdFlags struct {
 	ResourceType string
 	Selector     string
+	Namespace    string
 }
 
 type addPackageFlags struct {
 	AppVersion   string
 	ChartVersion string
 	SkipQuestion bool
+	Deployment   string
 }
 
 func init() {
@@ -106,6 +109,7 @@ func init() {
 	addSyncCmd.Flags().StringVar(&cmd.syncFlags.ResourceType, "resource-type", "pod", "Selected resource type")
 	addSyncCmd.Flags().StringVar(&cmd.syncFlags.Selector, "selector", "", "Comma separated key=value selector list (e.g. release=test)")
 	addSyncCmd.Flags().StringVar(&cmd.syncFlags.LocalPath, "local", "", "Relative local path")
+	addSyncCmd.Flags().StringVar(&cmd.syncFlags.Namespace, "namespace", "", "Namespace to use")
 	addSyncCmd.Flags().StringVar(&cmd.syncFlags.ContainerPath, "container", "", "Absolute container path")
 	addSyncCmd.Flags().StringVar(&cmd.syncFlags.ExcludedPaths, "exclude", "", "Comma separated list of paths to exclude (e.g. node_modules/,bin,*.exe)")
 
@@ -129,6 +133,7 @@ func init() {
 	}
 
 	addPortCmd.Flags().StringVar(&cmd.portFlags.ResourceType, "resource-type", "pod", "Selected resource type")
+	addSyncCmd.Flags().StringVar(&cmd.portFlags.Namespace, "namespace", "", "Namespace to use")
 	addPortCmd.Flags().StringVar(&cmd.portFlags.Selector, "selector", "", "Comma separated key=value selector list (e.g. release=test)")
 
 	addCmd.AddCommand(addPortCmd)
@@ -148,21 +153,39 @@ func init() {
 	devspace add package
 	devspace add package mysql
 	devspace add package mysql --app-version=5.7.14
-	devspace add package mysql --chart-version=0.10.3
+	devspace add package mysql --chart-version=0.10.3 -d devspace-default
 	#######################################################
 	`,
 		Run: cmd.RunAddPackage,
 	}
 
 	addPackageCmd.Flags().StringVar(&cmd.packageFlags.AppVersion, "app-version", "", "App version")
 	addPackageCmd.Flags().StringVar(&cmd.packageFlags.ChartVersion, "chart-version", "", "Chart version")
+	addPackageCmd.Flags().StringVarP(&cmd.packageFlags.Deployment, "deployment", "d", "", "The deployment name to use")
 	addPackageCmd.Flags().BoolVar(&cmd.packageFlags.SkipQuestion, "skip-question", false, "Skips the question to show the readme in a browser")
 
 	addCmd.AddCommand(addPackageCmd)
 }
 
 // RunAddPackage executes the add package command logic
 func (cmd *AddCmd) RunAddPackage(cobraCmd *cobra.Command, args []string) {
+	config := configutil.GetConfig()
+	if config.DevSpace.Deployments == nil || (len(*config.DevSpace.Deployments) != 1 && cmd.packageFlags.Deployment == "") {
+		log.Fatalf("Please specify the deployment via the -d flag")
+	}
+
+	var deploymentConfig *v1.DeploymentConfig
+	for _, deployConfig := range *config.DevSpace.Deployments {
+		if cmd.packageFlags.Deployment == "" || cmd.packageFlags.Deployment == *deployConfig.Name {
+			if deployConfig.Helm == nil || deployConfig.Helm.ChartPath == nil {
+				log.Fatalf("Selected deployment %s is not a valid helm deployment", *deployConfig.Name)
+			}
+
+			deploymentConfig = deployConfig
+			break
+		}
+	}
+
 	kubectl, err := kubectl.NewClient()
 	if err != nil {
 		log.Fatalf("Unable to create new kubectl client: %v", err)
@@ -187,13 +210,12 @@ func (cmd *AddCmd) RunAddPackage(cobraCmd *cobra.Command, args []string) {
 	}
 
 	log.Done("Chart found")
-
-	cwd, err := os.Getwd()
+	chartPath, err := filepath.Abs(*deploymentConfig.Helm.ChartPath)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	requirementsFile := filepath.Join(cwd, "chart", "requirements.yaml")
+	requirementsFile := filepath.Join(chartPath, "requirements.yaml")
 	_, err = os.Stat(requirementsFile)
 	if os.IsNotExist(err) {
 		entry := "dependencies:\n" +
@@ -234,15 +256,15 @@ func (cmd *AddCmd) RunAddPackage(cobraCmd *cobra.Command, args []string) {
 	}
 
 	log.StartWait("Update chart dependencies")
-	err = helm.UpdateDependencies(filepath.Join(cwd, "chart"))
+	err = helm.UpdateDependencies(chartPath)
 	log.StopWait()
 
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	// Check if key already exists
-	valuesYaml := filepath.Join(cwd, "chart", "values.yaml")
+	valuesYaml := filepath.Join(chartPath, "values.yaml")
 	valuesYamlContents := map[interface{}]interface{}{}
 
 	err = yamlutil.ReadYamlFromFile(valuesYaml, valuesYamlContents)
@@ -262,16 +284,11 @@ func (cmd *AddCmd) RunAddPackage(cobraCmd *cobra.Command, args []string) {
 		}
 	}
 
-	log.Donef("Successfully added %s as chart dependency, you can configure the package in 'chart/values.yaml'", version.GetName())
-	cmd.showReadme(version)
+	log.Donef("Successfully added %s as chart dependency, you can configure the package in '%s/values.yaml'", *deploymentConfig.Helm.ChartPath, version.GetName())
+	cmd.showReadme(chartPath, version)
 }
 
-func (cmd *AddCmd) showReadme(chartVersion *repo.ChartVersion) {
-	cwd, err := os.Getwd()
-	if err != nil {
-		log.Fatal(err)
-	}
-
+func (cmd *AddCmd) showReadme(chartPath string, chartVersion *repo.ChartVersion) {
 	if cmd.packageFlags.SkipQuestion {
 		return
 	}
@@ -286,7 +303,7 @@ func (cmd *AddCmd) showReadme(chartVersion *repo.ChartVersion) {
 		return
 	}
 
-	content, err := tar.ExtractSingleFileToStringTarGz(filepath.Join(cwd, "chart", "charts", chartVersion.GetName()+"-"+chartVersion.GetVersion()+".tgz"), chartVersion.GetName()+"/README.md")
+	content, err := tar.ExtractSingleFileToStringTarGz(filepath.Join(chartPath, "charts", chartVersion.GetName()+"-"+chartVersion.GetVersion()+".tgz"), chartVersion.GetName()+"/README.md")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -349,6 +366,7 @@ func (cmd *AddCmd) RunAddSync(cobraCmd *cobra.Command, args []string) {
 		ContainerPath: configutil.String(cmd.syncFlags.ContainerPath),
 		LocalSubPath:  configutil.String(cmd.syncFlags.LocalPath),
 		ExcludePaths:  &excludedPaths,
+		Namespace:     &cmd.syncFlags.Namespace,
 	})
 
 	config.DevSpace.Sync = &syncConfig
@@ -408,6 +426,7 @@ func (cmd *AddCmd) insertOrReplacePortMapping(labelSelectorMap map[string]*strin
 		ResourceType:  nil,
 		LabelSelector: &labelSelectorMap,
 		PortMappings:  &portMappings,
+		Namespace:     &cmd.portFlags.Namespace,
 	})
 
 	config.DevSpace.PortForwarding = &portMap

cmd/remove.go

@@ -1,7 +1,6 @@
 package cmd
 
 import (
-	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -36,7 +35,8 @@ type removePortCmdFlags struct {
 }
 
 type removePackageCmdFlags struct {
-	RemoveAll bool
+	RemoveAll  bool
+	Deployment string
 }
 
 func init() {
@@ -113,7 +113,6 @@ func init() {
 	removePortCmd.Flags().BoolVar(&cmd.portFlags.RemoveAll, "all", false, "Remove all configured ports")
 
 	removeCmd.AddCommand(removePortCmd)
-
 	removePackageCmd := &cobra.Command{
 		Use:   "package",
 		Short: "Removes forwarded ports from a devspace",
@@ -123,19 +122,38 @@ func init() {
 	#######################################################
 	Removes a package from the devspace:
 	devspace remove package mysql
+	devspace remove package mysql -d devspace-default
 	#######################################################
 	`,
 		Args: cobra.MaximumNArgs(1),
 		Run:  cmd.RunRemovePackage,
 	}
 
 	removePackageCmd.Flags().BoolVar(&cmd.packageFlags.RemoveAll, "all", false, "Remove all packages")
+	removePackageCmd.Flags().StringVarP(&cmd.packageFlags.Deployment, "deployment", "d", "", "The deployment name to use")
 	removeCmd.AddCommand(removePackageCmd)
 }
 
 // RunRemovePackage executes the remove package command logic
 func (cmd *RemoveCmd) RunRemovePackage(cobraCmd *cobra.Command, args []string) {
-	cwd, err := os.Getwd()
+	config := configutil.GetConfig()
+	if config.DevSpace.Deployments == nil || (len(*config.DevSpace.Deployments) != 1 && cmd.packageFlags.Deployment == "") {
+		log.Fatalf("Please specify the deployment via the -d flag")
+	}
+
+	var deploymentConfig *v1.DeploymentConfig
+	for _, deployConfig := range *config.DevSpace.Deployments {
+		if cmd.packageFlags.Deployment == "" || cmd.packageFlags.Deployment == *deployConfig.Name {
+			if deployConfig.Helm == nil || deployConfig.Helm.ChartPath == nil {
+				log.Fatalf("Selected deployment %s is not a valid helm deployment", *deployConfig.Name)
+			}
+
+			deploymentConfig = deployConfig
+			break
+		}
+	}
+
+	chartPath, err := filepath.Abs(*deploymentConfig.Helm.ChartPath)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -144,7 +162,7 @@ func (cmd *RemoveCmd) RunRemovePackage(cobraCmd *cobra.Command, args []string) {
 		log.Fatal("You need to specify a package name or the --all flag")
 	}
 
-	requirementsPath := filepath.Join(cwd, "chart", "requirements.yaml")
+	requirementsPath := filepath.Join(chartPath, "requirements.yaml")
 	yamlContents := map[interface{}]interface{}{}
 
 	err = yamlutil.ReadYamlFromFile(requirementsPath, yamlContents)
@@ -170,7 +188,7 @@ func (cmd *RemoveCmd) RunRemovePackage(cobraCmd *cobra.Command, args []string) {
 						dependenciesArr = append(dependenciesArr[:key], dependenciesArr[key+1:]...)
 						yamlContents["dependencies"] = dependenciesArr
 
-						cmd.rebuildDependencies(yamlContents)
+						cmd.rebuildDependencies(chartPath, yamlContents)
 						break
 					}
 				}
@@ -182,21 +200,16 @@ func (cmd *RemoveCmd) RunRemovePackage(cobraCmd *cobra.Command, args []string) {
 
 		yamlContents["dependencies"] = []interface{}{}
 
-		cmd.rebuildDependencies(yamlContents)
+		cmd.rebuildDependencies(chartPath, yamlContents)
 		log.Done("Successfully removed all dependencies")
 		return
 	}
 
 	log.Done("No dependencies found")
 }
 
-func (cmd *RemoveCmd) rebuildDependencies(newYamlContents map[interface{}]interface{}) {
-	cwd, err := os.Getwd()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = yamlutil.WriteYamlToFile(newYamlContents, filepath.Join(cwd, "chart", "requirements.yaml"))
+func (cmd *RemoveCmd) rebuildDependencies(chartPath string, newYamlContents map[interface{}]interface{}) {
+	err := yamlutil.WriteYamlToFile(newYamlContents, filepath.Join(chartPath, "requirements.yaml"))
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -213,7 +226,7 @@ func (cmd *RemoveCmd) rebuildDependencies(newYamlContents map[interface{}]interf
 	}
 
 	log.StartWait("Update chart dependencies")
-	err = helm.UpdateDependencies(filepath.Join(cwd, "chart"))
+	err = helm.UpdateDependencies(chartPath)
 	log.StopWait()
 
 	if err != nil {

pkg/devspace/config/v1/deployments.go

@@ -10,8 +10,7 @@ type DeploymentConfig struct {
 
 // HelmConfig defines the specific helm options used during deployment
 type HelmConfig struct {
-	ChartPath *string                      `yaml:"chartPath,omitempty"`
-	Values    *map[interface{}]interface{} `yaml:"values,omitempty"`
+	ChartPath *string `yaml:"chartPath,omitempty"`
 }
 
 // KubectlConfig defines the specific kubectl options used during deployment

pkg/devspace/kubectl/client.go

@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"os"
 	"sync"
+	"time"
 
 	"github.com/covexo/devspace/pkg/util/kubeconfig"
 
@@ -158,23 +159,41 @@ func IsMinikube() bool {
 	return *isMinikubeVar
 }
 
-// GetFirstRunningPod retrieves the first pod that is found that has the status "Running" using the label selector string
-func GetFirstRunningPod(kubectl *kubernetes.Clientset, labelSelector, namespace string) (*k8sv1.Pod, error) {
-	podList, err := kubectl.Core().Pods(namespace).List(metav1.ListOptions{
-		LabelSelector: labelSelector,
-	})
+// GetNewestRunningPod retrieves the first pod that is found that has the status "Running" using the label selector string
+func GetNewestRunningPod(kubectl *kubernetes.Clientset, labelSelector, namespace string) (*k8sv1.Pod, error) {
+	maxWaiting := 120 * time.Second
+	waitingInterval := 1 * time.Second
 
-	if err != nil {
-		return nil, err
-	}
+	for maxWaiting > 0 {
+		time.Sleep(waitingInterval)
 
-	for _, pod := range podList.Items {
-		if GetPodStatus(&pod) == "Running" {
-			return &pod, nil
+		podList, err := kubectl.Core().Pods(namespace).List(metav1.ListOptions{
+			LabelSelector: labelSelector,
+		})
+		if err != nil {
+			return nil, err
 		}
+
+		if podList.Size() > 0 && len(podList.Items) > 0 {
+			// Get Pod with latest creation timestamp
+			var selectedPod *k8sv1.Pod
+
+			for _, pod := range podList.Items {
+				if selectedPod == nil || pod.CreationTimestamp.After(selectedPod.CreationTimestamp.Time) {
+					selectedPod = &pod
+				}
+			}
+
+			if selectedPod != nil && GetPodStatus(selectedPod) == "Running" {
+				return selectedPod, nil
+			}
+		}
+
+		time.Sleep(waitingInterval)
+		maxWaiting -= waitingInterval * 2
 	}
 
-	return nil, nil
+	return nil, fmt.Errorf("Waiting for pod with selector %s in namespace %s timed out", labelSelector, namespace)
 }
 
 // GetPodStatus returns the pod status as a string

pkg/devspace/services/port_forwarding.go

@@ -30,7 +30,7 @@ func StartPortForwarding(client *kubernetes.Clientset, log log.Logger) error {
 					namespace = *portForwarding.Namespace
 				}
 
-				pod, err := kubectl.GetFirstRunningPod(client, strings.Join(labels, ", "), namespace)
+				pod, err := kubectl.GetNewestRunningPod(client, strings.Join(labels, ", "), namespace)
 				if err != nil {
 					return fmt.Errorf("Unable to list devspace pods: %s", err.Error())
 				} else if pod != nil {

pkg/devspace/services/sync.go

@@ -36,7 +36,7 @@ func StartSync(client *kubernetes.Clientset, verboseSync bool, log log.Logger) (
 			namespace = *syncPath.Namespace
 		}
 
-		pod, err := kubectl.GetFirstRunningPod(client, strings.Join(labels, ", "), namespace)
+		pod, err := kubectl.GetNewestRunningPod(client, strings.Join(labels, ", "), namespace)
 		if err != nil {
 			return nil, fmt.Errorf("Unable to list devspace pods: %v", err)
 		} else if pod != nil {

pkg/devspace/services/terminal.go

@@ -49,7 +49,7 @@ func StartTerminal(client *kubernetes.Clientset, containerNameOverride string, a
 	}
 
 	// Get first running pod
-	pod, err := kubectl.GetFirstRunningPod(client, labelSelector, namespace)
+	pod, err := kubectl.GetNewestRunningPod(client, labelSelector, namespace)
 	if err != nil {
 		log.Fatalf("Cannot find running pod: %v", err)
 	}