refactor: make commands and pull secrets maps

Author: FabianKramm

cmd/deploy.go

@@ -3,10 +3,13 @@ package cmd
 import (
 	"context"
 	"fmt"
+	"github.com/loft-sh/devspace/cmd/flags"
+	"github.com/loft-sh/devspace/pkg/devspace/analyze"
 	"github.com/loft-sh/devspace/pkg/devspace/build"
 	"github.com/loft-sh/devspace/pkg/devspace/config/loader"
 	"github.com/loft-sh/devspace/pkg/devspace/config/versions/latest"
 	devspacecontext "github.com/loft-sh/devspace/pkg/devspace/context"
+	"github.com/loft-sh/devspace/pkg/devspace/dependency"
 	"github.com/loft-sh/devspace/pkg/devspace/dependency/registry"
 	"github.com/loft-sh/devspace/pkg/devspace/deploy"
 	"github.com/loft-sh/devspace/pkg/devspace/dev"
@@ -18,19 +21,14 @@ import (
 	"github.com/loft-sh/devspace/pkg/devspace/plugin"
 	"github.com/loft-sh/devspace/pkg/devspace/server"
 	"github.com/loft-sh/devspace/pkg/devspace/upgrade"
-	"github.com/sirupsen/logrus"
-	"gopkg.in/yaml.v3"
-	"k8s.io/client-go/kubernetes/fake"
-	"time"
-
-	"github.com/loft-sh/devspace/cmd/flags"
-	"github.com/loft-sh/devspace/pkg/devspace/analyze"
-	"github.com/loft-sh/devspace/pkg/devspace/dependency"
 	"github.com/loft-sh/devspace/pkg/util/factory"
 	logpkg "github.com/loft-sh/devspace/pkg/util/log"
 	"github.com/loft-sh/devspace/pkg/util/message"
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
+	"gopkg.in/yaml.v3"
+	"k8s.io/client-go/kubernetes/fake"
 )
 
 // DeployCmd holds the required data for the down cmd
@@ -234,12 +232,6 @@ func runPipeline(ctx *devspacecontext.Context, f factory.Factory, options *Pipel
 		}
 	}
 
