feat: exec_container & run_default_pipeline

Author: FabianKramm

cmd/deploy.go

@@ -271,7 +271,7 @@ func runPipeline(ctx *devspacecontext.Context, f factory.Factory, forceLeader bo
 	if ctx.Config.Config().Pipelines != nil && ctx.Config.Config().Pipelines[options.Pipeline] != nil {
 		configPipeline = ctx.Config.Config().Pipelines[options.Pipeline]
 	} else {
-		configPipeline, err = pipeline.GetDefaultPipeline(options.Pipeline)
+		configPipeline, err = types.GetDefaultPipeline(options.Pipeline)
 		if err != nil {
 			return err
 		}

e2e/e2e_suite_test.go

@@ -18,6 +18,7 @@ import (
 	_ "github.com/loft-sh/devspace/e2e/tests/hooks"
 	_ "github.com/loft-sh/devspace/e2e/tests/imports"
 	_ "github.com/loft-sh/devspace/e2e/tests/init"
+	_ "github.com/loft-sh/devspace/e2e/tests/pipelines"
 	_ "github.com/loft-sh/devspace/e2e/tests/pullsecret"
 	_ "github.com/loft-sh/devspace/e2e/tests/render"
 	_ "github.com/loft-sh/devspace/e2e/tests/replacepods"

e2e/tests/pipelines/framework.go

@@ -0,0 +1,8 @@
+package pipelines
+
+import "github.com/onsi/ginkgo"
+
+// DevSpaceDescribe annotates the test with the label.
+func DevSpaceDescribe(text string, body func()) bool {
+	return ginkgo.Describe("[pipelines] "+text, body)
+}

e2e/tests/pipelines/pipelines.go

@@ -0,0 +1,51 @@
+package pipelines
+
+import (
+	"github.com/loft-sh/devspace/cmd"
+	"github.com/loft-sh/devspace/cmd/flags"
+	"github.com/loft-sh/devspace/e2e/framework"
+	"github.com/loft-sh/devspace/e2e/kube"
+	"github.com/loft-sh/devspace/pkg/util/factory"
+	"github.com/onsi/ginkgo"
+	"os"
+)
+
+var _ = DevSpaceDescribe("portforward", func() {
+	initialDir, err := os.Getwd()
+	if err != nil {
+		panic(err)
+	}
+
+	// create a new factory
+	var (
+		f          factory.Factory
+		kubeClient *kube.KubeHelper
+	)
+
+	ginkgo.BeforeEach(func() {
+		f = framework.NewDefaultFactory()
+
+		kubeClient, err = kube.NewKubeHelper()
+		framework.ExpectNoError(err)
+	})
+
+	ginkgo.It("should exec container", func() {
+		tempDir, err := framework.CopyToTempDir("tests/pipelines/testdata/exec_container")
+		framework.ExpectNoError(err)
+		defer framework.CleanupTempDir(initialDir, tempDir)
+
+		ns, err := kubeClient.CreateNamespace("pipelines")
+		framework.ExpectNoError(err)
+		defer framework.ExpectDeleteNamespace(kubeClient, ns)
+
+		devCmd := &cmd.DevCmd{
+			GlobalFlags: &flags.GlobalFlags{
+				NoWarn:    true,
+				Namespace: ns,
+			},
+		}
+		err = devCmd.Run(f)
+		framework.ExpectNoError(err)
+		framework.ExpectLocalFileContentsImmediately("test.txt", "Hello World!\n")
+	})
+})

e2e/tests/pipelines/testdata/exec_container/devspace.yaml

@@ -0,0 +1,18 @@
+version: v2beta1
+name: exec
+
+deployments:
+  test:
+    helm:
+      values:
+        containers:
+          - image: alpine
+            command: ["sleep", "99999999"]
+
+pipelines:
+  dev:
+    steps:
+      - run: |-
+          run_default_pipeline deploy
+          
+          echo "Hello World!" | exec_container --image-selector alpine --silent -- cat - > test.txt 

pkg/devspace/pipeline/engine/pipelinehandler/commands/exec_container.go

@@ -0,0 +1,69 @@
+package commands
+
+import (
+	"fmt"
+	"github.com/jessevdk/go-flags"
+	devspacecontext "github.com/loft-sh/devspace/pkg/devspace/context"
+	"github.com/loft-sh/devspace/pkg/devspace/kubectl"
+	"github.com/loft-sh/devspace/pkg/devspace/services/targetselector"
+	"github.com/loft-sh/devspace/pkg/util/log"
+	"github.com/pkg/errors"
+	"mvdan.cc/sh/v3/interp"
+	"strings"
+	"time"
+)
+
+type ExecContainerOptions struct {
+	ImageSelector string `long:"image-selector" description:"The image selector to use to select the container"`
+	LabelSelector string `long:"label-selector" description:"The label selector to use to select the container"`
+	Container     string `long:"container" description:"The container to use"`
+
+	Namespace   string `long:"namespace" short:"n" description:"The namespace to use"`
+	DisableWait bool   `long:"disable-wait" description:"If true, will not wait for the container to become ready"`
+	Timeout     int64  `long:"timeout" description:"The timeout to wait. Defaults to 5 minutes"`
+	Silent      bool   `long:"silent" short:"s" description:"If true will not output any other log messages"`
+}
+
+func ExecContainer(ctx *devspacecontext.Context, args []string) error {
+	hc := interp.HandlerCtx(ctx.Context)
+
+	ctx.Log.Debugf("exec_container %s", strings.Join(args, " "))
+	options := &ExecContainerOptions{
+		Namespace: ctx.KubeClient.Namespace(),
+	}
+	args, err := flags.ParseArgs(options, args)
+	if err != nil {
+		return errors.Wrap(err, "parse args")
+	}
+	if len(args) == 0 {
+		return fmt.Errorf("usage: exec_container [--image-selector|--label-selector] COMMAND")
+	}
+	if options.ImageSelector == "" && options.LabelSelector == "" {
+		return fmt.Errorf("usage: exec_container [--image-selector|--label-selector] COMMAND")
+	}
+
+	logger := ctx.Log
+	if options.Silent {
+		logger = log.Discard
+	}
+
+	selectorOptions := targetselector.NewOptionsFromFlags(options.Container, options.LabelSelector, []string{options.ImageSelector}, options.Namespace, "")
+	if options.Timeout != 0 {
+		selectorOptions = selectorOptions.WithTimeout(options.Timeout)
+	}
+	selectorOptions.WithWaitingStrategy(targetselector.NewUntilNewestRunningWaitingStrategy(time.Millisecond * 500))
+	selectedContainer, err := targetselector.NewTargetSelector(selectorOptions).SelectSingleContainer(ctx.Context, ctx.KubeClient, logger)
+	if err != nil {
+		return err
+	}
+
+	return ctx.KubeClient.ExecStream(ctx.Context, &kubectl.ExecStreamOptions{
+		Pod:         selectedContainer.Pod,
+		Container:   selectedContainer.Container.Name,
+		Command:     args,
+		Stdin:       hc.Stdin,
+		Stdout:      hc.Stdout,
+		Stderr:      hc.Stderr,
+		SubResource: kubectl.SubResourceExec,
+	})
+}

pkg/devspace/pipeline/engine/pipelinehandler/commands/run_command.go

@@ -0,0 +1,34 @@
+package commands
+
+import (
+	"fmt"
+	devspacecontext "github.com/loft-sh/devspace/pkg/devspace/context"
+	"github.com/loft-sh/devspace/pkg/devspace/pipeline/engine"
+	enginetypes "github.com/loft-sh/devspace/pkg/devspace/pipeline/engine/types"
+	"github.com/loft-sh/devspace/pkg/devspace/pipeline/types"
+	"io"
+	"mvdan.cc/sh/v3/interp"
+)
+
+type NewHandlerFn func(ctx *devspacecontext.Context, stdout io.Writer, pipeline types.Pipeline) enginetypes.ExecHandler
+
+func RunCommand(ctx *devspacecontext.Context, pipeline types.Pipeline, args []string, newHandler NewHandlerFn) error {
+	hc := interp.HandlerCtx(ctx.Context)
+	if len(args) == 0 {
+		return fmt.Errorf("please specify a command to run")
+	}
+
+	// try to find command
+	for _, command := range ctx.Config.Config().Commands {
+		if command.Name == args[0] {
+			if len(command.Args) > 0 {
+				return fmt.Errorf("calling commands that use args is not supported currently")
+			}
+
+			_, err := engine.ExecutePipelineShellCommand(ctx.Context, command.Command, args[1:], hc.Dir, false, hc.Stdout, hc.Stderr, hc.Stdin, hc.Env, newHandler(ctx, hc.Stdout, pipeline))
+			return err
+		}
+	}
+
+	return fmt.Errorf("couldn't find command %v", args[0])
+}

pkg/devspace/pipeline/engine/pipelinehandler/commands/run_default_pipeline.go

@@ -0,0 +1,24 @@
+package commands
+
+import (
+	"fmt"
+	devspacecontext "github.com/loft-sh/devspace/pkg/devspace/context"
+	"github.com/loft-sh/devspace/pkg/devspace/pipeline/engine"
+	"github.com/loft-sh/devspace/pkg/devspace/pipeline/types"
+	"mvdan.cc/sh/v3/interp"
+)
+
+func RunDefaultPipeline(ctx *devspacecontext.Context, pipeline types.Pipeline, args []string, newHandler NewHandlerFn) error {
+	hc := interp.HandlerCtx(ctx.Context)
+	if len(args) != 1 {
+		return fmt.Errorf("usage: run_default_pipeline [pipeline]")
+	}
+
+	defaultPipeline, err := types.GetDefaultPipeline(args[0])
+	if err != nil {
+		return err
+	}
+
+	_, err = engine.ExecutePipelineShellCommand(ctx.Context, defaultPipeline.Steps[0].Run, nil, hc.Dir, false, hc.Stdout, hc.Stderr, hc.Stdin, hc.Env, newHandler(ctx, hc.Stdout, pipeline))
+	return err
+}

pkg/devspace/pipeline/engine/pipelinehandler/handler.go

@@ -7,7 +7,6 @@ import (
 	"io"
 
 	devspacecontext "github.com/loft-sh/devspace/pkg/devspace/context"
-	"github.com/loft-sh/devspace/pkg/devspace/pipeline/engine"
 	"github.com/loft-sh/devspace/pkg/devspace/pipeline/engine/basichandler"
 	"github.com/loft-sh/devspace/pkg/devspace/pipeline/engine/pipelinehandler/commands"
 	enginetypes "github.com/loft-sh/devspace/pkg/devspace/pipeline/engine/types"
@@ -19,11 +18,17 @@ import (
 
 // PipelineCommands are commands that can only be run within a pipeline and have special functionality in there
 var PipelineCommands = map[string]func(devCtx *devspacecontext.Context, pipeline types.Pipeline, args []string) error{
+	"exec_container": func(devCtx *devspacecontext.Context, pipeline types.Pipeline, args []string) error {
+		return commands.ExecContainer(devCtx, args)
+	},
 	"get_image": func(devCtx *devspacecontext.Context, pipeline types.Pipeline, args []string) error {
 		return commands.GetImage(devCtx, args)
 	},
 	"run_command": func(devCtx *devspacecontext.Context, pipeline types.Pipeline, args []string) error {
-		return runCommand(devCtx, pipeline, args)
+		return commands.RunCommand(devCtx, pipeline, args, NewPipelineExecHandler)
+	},
+	"run_default_pipeline": func(devCtx *devspacecontext.Context, pipeline types.Pipeline, args []string) error {
+		return commands.RunDefaultPipeline(devCtx, pipeline, args, NewPipelineExecHandler)
 	},
 	"run_pipelines": func(devCtx *devspacecontext.Context, pipeline types.Pipeline, args []string) error {
 		return commands.RunPipelines(devCtx, pipeline, args)
@@ -128,27 +133,6 @@ func (e *execHandler) executePipelineCommand(ctx context.Context, command string
 	return true, handleError(ctx, command, commandFn())
 }
 
-func runCommand(ctx *devspacecontext.Context, pipeline types.Pipeline, args []string) error {
-	hc := interp.HandlerCtx(ctx.Context)
-	if len(args) == 0 {
-		return fmt.Errorf("please specify a command to run")
-	}
-
-	// try to find command
-	for _, command := range ctx.Config.Config().Commands {
-		if command.Name == args[0] {
-			if len(command.Args) > 0 {
-				return fmt.Errorf("calling commands that use args is not supported currently")
-			}
-
-			_, err := engine.ExecutePipelineShellCommand(ctx.Context, command.Command, args[1:], ctx.WorkingDir, false, hc.Stdout, hc.Stderr, hc.Stdin, hc.Env, NewPipelineExecHandler(ctx, hc.Stdout, pipeline))
-			return err
-		}
-	}
-
-	return fmt.Errorf("couldn't find command %v", args[0])
-}
-
 func handleError(ctx context.Context, command string, err error) error {
 	if err == nil {
 		return interp.NewExitStatus(0)

pkg/devspace/pipeline/pipeline.go

@@ -187,7 +187,7 @@ func (p *pipeline) startNewDependency(ctx *devspacecontext.Context, dependency t
 		err            error
 	)
 	if dependency.Config().Config().Pipelines == nil || dependency.Config().Config().Pipelines[executePipeline] == nil {
-		pipelineConfig, err = GetDefaultPipeline(executePipeline)
+		pipelineConfig, err = types.GetDefaultPipeline(executePipeline)
 		if err != nil {
 			return err
 		}