refactor: lazy exclude & create namespace

FabianKramm · FabianKramm · commit 21af882b67ef · 2022-04-05T11:03:40.000+02:00
diff --git a/cmd/run_pipeline.go b/cmd/run_pipeline.go
@@ -37,7 +37,6 @@ import (
 	"io/ioutil"
 	"k8s.io/client-go/kubernetes/fake"
 	"os"
-	"strings"
 )
 
 // RunPipelineCmd holds the command flags
@@ -168,7 +167,7 @@ func (cmd *RunPipelineCmd) Run(cobraCmd *cobra.Command, args []string, f factory
 	}
 
 	return runWithHooks(ctx, hookName, func() error {
-		return runPipeline(ctx, true, options)
+		return runPipeline(ctx, options)
 	})
 }
 
@@ -259,14 +258,6 @@ func initialize(ctx context.Context, f factory.Factory, allowFailingKubeClient b
 		WithConfig(configInterface).
 		WithKubeClient(client)
 
-	// create namespace if necessary
-	if !options.DeployOptions.Render {
-		err := kubectl.EnsureNamespace(devCtx.Context(), devCtx.KubeClient(), devCtx.KubeClient().Namespace(), devCtx.Log())
-		if err != nil {
-			return nil, errors.Errorf("unable to create namespace: %v", err)
-		}
-	}
-
 	// print config
 	if devCtx.Log().GetLevel() == logrus.DebugLevel {
 		out, _ := yaml.Marshal(devCtx.Config().Config())
@@ -291,7 +282,7 @@ func initialize(ctx context.Context, f factory.Factory, allowFailingKubeClient b
 
 func updateLastKubeContext(ctx devspacecontext.Context) error {
 	// Update generated if we deploy the application
-	if ctx.Config != nil && ctx.Config().LocalCache() != nil {
+	if ctx.Config() != nil && ctx.Config().LocalCache() != nil {
 		ctx.Config().LocalCache().SetLastContext(&localcache.LastContextConfig{
 			Context:   ctx.KubeClient().CurrentContext(),
 			Namespace: ctx.KubeClient().Namespace(),
@@ -422,7 +413,7 @@ func (cmd *RunPipelineCmd) BuildOptions(configOptions *loader.ConfigOptions) *Co
 	}
 }
 
-func runPipeline(ctx devspacecontext.Context, forceLeader bool, options *CommandOptions) error {
+func runPipeline(ctx devspacecontext.Context, options *CommandOptions) error {
 	var configPipeline *latest.Pipeline
 	if ctx.Config().Config().Pipelines != nil && ctx.Config().Config().Pipelines[options.Pipeline] != nil {
 		configPipeline = ctx.Config().Config().Pipelines[options.Pipeline]
@@ -461,15 +452,6 @@ func runPipeline(ctx devspacecontext.Context, forceLeader bool, options *Command
 	}
 	dependencyRegistry.SetServer("http://" + serv.Server.Addr)
 
-	// exclude ourselves
-	couldExclude, err := dependencyRegistry.MarkDependencyExcluded(ctx, ctx.Config().Config().Name, forceLeader)
-	if err != nil {
-		return err
-	} else if !couldExclude {
-		return fmt.Errorf("couldn't execute '%s', because there is another DevSpace instance active in the current namespace right now that uses the same project name (%s)", strings.Join(os.Args, " "), ctx.Config().Config().Name)
-	}
-	ctx.Log().Debugf("Marked project excluded: %v", ctx.Config().Config().Name)
-
 	// get a stdout writer
 	stdoutWriter := ctx.Log().Writer(ctx.Log().GetLevel(), true)
 	defer stdoutWriter.Close()
diff --git a/pkg/devspace/pipeline/engine/pipelinehandler/commands/build_images.go b/pkg/devspace/pipeline/engine/pipelinehandler/commands/build_images.go
@@ -24,10 +24,15 @@ type BuildImagesOptions struct {
 
 func BuildImages(ctx devspacecontext.Context, pipeline types.Pipeline, args []string) error {
 	ctx.Log().Debugf("build_images %s", strings.Join(args, " "))
+	err := pipeline.Exclude(ctx)
+	if err != nil {
+		return err
+	}
+
 	options := &BuildImagesOptions{
 		Options: pipeline.Options().BuildOptions,
 	}
-	args, err := flags.ParseArgs(options, args)
+	args, err = flags.ParseArgs(options, args)
 	if err != nil {
 		return errors.Wrap(err, "parse args")
 	}
diff --git a/pkg/devspace/pipeline/engine/pipelinehandler/commands/create_deployments.go b/pkg/devspace/pipeline/engine/pipelinehandler/commands/create_deployments.go
@@ -31,10 +31,15 @@ type CreateDeploymentsOptions struct {
 
 func CreateDeployments(ctx devspacecontext.Context, pipeline types.Pipeline, args []string, stdout io.Writer) error {
 	ctx.Log().Debugf("create_deployments %s", strings.Join(args, " "))
+	err := pipeline.Exclude(ctx)
+	if err != nil {
+		return err
+	}
+
 	options := &CreateDeploymentsOptions{
 		Options: pipeline.Options().DeployOptions,
 	}
-	args, err := flags.ParseArgs(options, args)
+	args, err = flags.ParseArgs(options, args)
 	if err != nil {
 		return errors.Wrap(err, "parse args")
 	}
diff --git a/pkg/devspace/pipeline/engine/pipelinehandler/commands/ensure_pull_secrets.go b/pkg/devspace/pipeline/engine/pipelinehandler/commands/ensure_pull_secrets.go
@@ -5,6 +5,7 @@ import (
 	flags "github.com/jessevdk/go-flags"
 	devspacecontext "github.com/loft-sh/devspace/pkg/devspace/context"
 	"github.com/loft-sh/devspace/pkg/devspace/docker"
+	"github.com/loft-sh/devspace/pkg/devspace/pipeline/types"
 	"github.com/loft-sh/devspace/pkg/devspace/pullsecrets"
 	"github.com/pkg/errors"
 	"strings"
@@ -20,10 +21,15 @@ type EnsurePullSecretsOptions struct {
 	All bool `long:"all" description:"Ensure all pull secrets"`
 }
 
-func EnsurePullSecrets(ctx devspacecontext.Context, args []string) error {
+func EnsurePullSecrets(ctx devspacecontext.Context, pipeline types.Pipeline, args []string) error {
 	ctx.Log().Debugf("ensure_pull_secrets %s", strings.Join(args, " "))
+	err := pipeline.Exclude(ctx)
+	if err != nil {
+		return err
+	}
+
 	options := &EnsurePullSecretsOptions{}
-	args, err := flags.ParseArgs(options, args)
+	args, err = flags.ParseArgs(options, args)
 	if err != nil {
 		return errors.Wrap(err, "parse args")
 	}
diff --git a/pkg/devspace/pipeline/engine/pipelinehandler/commands/purge_deployments.go b/pkg/devspace/pipeline/engine/pipelinehandler/commands/purge_deployments.go
@@ -23,10 +23,15 @@ type PurgeDeploymentsOptions struct {
 
 func PurgeDeployments(ctx devspacecontext.Context, pipeline types.Pipeline, args []string) error {
 	ctx.Log().Debugf("purge_deployments %s", strings.Join(args, " "))
+	err := pipeline.Exclude(ctx)
+	if err != nil {
+		return err
+	}
+
 	options := &PurgeDeploymentsOptions{
 		PurgeOptions: pipeline.Options().PurgeOptions,
 	}
-	args, err := flags.ParseArgs(options, args)
+	args, err = flags.ParseArgs(options, args)
 	if err != nil {
 		return errors.Wrap(err, "parse args")
 	}
diff --git a/pkg/devspace/pipeline/engine/pipelinehandler/commands/run_default_pipeline.go b/pkg/devspace/pipeline/engine/pipelinehandler/commands/run_default_pipeline.go
@@ -13,6 +13,11 @@ import (
 type NewHandlerFn func(ctx devspacecontext.Context, stdout, stderr io.Writer, pipeline types.Pipeline) enginetypes.ExecHandler
 
 func RunDefaultPipeline(ctx devspacecontext.Context, pipeline types.Pipeline, args []string, newHandler NewHandlerFn) error {
+	err := pipeline.Exclude(ctx)
+	if err != nil {
+		return err
+	}
+
 	hc := interp.HandlerCtx(ctx.Context())
 	if len(args) != 1 {
 		return fmt.Errorf("usage: run_default_pipeline [pipeline]")
diff --git a/pkg/devspace/pipeline/engine/pipelinehandler/commands/run_dependency_pipelines.go b/pkg/devspace/pipeline/engine/pipelinehandler/commands/run_dependency_pipelines.go
@@ -20,10 +20,15 @@ type RunDependencyPipelinesOptions struct {
 
 func RunDependencyPipelines(ctx devspacecontext.Context, pipeline types.Pipeline, args []string) error {
 	ctx.Log().Debugf("run_dependency_pipelines %s", strings.Join(args, " "))
+	err := pipeline.Exclude(ctx)
+	if err != nil {
+		return err
+	}
+
 	options := &RunDependencyPipelinesOptions{
 		DependencyOptions: pipeline.Options().DependencyOptions,
 	}
-	args, err := flags.ParseArgs(options, args)
+	args, err = flags.ParseArgs(options, args)
 	if err != nil {
 		return errors.Wrap(err, "parse args")
 	}
diff --git a/pkg/devspace/pipeline/engine/pipelinehandler/commands/start_dev.go b/pkg/devspace/pipeline/engine/pipelinehandler/commands/start_dev.go
@@ -25,10 +25,15 @@ type StartDevOptions struct {
 
 func StartDev(ctx devspacecontext.Context, pipeline types.Pipeline, args []string) error {
 	ctx.Log().Debugf("start_dev %s", strings.Join(args, " "))
+	err := pipeline.Exclude(ctx)
+	if err != nil {
+		return err
+	}
+
 	options := &StartDevOptions{
 		Options: pipeline.Options().DevOptions,
 	}
-	args, err := flags.ParseArgs(options, args)
+	args, err = flags.ParseArgs(options, args)
 	if err != nil {
 		return errors.Wrap(err, "parse args")
 	}
diff --git a/pkg/devspace/pipeline/engine/pipelinehandler/commands/stop_dev.go b/pkg/devspace/pipeline/engine/pipelinehandler/commands/stop_dev.go
@@ -19,10 +19,15 @@ type StopDevOptions struct {
 
 func StopDev(ctx devspacecontext.Context, pipeline types.Pipeline, args []string) error {
 	ctx.Log().Debugf("stop_dev %s", strings.Join(args, " "))
+	err := pipeline.Exclude(ctx)
+	if err != nil {
+		return err
+	}
+
 	options := &StopDevOptions{
 		PurgeOptions: pipeline.Options().PurgeOptions,
 	}
-	args, err := flags.ParseArgs(options, args)
+	args, err = flags.ParseArgs(options, args)
 	if err != nil {
 		return errors.Wrap(err, "parse args")
 	}
diff --git a/pkg/devspace/pipeline/engine/pipelinehandler/handler.go b/pkg/devspace/pipeline/engine/pipelinehandler/handler.go
@@ -59,7 +59,7 @@ var PipelineCommands = map[string]func(devCtx devspacecontext.Context, pipeline
 		return commands.RunDependencyPipelines(devCtx, pipeline, args)
 	},
 	"ensure_pull_secrets": func(devCtx devspacecontext.Context, pipeline types.Pipeline, args []string) error {
-		return commands.EnsurePullSecrets(devCtx, args)
+		return commands.EnsurePullSecrets(devCtx, pipeline, args)
 	},
 	"is_dependency": func(devCtx devspacecontext.Context, pipeline types.Pipeline, args []string) error {
 		return commands.IsDependency(devCtx.Context(), args)
diff --git a/pkg/devspace/pipeline/pipeline.go b/pkg/devspace/pipeline/pipeline.go
@@ -4,7 +4,9 @@ import (
 	"context"
 	"fmt"
 	"github.com/loft-sh/devspace/pkg/devspace/context/values"
+	"github.com/loft-sh/devspace/pkg/devspace/kubectl"
 	utilerrors "k8s.io/apimachinery/pkg/util/errors"
+	"os"
 	"strings"
 	"sync"
 
@@ -39,6 +41,9 @@ func NewPipeline(name string, devPodManager devpod.Manager, dependencyRegistry r
 type pipeline struct {
 	m sync.Mutex
 
+	excluded    bool
+	excludedErr error
+
 	options types.Options
 
 	name               string
@@ -52,6 +57,46 @@ type pipeline struct {
 	jobs map[string]*Job
 }
 
+func (p *pipeline) Exclude(ctx devspacecontext.Context) error {
+	// get parent
+	if p.Parent() != nil {
+		parent := p.Parent()
+		for parent.Parent() != nil {
+			parent = parent.Parent()
+		}
+
+		return p.Exclude(ctx)
+	}
+
+	// make sure we are locked
+	p.m.Lock()
+	defer p.m.Unlock()
+
+	if p.excluded {
+		return p.excludedErr
+	}
+
+	p.excluded = true
+
+	// create namespace if necessary
+	p.excludedErr = kubectl.EnsureNamespace(ctx.Context(), ctx.KubeClient(), ctx.KubeClient().Namespace(), ctx.Log())
+	if p.excludedErr != nil {
+		p.excludedErr = errors.Errorf("unable to create namespace: %v", p.excludedErr)
+		return p.excludedErr
+	}
+
+	// exclude ourselves
+	var couldExclude bool
+	couldExclude, p.excludedErr = p.dependencyRegistry.MarkDependencyExcluded(ctx, p.name, true)
+	if p.excludedErr != nil {
+		return p.excludedErr
+	} else if !couldExclude {
+		return fmt.Errorf("couldn't execute '%s', because there is another DevSpace instance active in the current namespace right now that uses the same project name (%s)", strings.Join(os.Args, " "), p.name)
+	}
+	ctx.Log().Debugf("Marked project excluded: %v", p.name)
+	return nil
+}
+
 func (p *pipeline) Parent() types.Pipeline {
 	return p.parent
 }
diff --git a/pkg/devspace/pipeline/types/pipeline.go b/pkg/devspace/pipeline/types/pipeline.go
@@ -45,6 +45,10 @@ type Pipeline interface {
 	// Parent retrieves the pipeline parent or nil if there is non
 	Parent() Pipeline
 
+	// Exclude locks the upmost parent pipeline in the namespace and ensures only
+	// a single DevSpace instance is running this project at the same time
+	Exclude(ctx devspacecontext.Context) error
+
 	// Dependencies retrieves the currently created dependencies
 	Dependencies() map[string]Pipeline
 
