Local registry

cmd/build.go

@@ -10,9 +10,10 @@ import (
 // NewBuildCmd creates a new devspace build command
 func NewBuildCmd(f factory.Factory, globalFlags *flags.GlobalFlags, rawConfig *RawConfig) *cobra.Command {
 	cmd := &RunPipelineCmd{
-		GlobalFlags: globalFlags,
-		Pipeline:    "build",
-		ForceBuild:  true,
+		GlobalFlags:             globalFlags,
+		Pipeline:                "build",
+		ForceBuild:              true,
+		SkipPushLocalKubernetes: true,
 	}
 
 	var pipeline *latest.Pipeline

cmd/cleanup/cleanup.go

@@ -21,6 +21,7 @@ func NewCleanupCmd(f factory.Factory, globalFlags *flags.GlobalFlags, plugins []
 	}
 
 	cleanupCmd.AddCommand(newImagesCmd(f, globalFlags))
+	cleanupCmd.AddCommand(newLocalRegistryCmd(f, globalFlags))
 
 	// Add plugin commands
 	plugin.AddPluginCommands(cleanupCmd, plugins, "cleanup")

cmd/cleanup/local_registry.go

@@ -0,0 +1,171 @@
+package cleanup
+
+import (
+	"context"
+
+	"github.com/loft-sh/devspace/cmd/flags"
+	"github.com/loft-sh/devspace/pkg/devspace/build/registry"
+	"github.com/loft-sh/devspace/pkg/devspace/kubectl"
+	"github.com/loft-sh/devspace/pkg/util/factory"
+	"github.com/loft-sh/devspace/pkg/util/message"
+	"github.com/loft-sh/devspace/pkg/util/survey"
+	"github.com/sirupsen/logrus"
+	kerrors "k8s.io/apimachinery/pkg/api/errors"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+type localRegistryCmd struct {
+	*flags.GlobalFlags
+}
+
+func newLocalRegistryCmd(f factory.Factory, globalFlags *flags.GlobalFlags) *cobra.Command {
+	cmd := &localRegistryCmd{GlobalFlags: globalFlags}
+
+	localRegistryCmd := &cobra.Command{
+		Use:   "local-registry",
+		Short: "Deletes the local image registry",
+		Long: ` 
+#######################################################
+######### devspace cleanup local-registry #############
+#######################################################
+Deletes the local image registry
+#######################################################
+	`,
+		Args: cobra.NoArgs,
+		RunE: func(cobraCmd *cobra.Command, args []string) error {
+			return cmd.RunCleanupLocalRegistry(f, cobraCmd, args)
+		}}
+
+	return localRegistryCmd
+}
+
+// RunCleanupLocalRegistry executes the cleanup local-registry command logic
+func (cmd *localRegistryCmd) RunCleanupLocalRegistry(f factory.Factory, cobraCmd *cobra.Command, args []string) error {
+	ctx := context.Background()
+	log := f.GetLog()
+
+	// set config root
+	configLoader, err := f.NewConfigLoader(cmd.ConfigPath)
+	if err != nil {
+		return err
+	}
+	configExists, err := configLoader.SetDevSpaceRoot(log)
+	if err != nil {
+		return err
+	} else if !configExists {
+		return errors.New(message.ConfigNotFound)
+	}
+
+	// create kubectl client
+	client, err := f.NewKubeClientFromContext(cmd.KubeContext, cmd.Namespace)
+	if err != nil {
+		log.Warnf("Unable to create new kubectl client: %v", err)
+		log.WriteString(logrus.WarnLevel, "\n")
+		client = nil
+	}
+
+	// load generated config
+	localCache, err := configLoader.LoadLocalCache()
+	if err != nil {
+		return errors.Errorf("error loading local cache: %v", err)
+	}
+
+	if client != nil {
+		// If the current kube context or namespace is different than old,
+		// show warnings and reset kube client if necessary
+		client, err = kubectl.CheckKubeContext(client, localCache, cmd.NoWarn, cmd.SwitchContext, false, log)
+		if err != nil {
+			return err
+		}
+	}
+
+	// load config
+	configInterface, err := configLoader.LoadWithCache(ctx, localCache, client, cmd.ToConfigOptions(), log)
+	if err != nil {
+		return err
+	}
+
+	// clean up registry according to options
+	config := configInterface.Config()
+	options := registry.NewDefaultOptions().
+		WithNamespace(client.Namespace()).
+		WithLocalRegistryConfig(config.LocalRegistry)
+
+	hasStatefulSet := true
+	_, err = client.KubeClient().AppsV1().StatefulSets(options.Namespace).Get(ctx, options.Name, v1.GetOptions{})
+	if err != nil {
+		if kerrors.IsNotFound(err) {
+			hasStatefulSet = false
+		} else {
+			return errors.Wrap(err, "clean up statefulset")
+		}
+	}
+
+	hasDeployment := true
+	_, err = client.KubeClient().AppsV1().Deployments(options.Namespace).Get(ctx, options.Name, v1.GetOptions{})
+	if err != nil {
+		if kerrors.IsNotFound(err) {
+			hasDeployment = false
+		} else {
+			return errors.Wrap(err, "clean up statefulset")
+		}
+	}
+
+	hasService := true
+	_, err = client.KubeClient().CoreV1().Services(options.Namespace).Get(ctx, options.Name, v1.GetOptions{})
+	if err != nil {
+		if kerrors.IsNotFound(err) {
+			hasService = false
+		} else {
+			return errors.Wrap(err, "clean up statefulset")
+		}
+	}
+
+	if !hasStatefulSet && !hasDeployment && !hasService {
+		log.Donef("No local registry found.")
+		return nil
+	}
+
+	// prompt user since this is a destructive action
+	cleanupAnswer, err := log.Question(&survey.QuestionOptions{
+		Question: "This will delete your local registry and all the images it contains. Do you wish to continue?",
+		Options: []string{
+			"Yes",
+			"No",
+		},
+	})
+	if err != nil {
+		return err
+	}
+
+	if cleanupAnswer == "No" {
+		return nil
+	}
+
+	if hasStatefulSet {
+		err = client.KubeClient().AppsV1().StatefulSets(options.Namespace).Delete(ctx, options.Name, v1.DeleteOptions{})
+		if err != nil && !kerrors.IsNotFound(err) {
+			return errors.Wrap(err, "clean up statefulset")
+		}
+	}
+
+	if hasDeployment {
+		err = client.KubeClient().AppsV1().Deployments(options.Namespace).Delete(ctx, options.Name, v1.DeleteOptions{})
+		if err != nil && !kerrors.IsNotFound(err) {
+			return errors.Wrap(err, "clean up deployment")
+		}
+	}
+
+	if hasService {
+		err = client.KubeClient().CoreV1().Services(options.Namespace).Delete(ctx, options.Name, v1.DeleteOptions{})
+		if err != nil && !kerrors.IsNotFound(err) {
+			return errors.Wrap(err, "clean up service")
+		}
+	}
+
+	log.Donef("Successfully cleaned up local registry")
+	return nil
+}

cmd/init.go

@@ -662,6 +662,19 @@ func annotateConfig(configPath string) error {
 #     tag: v1.0.0
 #   ui:
 #     path: ./ui        # Path-based dependencies (for monorepos)
+`)...)
+
+	annotatedConfig = append(annotatedConfig, []byte(`
+# Customize local registry settings 
+# localRegistry:
+#   enabled: true                     # Always use local registry, remove to only use the local registry when required
+#   name: registry
+#   namespace: ${devspace.namespace}  # Uses the current kube context's namespace (can be removed)
+#   image: registry:2.8.1
+#   port: 5000
+#   persistence:
+#     enabled: false
+#     size: 5Gi
 `)...)
 
 	err = ioutil.WriteFile(configPath, annotatedConfig, os.ModePerm)

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/localregistry"
 	_ "github.com/loft-sh/devspace/e2e/tests/pipelines"
 	_ "github.com/loft-sh/devspace/e2e/tests/portforward"
 	_ "github.com/loft-sh/devspace/e2e/tests/proxycommands"

e2e/tests/config/config.go

@@ -3,10 +3,12 @@ package config
 import (
 	"bytes"
 	"fmt"
-	"github.com/loft-sh/devspace/pkg/devspace/config/constants"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 
+	"github.com/loft-sh/devspace/pkg/devspace/config/constants"
+
 	"github.com/loft-sh/devspace/pkg/devspace/config/loader"
 	"github.com/loft-sh/devspace/pkg/devspace/config/loader/variable"
 	"github.com/loft-sh/devspace/pkg/devspace/config/localcache"
@@ -106,8 +108,11 @@ var _ = DevSpaceDescribe("config", func() {
 		// read the generated.yaml
 		config, err := localcache.NewCacheLoader().Load(constants.DefaultConfigPath)
 		framework.ExpectNoError(err)
+
 		ic, _ := config.GetImageCache("app-test")
-		framework.ExpectLocalFileContentsImmediately(filepath.Join(tempDir, "out0.txt"), "my-docker-username/helloworld2:"+ic.Tag)
+		out, err := ioutil.ReadFile(filepath.Join(tempDir, "out0.txt"))
+		framework.ExpectNoError(err)
+		gomega.Expect(string(out)).To(gomega.MatchRegexp("my-docker-username/helloworld2:" + ic.Tag))
 	})
 
 	ginkgo.It("should load multiple profiles in order via --profile", func() {

e2e/tests/localregistry/framework.go

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