refactor: improve target selector

Author: FabianKramm

cmd/attach.go

@@ -7,7 +7,6 @@ import (
 	"github.com/loft-sh/devspace/pkg/devspace/plugin"
 	"github.com/loft-sh/devspace/pkg/devspace/services/targetselector"
 	"github.com/loft-sh/devspace/pkg/util/factory"
-	"github.com/loft-sh/devspace/pkg/util/ptr"
 	"github.com/pkg/errors"
 
 	"github.com/spf13/cobra"
@@ -99,18 +98,16 @@ func (cmd *AttachCmd) Run(f factory.Factory, cobraCmd *cobra.Command, args []str
 		return err
 	}
 
-	// Build params
-	options := targetselector.NewOptionsFromFlags(cmd.Container, cmd.LabelSelector, cmd.Namespace, cmd.Pod, cmd.Pick)
-
 	// get image selector if specified
 	imageSelector, err := getImageSelector(client, configLoader, configOptions, cmd.Image, cmd.ImageSelector, log)
 	if err != nil {
 		return err
 	}
 
-	// set image selector
-	options.ImageSelector = imageSelector
-	options.Wait = ptr.Bool(false)
+	// Build params
+	options := targetselector.NewOptionsFromFlags(cmd.Container, cmd.LabelSelector, imageSelector, cmd.Namespace, cmd.Pod).
+		WithPick(cmd.Pick).
+		WithWait(false)
 
 	// Start attach
 	return f.NewServicesClient(nil, nil, client, log).StartAttach(options, make(chan error))

cmd/dev.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"fmt"
+	"github.com/loft-sh/devspace/pkg/devspace/kubectl/selector"
 	"github.com/loft-sh/devspace/pkg/util/stringutil"
 	"io"
 	"os"
@@ -11,7 +12,6 @@ import (
 	"time"
 
 	runtimevar "github.com/loft-sh/devspace/pkg/devspace/config/loader/variable/runtime"
-	"github.com/loft-sh/devspace/pkg/devspace/imageselector"
 	"github.com/loft-sh/devspace/pkg/util/command"
 
 	"github.com/loft-sh/devspace/pkg/devspace/config"
@@ -625,24 +625,24 @@ func (cmd *DevCmd) startOutput(configInterface config.Config, dependencies []typ
 				}
 				return 0, nil
 			} else {
-				selectorOptions := targetselector.NewDefaultOptions().ApplyCmdParameter("", "", cmd.Namespace, "")
+				selectorOptions := targetselector.NewEmptyOptions().
+					WithContainerFilter(selector.FilterNonRunningContainers).
+					WithPick(true).
+					WithNamespace(cmd.Namespace)
 				if config.Dev.Terminal != nil {
-					selectorOptions = selectorOptions.ApplyConfigParameter(config.Dev.Terminal.LabelSelector, config.Dev.Terminal.Namespace, config.Dev.Terminal.ContainerName, "")
-				}
+					var imageSelectors []string
+					if config.Dev.Terminal.ImageSelector != "" {
+						imageSelector, err := runtimevar.NewRuntimeResolver(true).FillRuntimeVariablesAsImageSelector(config.Dev.Terminal.ImageSelector, configInterface, dependencies)
+						if err != nil {
+							return 0, err
+						}
 
-				var imageSelectors []imageselector.ImageSelector
-				if config.Dev.Terminal != nil && config.Dev.Terminal.ImageSelector != "" {
-					imageSelector, err := runtimevar.NewRuntimeResolver(true).FillRuntimeVariablesAsImageSelector(config.Dev.Terminal.ImageSelector, configInterface, dependencies)
-					if err != nil {
-						return 0, err
+						imageSelectors = []string{imageSelector.Image}
 					}
-
-					imageSelectors = append(imageSelectors, *imageSelector)
+					selectorOptions = selectorOptions.ApplyConfigParameter(config.Dev.Terminal.ContainerName, config.Dev.Terminal.LabelSelector, imageSelectors, config.Dev.Terminal.Namespace, "")
 				}
 
 				cmd.log.Info("Terminal: Waiting for containers to start...")
-				selectorOptions.ImageSelector = imageSelectors
-
 				code, err := servicesClient.StartTerminal(selectorOptions, args, cmd.WorkingDirectory, exitChan, true, cmd.TerminalReconnect, stdout, stderr, stdin)
 				if services.IsUnexpectedExitCode(code) {
 					cmd.log.Warnf("Command terminated with exit code %d", code)

cmd/enter.go

@@ -117,17 +117,15 @@ func (cmd *EnterCmd) Run(f factory.Factory, cobraCmd *cobra.Command, args []stri
 		return err
 	}
 
-	// Build params
-	selectorOptions := targetselector.NewOptionsFromFlags(cmd.Container, cmd.LabelSelector, cmd.Namespace, cmd.Pod, cmd.Pick)
-
 	// get image selector if specified
 	imageSelector, err := getImageSelector(client, configLoader, configOptions, cmd.Image, cmd.ImageSelector, logger)
 	if err != nil {
 		return err
 	}
 
-	// set image selector
-	selectorOptions.ImageSelector = imageSelector
+	// Build params
+	selectorOptions := targetselector.NewOptionsFromFlags(cmd.Container, cmd.LabelSelector, imageSelector, cmd.Namespace, cmd.Pod).
+		WithPick(cmd.Pick)
 
 	// Start terminal
 	stdout, stderr, stdin := defaultStdStreams(cmd.Stdout, cmd.Stderr, cmd.Stdin)

cmd/logs.go

@@ -116,17 +116,15 @@ func (cmd *LogsCmd) RunLogs(f factory.Factory) error {
 		return err
 	}
 
-	// Build options
-	options := targetselector.NewOptionsFromFlags(cmd.Container, cmd.LabelSelector, cmd.Namespace, cmd.Pod, cmd.Pick)
-
 	// get image selector if specified
 	imageSelector, err := getImageSelector(client, configLoader, configOptions, cmd.Image, cmd.ImageSelector, log)
 	if err != nil {
 		return err
 	}
 
-	// set image selector
-	options.ImageSelector = imageSelector
+	// Build options
+	options := targetselector.NewOptionsFromFlags(cmd.Container, cmd.LabelSelector, imageSelector, cmd.Namespace, cmd.Pod).
+		WithPick(cmd.Pick)
 
 	// Start terminal
 	err = f.NewServicesClient(nil, nil, client, log).StartLogs(options, cmd.Follow, int64(cmd.LastAmountOfLines), cmd.Wait)
@@ -137,8 +135,8 @@ func (cmd *LogsCmd) RunLogs(f factory.Factory) error {
 	return nil
 }
 
-func getImageSelector(client kubectl.Client, configLoader loader.ConfigLoader, configOptions *loader.ConfigOptions, image, imageSelector string, log log.Logger) ([]imageselector.ImageSelector, error) {
-	var imageSelectors []imageselector.ImageSelector
+func getImageSelector(client kubectl.Client, configLoader loader.ConfigLoader, configOptions *loader.ConfigOptions, image, imageSelector string, log log.Logger) ([]string, error) {
+	var imageSelectors []string
 	if imageSelector != "" {
 		var (
 			err          error
@@ -166,7 +164,7 @@ func getImageSelector(client kubectl.Client, configLoader loader.ConfigLoader, c
 			return nil, err
 		}
 
-		imageSelectors = append(imageSelectors, *resolved)
+		imageSelectors = append(imageSelectors, resolved.Image)
 	} else if image != "" {
 		log.Warnf("Flag --image is deprecated, please use --image-selector instead")
 
@@ -193,7 +191,7 @@ func getImageSelector(client kubectl.Client, configLoader loader.ConfigLoader, c
 			return nil, fmt.Errorf("couldn't find an image with name %s in devspace config", image)
 		}
 
-		imageSelectors = append(imageSelectors, *imageSelector)
+		imageSelectors = append(imageSelectors, imageSelector.Image)
 	}
 
 	return imageSelectors, nil

cmd/restart.go

@@ -3,19 +3,15 @@ package cmd
 import (
 	"context"
 	"fmt"
+	"github.com/loft-sh/devspace/cmd/flags"
 	runtimevar "github.com/loft-sh/devspace/pkg/devspace/config/loader/variable/runtime"
-	"github.com/loft-sh/devspace/pkg/devspace/imageselector"
-
 	"github.com/loft-sh/devspace/pkg/devspace/dependency"
 	"github.com/loft-sh/devspace/pkg/devspace/hook"
 	"github.com/loft-sh/devspace/pkg/devspace/kubectl"
 	"github.com/loft-sh/devspace/pkg/devspace/plugin"
 	"github.com/loft-sh/devspace/pkg/devspace/services/inject"
 	"github.com/loft-sh/devspace/pkg/devspace/services/targetselector"
 	"github.com/loft-sh/devspace/pkg/util/factory"
-	"github.com/loft-sh/devspace/pkg/util/ptr"
-
-	"github.com/loft-sh/devspace/cmd/flags"
 	"github.com/loft-sh/devspace/pkg/util/log"
 	"github.com/pkg/errors"
 
@@ -85,7 +81,7 @@ func (cmd *RestartCmd) Run(f factory.Factory) error {
 			return errors.Wrap(err, "create kube client")
 		}
 
-		return restartContainer(client, targetselector.NewOptionsFromFlags(cmd.Container, cmd.LabelSelector, cmd.Namespace, cmd.Pod, cmd.Pick), cmd.log)
+		return restartContainer(client, targetselector.NewOptionsFromFlags(cmd.Container, cmd.LabelSelector, nil, cmd.Namespace, cmd.Pod).WithPick(cmd.Pick), cmd.log)
 	}
 
 	log.StartFileLogging()
@@ -149,17 +145,19 @@ func (cmd *RestartCmd) Run(f factory.Factory) error {
 		}
 
 		// create target selector options
-		options := targetselector.NewOptionsFromFlags("", "", cmd.Namespace, "", cmd.Pick).ApplyConfigParameter(syncPath.LabelSelector, syncPath.Namespace, syncPath.ContainerName, "")
-		options.ImageSelector = []imageselector.ImageSelector{}
+		var imageSelector []string
 		if syncPath.ImageSelector != "" {
-			imageSelector, err := runtimevar.NewRuntimeResolver(true).FillRuntimeVariablesAsImageSelector(syncPath.ImageSelector, configInterface, dep)
+			imageSelectorObject, err := runtimevar.NewRuntimeResolver(true).FillRuntimeVariablesAsImageSelector(syncPath.ImageSelector, configInterface, dep)
 			if err != nil {
 				return err
 			}
 
-			options.ImageSelector = append(options.ImageSelector, *imageSelector)
+			imageSelector = []string{imageSelectorObject.Image}
 		}
 
+		options := targetselector.NewOptionsFromFlags("", "", nil, cmd.Namespace, "").
+			WithPick(cmd.Pick).
+			ApplyConfigParameter(syncPath.ContainerName, syncPath.LabelSelector, imageSelector, syncPath.Namespace, "")
 		err = restartContainer(client, options, cmd.log)
 		if err != nil {
 			return err
@@ -179,7 +177,7 @@ func (cmd *RestartCmd) Run(f factory.Factory) error {
 }
 
 func restartContainer(client kubectl.Client, options targetselector.Options, log log.Logger) error {
-	options.Wait = ptr.Bool(false)
+	options = options.WithWait(false)
 	container, err := targetselector.NewTargetSelector(client).SelectSingleContainer(context.TODO(), options, log)
 	if err != nil {
 		return errors.Errorf("Error selecting pod: %v", err)

cmd/sync.go

@@ -180,17 +180,16 @@ func (cmd *SyncCmd) Run(f factory.Factory) error {
 		return err
 	}
 
-	// Build params
-	options := targetselector.NewOptionsFromFlags(cmd.Container, cmd.LabelSelector, cmd.Namespace, cmd.Pod, cmd.Pick)
 	// get image selector if specified
 	imageSelector, err := getImageSelector(client, configLoader, configOptions, "", cmd.ImageSelector, logger)
 	if err != nil {
 		return err
 	}
 
-	// set image selector
-	options.ImageSelector = imageSelector
-	options.Wait = &cmd.Wait
+	// Build params
+	options := targetselector.NewOptionsFromFlags(cmd.Container, cmd.LabelSelector, imageSelector, cmd.Namespace, cmd.Pod).
+		WithPick(cmd.Pick).
+		WithWait(cmd.Wait)
 
 	if cmd.DownloadOnly && cmd.UploadOnly {
 		return errors.New("--upload-only cannot be used together with --download-only")
@@ -253,9 +252,8 @@ func (cmd *SyncCmd) Run(f factory.Factory) error {
 		return errors.Wrap(err, "apply flags to sync config")
 	}
 
-	options = options.ApplyConfigParameter(syncConfig.LabelSelector, syncConfig.Namespace, syncConfig.ContainerName, "")
-
 	// Start sync
+	options = options.ApplyConfigParameter(syncConfig.ContainerName, syncConfig.LabelSelector, nil, syncConfig.Namespace, "")
 	return f.NewServicesClient(configInterface, nil, client, logger).StartSyncFromCmd(options, syncConfig, cmd.Interrupt, cmd.NoWatch, cmd.Verbose)
 }
 

e2e/kube/kube.go

@@ -3,7 +3,6 @@ package kube
 import (
 	"context"
 	"fmt"
-	"github.com/loft-sh/devspace/pkg/devspace/imageselector"
 	"strings"
 	"time"
 
@@ -41,15 +40,10 @@ func (k *KubeHelper) RawClient() kubernetes.Interface {
 }
 
 func (k *KubeHelper) ExecByImageSelector(imageSelector, namespace string, command []string) (string, error) {
-	targetOptions := targetselector.NewEmptyOptions().ApplyConfigParameter(nil, namespace, "", "")
-	targetOptions.AllowPick = false
-	targetOptions.Timeout = 120
-	targetOptions.ImageSelector = []imageselector.ImageSelector{
-		{
-			Image: imageSelector,
-		},
-	}
-	targetOptions.WaitingStrategy = targetselector.NewUntilNewestRunningWaitingStrategy(time.Second * 2)
+	targetOptions := targetselector.NewOptionsFromFlags("", "", []string{imageSelector}, namespace, "").
+		WithTimeout(120).
+		WithWaitingStrategy(targetselector.NewUntilNewestRunningWaitingStrategy(time.Second * 2))
+
 	container, err := targetselector.NewTargetSelector(k.client).SelectSingleContainer(context.TODO(), targetOptions, log.Discard)
 	if err != nil {
 		return "", err
@@ -64,12 +58,10 @@ func (k *KubeHelper) ExecByImageSelector(imageSelector, namespace string, comman
 }
 
 func (k *KubeHelper) ExecByContainer(labelSelector, containerName, namespace string, command []string) (string, error) {
-	targetOptions := targetselector.NewEmptyOptions().ApplyConfigParameter(nil, namespace, "", "")
-	targetOptions.AllowPick = false
-	targetOptions.Timeout = 120
-	targetOptions.LabelSelector = labelSelector
-	targetOptions.ContainerName = containerName
-	targetOptions.WaitingStrategy = targetselector.NewUntilNewestRunningWaitingStrategy(time.Second * 2)
+	targetOptions := targetselector.NewOptionsFromFlags(containerName, labelSelector, nil, namespace, "").
+		WithTimeout(120).
+		WithWaitingStrategy(targetselector.NewUntilNewestRunningWaitingStrategy(time.Second * 2))
+
 	container, err := targetselector.NewTargetSelector(k.client).SelectSingleContainer(context.TODO(), targetOptions, log.Discard)
 	if err != nil {
 		return "", err

pkg/devspace/build/builder/kaniko/kaniko.go

@@ -393,7 +393,8 @@ func (b *Builder) BuildImage(contextPath, dockerfilePath string, entrypoint []st
 		stdoutLogger := kanikoLogger{out: writer}
 
 		// Stream the logs
-		err = services.NewClient(b.helper.Config, nil, b.helper.KubeClient, log).StartLogsWithWriter(targetselector.NewOptionsFromFlags(buildPod.Spec.Containers[0].Name, "", buildPod.Namespace, buildPod.Name, false), true, 100, false, stdoutLogger)
+		options := targetselector.NewOptionsFromFlags(buildPod.Spec.Containers[0].Name, "", nil, buildPod.Namespace, buildPod.Name)
+		err = services.NewClient(b.helper.Config, nil, b.helper.KubeClient, log).StartLogsWithWriter(options, true, 100, false, stdoutLogger)
 		if err != nil {
 			return errors.Errorf("error printing build logs: %v", err)
 		}

pkg/devspace/hook/hook.go

@@ -143,16 +143,16 @@ func executeSingle(client kubectl.Client, config config.Config, dependencies []t
 			var hook Hook
 			if hookConfig.Container != nil {
 				if hookConfig.Upload != nil {
-					hook = NewRemoteHook(NewUploadHook(), client, hookConfig.Container.Namespace)
+					hook = NewRemoteHook(NewUploadHook())
 				} else if hookConfig.Download != nil {
-					hook = NewRemoteHook(NewDownloadHook(), client, hookConfig.Container.Namespace)
+					hook = NewRemoteHook(NewDownloadHook())
 				} else if hookConfig.Logs != nil {
 					// we use another waiting strategy here, because the pod might has finished already
-					hook = NewRemoteHookWithWaitingStrategy(NewLogsHook(hookWriter), targetselector.NewUntilNotWaitingStrategy(time.Second*2, client, hookConfig.Container.Namespace))
+					hook = NewRemoteHookWithWaitingStrategy(NewLogsHook(hookWriter), targetselector.NewUntilNotWaitingStrategy(time.Second*2))
 				} else if hookConfig.Wait != nil {
 					hook = NewWaitHook()
 				} else {
-					hook = NewRemoteHook(NewRemoteCommandHook(hookWriter, hookWriter), client, hookConfig.Container.Namespace)
+					hook = NewRemoteHook(NewRemoteCommandHook(hookWriter, hookWriter))
 				}
 			} else {
 				hook = NewLocalCommandHook(hookWriter, hookWriter)

pkg/devspace/hook/remote_hook.go

@@ -23,10 +23,10 @@ type RemoteHook interface {
 	ExecuteRemotely(hook *latest.HookConfig, podContainer *selector.SelectedPodContainer, client kubectl.Client, config config.Config, dependencies []types.Dependency, log logpkg.Logger) error
 }
 
-func NewRemoteHook(hook RemoteHook, client kubectl.Client, namespace string) Hook {
+func NewRemoteHook(hook RemoteHook) Hook {
 	return &remoteHook{
 		Hook:            hook,
-		WaitingStrategy: targetselector.NewUntilNewestRunningWaitingStrategy(time.Second*2, client, namespace),
+		WaitingStrategy: targetselector.NewUntilNewestRunningWaitingStrategy(time.Second * 2),
 	}
 }
 
@@ -95,20 +95,15 @@ func (r *remoteHook) execute(hook *latest.HookConfig, imageSelector []imageselec
 
 	// select the container
 	targetSelector := targetselector.NewTargetSelector(client)
-	podContainer, err := targetSelector.SelectSingleContainer(context.TODO(), targetselector.Options{
-		Selector: selector.Selector{
-			ImageSelector: imageSelector,
-			LabelSelector: labelSelector,
-			Pod:           hook.Container.Pod,
-			ContainerName: hook.Container.ContainerName,
-			Namespace:     hook.Container.Namespace,
-		},
-		Wait:            &wait,
-		Timeout:         timeout,
-		SortPods:        selector.SortPodsByNewest,
-		SortContainers:  selector.SortContainersByNewest,
-		WaitingStrategy: r.WaitingStrategy,
-	}, log)
+
+	// build target selector
+	targetSelectorOptions := targetselector.NewOptionsFromFlags(hook.Container.ContainerName, labelSelector, targetselector.ToStringImageSelector(imageSelector), hook.Container.Namespace, hook.Container.Pod).
+		WithTimeout(timeout).
+		WithWait(wait).
+		WithWaitingStrategy(r.WaitingStrategy)
+
+	// select container
+	podContainer, err := targetSelector.SelectSingleContainer(context.TODO(), targetSelectorOptions, log)
 	if err != nil {
 		if _, ok := err.(*targetselector.NotFoundErr); ok {
 			return false, nil