-	// create docker client
-	dockerClient, err := f.NewDockerClient(ctx.Log)
-	if err != nil {
-		dockerClient = nil
-	}
-
 	// deploy dependencies
 	dependencies, err := f.NewDependencyManager(ctx, options.ConfigOptions).ResolveAll(ctx, dependency.ResolveOptions{
 		SkipDependencies: options.DependencyOptions.Exclude,
@@ -262,12 +254,6 @@ func runPipeline(ctx *devspacecontext.Context, f factory.Factory, options *Pipel
 		return err
 	}
 
-	// create pull secrets if necessary
-	err = f.NewPullSecretClient(dockerClient).EnsurePullSecrets(ctx, ctx.KubeClient.Namespace())
-	if err != nil {
-		ctx.Log.Warn(err)
-	}
-
 	// update last used kube context & save generated yaml
 	err = updateLastKubeContext(ctx)
 	if err != nil {
@@ -339,24 +325,5 @@ func startServices(ctx *devspacecontext.Context, uiPort int) (*server.Server, er
 		return nil, err
 	}
 
-	// Run dev.open configs
-	for _, openConfig := range ctx.Config.Config().Open {
-		if openConfig.URL != "" {
-			maxWait := 4 * time.Minute
-			ctx.Log.Infof("Opening '%s' as soon as application will be started (timeout: %s)", openConfig.URL, maxWait)
-
-			go func(url string) {
-				// Use DiscardLogger as we do not want to print warnings about failed HTTP requests
-				err := openURL(url, nil, "", logpkg.Discard, maxWait)
-				if err != nil {
-					// Use warn instead of fatal to prevent exit
-					// Do not print warning
-					// log.Warn(err)
-					_ = err // just to avoid empty branch (SA9003) lint error
-				}
-			}(openConfig.URL)
-		}
-	}
-
 	return serv, nil
 }

cmd/init.go

@@ -515,7 +515,7 @@ func (cmd *InitCmd) addDevConfig(config *latest.Config, imageName, image string,
 			config.Dev["default"].Forward = portMappings
 
 			// Add dev.open config
-			config.Open = []*latest.OpenConfig{
+			config.Dev["default"].Open = []*latest.OpenConfig{
 				{
 					URL: "http://localhost:" + strconv.Itoa(localPort),
 				},

cmd/open.go

@@ -9,6 +9,7 @@ import (
 	"github.com/loft-sh/devspace/pkg/devspace/services/portforwarding"
 	"github.com/loft-sh/devspace/pkg/devspace/services/targetselector"
 	"github.com/sirupsen/logrus"
+	networkingv1 "k8s.io/api/networking/v1"
 	"k8s.io/apimachinery/pkg/labels"
 	"net/http"
 	"os"
@@ -38,9 +39,7 @@ import (
 	"github.com/skratchdot/open-golang/open"
 	"github.com/spf13/cobra"
 	v1 "k8s.io/api/core/v1"
-	"k8s.io/api/extensions/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/intstr"
 )
 
 const (
@@ -194,19 +193,23 @@ func (cmd *OpenCmd) RunOpen(f factory.Factory) error {
 		domainHash := hash.String(domain)
 
 		ingressName := "devspace-ingress-" + domainHash[:10]
-		_, err = client.KubeClient().ExtensionsV1beta1().Ingresses(namespace).Create(context.TODO(), &v1beta1.Ingress{
+		_, err = client.KubeClient().NetworkingV1().Ingresses(namespace).Create(context.TODO(), &networkingv1.Ingress{
 			ObjectMeta: metav1.ObjectMeta{Name: ingressName},
-			Spec: v1beta1.IngressSpec{
-				Rules: []v1beta1.IngressRule{
+			Spec: networkingv1.IngressSpec{
+				Rules: []networkingv1.IngressRule{
 					{
 						Host: domain,
-						IngressRuleValue: v1beta1.IngressRuleValue{
-							HTTP: &v1beta1.HTTPIngressRuleValue{
-								Paths: []v1beta1.HTTPIngressPath{
+						IngressRuleValue: networkingv1.IngressRuleValue{
+							HTTP: &networkingv1.HTTPIngressRuleValue{
+								Paths: []networkingv1.HTTPIngressPath{
 									{
-										Backend: v1beta1.IngressBackend{
-											ServiceName: serviceName,
-											ServicePort: intstr.FromInt(servicePort),
+										Backend: networkingv1.IngressBackend{
+											Service: &networkingv1.IngressServiceBackend{
+												Name: serviceName,
+												Port: networkingv1.ServiceBackendPort{
+													Number: int32(servicePort),
+												},
+											},
 										},
 									},
 								},
@@ -326,7 +329,7 @@ func (cmd *OpenCmd) openLocal(ctx *devspacecontext.Context, domain string) error
 		},
 	}
 
-	devSpaceConfig := config.Ensure(config.NewConfig(nil, fakeConfig, nil, nil, nil, constants.DefaultConfigPath))
+	devSpaceConfig := config.Ensure(config.NewConfig(nil, nil, fakeConfig, nil, nil, nil, constants.DefaultConfigPath))
 	ctx = ctx.WithConfig(devSpaceConfig)
 	options := targetselector.NewEmptyOptions().
 		WithLabelSelector(labels.Set(labelSelector).String()).
@@ -440,7 +443,7 @@ func (cmd *OpenCmd) findDomain(client kubectl.Client, namespace, host string) (s
 	cmd.log.Info("Retrieve ingresses...")
 
 	// List all ingresses and only create one if there is none already
-	ingressList, err := client.KubeClient().ExtensionsV1beta1().Ingresses(namespace).List(context.TODO(), metav1.ListOptions{})
+	ingressList, err := client.KubeClient().NetworkingV1().Ingresses(namespace).List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
 		return "", false, errors.Errorf("Error listing ingresses: %v", err)
 	}

cmd/run.go

@@ -204,7 +204,7 @@ func (cmd *RunCmd) RunRun(f factory.Factory, args []string) error {
 	return dependency.ExecuteCommand(ctx.Context, commands, args[0], args[1:], ctx.WorkingDir, cmd.Stdout, cmd.Stderr, os.Stdin)
 }
 
-func getCommands(f factory.Factory) ([]*latest.CommandConfig, error) {
+func getCommands(f factory.Factory) (map[string]*latest.CommandConfig, error) {
 	// get current working dir
 	cwd, err := os.Getwd()
 	if err != nil {

cmd/set/var.go

@@ -128,14 +128,14 @@ type variableParser struct {
 	Used        map[string]bool
 }
 
-func (v *variableParser) Parse(ctx context.Context, originalRawConfig map[string]interface{}, rawConfig map[string]interface{}, resolver variable.Resolver, log log.Logger) (*latest.Config, error) {
+func (v *variableParser) Parse(ctx context.Context, originalRawConfig map[string]interface{}, rawConfig map[string]interface{}, resolver variable.Resolver, log log.Logger) (*latest.Config, map[string]interface{}, error) {
 	// Find out what vars are really used
 	varsUsed, err := resolver.FindVariables(rawConfig)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	v.Definitions = resolver.DefinedVars()
 	v.Used = varsUsed
-	return latest.NewRaw(), nil
+	return latest.NewRaw(), map[string]interface{}{}, nil
 }

examples/kustomize/devspace.yaml

@@ -4,7 +4,7 @@ vars:
     value: yourusername/devspace
 images:
   default:
-    image: ${IMAGE}
+    image: loft-sh/vcluster
 deployments:
 - name: devspace-app
   kubectl:

examples/pipelines/devspace.yaml

@@ -1,29 +1,21 @@
 version: v2beta1
 name: pipelines
 
-commands:
-  - name: dev
-    command: |-
-      devspace --config dep1/dependency.yaml run dev
-
-dependencies:
-  - source:
-      path: dep1/dependency.yaml
-
 pipelines:
+  helper:
+    steps:
+      - run: |-
+          echo "Hello World!"
   dev:
     steps:
       - run: |-
-          run_dependencies_pipelines --all
-          
-          export IMAGE=testfabi
+          export TEST=$(run_pipelines helper)
+          echo $TEST > swag.txt
           
-          build_images test --set image=${IMAGE}
+          #build_images test --set image=${IMAGE}
           
-          # Deploy test here
-          create_deployments test --set helm.componentChart=true \
-                                  --set helm.values.containers[0].image=${runtime.images.test}
+          #create_deployments test2
           
           # Start development mode for test here
-          start_dev test --set imageSelector=${runtime.images.test} \
-                         --set terminal.command=sh
+          #start_dev test --set imageSelector=${runtime.images.test} \
+          #               --set terminal.command=sh

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

@@ -145,7 +145,7 @@ func (b *Builder) createPullSecret(ctx *devspacecontext.Context) error {
 		password = authConfig.IdentityToken
 	}
 
-	return pullsecrets.NewClient(b.dockerClient).CreatePullSecret(ctx, &pullsecrets.PullSecretOptions{
+	return pullsecrets.NewClient().CreatePullSecret(ctx, &pullsecrets.PullSecretOptions{
 		Namespace:       b.BuildNamespace,
 		RegistryURL:     registryURL,
 		Username:        username,

pkg/devspace/build/create_builder.go

@@ -97,7 +97,7 @@ func (c *controller) createBuilder(ctx *devspacecontext.Context, imageConfigName
 
 		dockerClient, err := dockerclient.NewClient(ctx.Log)
 		if err == nil {
-			err = pullsecrets.NewClient(dockerClient).EnsurePullSecret(ctx, ctx.KubeClient.Namespace(), registryURL)
+			err = pullsecrets.NewClient().EnsurePullSecret(ctx, dockerClient, ctx.KubeClient.Namespace(), registryURL)
 			if err != nil {
 				ctx.Log.Errorf("error ensuring pull secret for registry %s: %v", registryURL, err)
 			}

pkg/devspace/command/command.go

@@ -14,7 +14,7 @@ import (
 )
 
 // ExecuteCommand executes a command from the config
-func ExecuteCommand(ctx context.Context, commands []*latest.CommandConfig, name string, args []string, dir string, stdout io.Writer, stderr io.Writer, stdin io.Reader) error {
+func ExecuteCommand(ctx context.Context, commands map[string]*latest.CommandConfig, name string, args []string, dir string, stdout io.Writer, stderr io.Writer, stdin io.Reader) error {
 	shellCommand := ""
 	var shellArgs []string
 	var appendArgs bool