Deploy without up

cmd/deploy.go

@@ -1,6 +1,10 @@
 package cmd
 
 import (
+	"os"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+
 	"github.com/covexo/devspace/pkg/devspace/cloud"
 	"github.com/covexo/devspace/pkg/devspace/config/configutil"
 	"github.com/covexo/devspace/pkg/devspace/config/generated"
@@ -11,6 +15,7 @@ import (
 	"github.com/covexo/devspace/pkg/devspace/registry"
 	"github.com/covexo/devspace/pkg/util/log"
 	"github.com/spf13/cobra"
+	git "gopkg.in/src-d/go-git.v4"
 )
 
 // DeployCmd holds the required data for the down cmd
@@ -26,6 +31,8 @@ type DeployCmdFlags struct {
 	DockerTarget  string
 	CloudTarget   string
 	SwitchContext bool
+	SkipBuild     bool
+	GitBranch     string
 }
 
 func init() {
@@ -47,8 +54,9 @@ devspace deploy --namespace=deploy --docker-target=production
 devspace deploy --kube-context=deploy-context
 devspace deploy --config=.devspace/deploy.yaml
 devspace deploy --cloud-target=production
+devspace deploy https://github.com/covexo/devspace --branch test
 #######################################################`,
-		Args: cobra.NoArgs,
+		Args: cobra.RangeArgs(0, 2),
 		Run:  cmd.Run,
 	}
 
@@ -58,12 +66,37 @@ devspace deploy --cloud-target=production
 	cobraCmd.Flags().StringVar(&cmd.flags.DockerTarget, "docker-target", "", "The docker target to use for building")
 	cobraCmd.Flags().StringVar(&cmd.flags.CloudTarget, "cloud-target", "", "When using a cloud provider, the target to use")
 	cobraCmd.Flags().BoolVar(&cmd.flags.SwitchContext, "switch-context", false, "Switches the kube context to the deploy context")
+	cobraCmd.Flags().BoolVar(&cmd.flags.SkipBuild, "skip-build", false, "Skips the image build & push step")
+	cobraCmd.Flags().StringVar(&cmd.flags.GitBranch, "branch", "master", "The git branch to checkout")
 
 	rootCmd.AddCommand(cobraCmd)
 }
 
 // Run executes the down command logic
 func (cmd *DeployCmd) Run(cobraCmd *cobra.Command, args []string) {
+	if len(args) > 0 {
+		directoryName := "devspace"
+		if len(args) == 2 {
+			directoryName = args[1]
+		}
+
+		_, err := git.PlainClone(directoryName, false, &git.CloneOptions{
+			URL:           args[0],
+			Progress:      os.Stdout,
+			ReferenceName: plumbing.ReferenceName(cmd.flags.GitBranch),
+		})
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		err = os.Chdir(directoryName)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		log.Donef("Successfully checked out %s into %s", args[0], directoryName)
+	}
+
 	cloud.UseDeployTarget = true
 	log.StartFileLogging()
 
@@ -100,10 +133,12 @@ func (cmd *DeployCmd) Run(cobraCmd *cobra.Command, args []string) {
 		log.Fatalf("Error loading generated.yaml: %v", err)
 	}
 
-	// Force image build
-	_, err = image.BuildAll(client, generatedConfig, true, log.GetInstance())
-	if err != nil {
-		log.Fatal(err)
+	if cmd.flags.SkipBuild == false {
+		// Force image build
+		_, err = image.BuildAll(client, generatedConfig, true, log.GetInstance())
+		if err != nil {
+			log.Fatal(err)
+		}
 	}
 
 	// Force deployment of all defined deployments

cmd/init.go

@@ -280,6 +280,7 @@ func (cmd *InitCmd) useCloudProvider() bool {
 
 	return false
 }
+
 func (cmd *InitCmd) loginToCloudProvider(providerConfig cloud.ProviderConfig, cloudProviderSelected string) {
 	config := configutil.GetConfig()
 	addToContext := cmd.flags.skipQuestions || cmd.flags.addDevSpaceCloudToLocalKubernetes
@@ -296,6 +297,7 @@ func (cmd *InitCmd) loginToCloudProvider(providerConfig cloud.ProviderConfig, cl
 	err := cloud.Update(providerConfig, &cloud.UpdateOptions{
 		UseKubeContext:    addToContext,
 		SwitchKubeContext: true,
+		SkipSaveConfig:    true,
 	}, log.GetInstance())
 	if err != nil {
 		log.Fatalf("Couldn't authenticate to %s: %v", cloudProviderSelected, err)

main.go

@@ -1,18 +1,24 @@
 package main
 
 import (
-	"os"
+	"fmt"
 
-	"github.com/covexo/devspace/cmd"
-	"github.com/covexo/devspace/pkg/devspace/upgrade"
+	"github.com/covexo/devspace/pkg/util/stdinutil"
 	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
 )
 
 var version string
 
 func main() {
-	upgrade.SetVersion(version)
+	/*upgrade.SetVersion(version)
 
 	cmd.Execute()
-	os.Exit(0)
+	os.Exit(0)*/
+	useDevSpaceCloud := *stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
+		Question:               "Do you want to use the DevSpace Cloud? (free ready-to-use Kubernetes) (yes | no)",
+		DefaultValue:           "yes",
+		ValidationRegexPattern: "^(yes)|(no)$",
+	})
+
+	fmt.Println(useDevSpaceCloud)
 }

pkg/devspace/builder/docker/auth.go

@@ -4,25 +4,24 @@ import (
 	"context"
 	"encoding/base64"
 	"encoding/json"
-	"fmt"
 
 	"github.com/covexo/devspace/pkg/util/log"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/client"
 	"github.com/docker/docker/registry"
 )
 
-func getOfficialServer(ctx context.Context, client client.CommonAPIClient) string {
+func getOfficialServer(ctx context.Context, client client.CommonAPIClient, log log.Logger) string {
 	// The daemon `/info` endpoint informs us of the default registry being
 	// used. This is essential in cross-platforms environment, where for
 	// example a Linux client might be interacting with a Windows daemon, hence
 	// the default registry URL might be Windows specific.
 	serverAddress := registry.IndexServer
 	if info, err := client.Info(ctx); err != nil {
 		// Only report the warning if we're in debug mode to prevent nagging during engine initialization workflows
-		fmt.Fprintf(log.GetInstance(), "Warning: failed to get default registry endpoint from daemon (%v). Using system default: %s\n", err, serverAddress)
+		// log.Warnf("Warning: failed to get default registry endpoint from daemon (%v). Using system default: %s", err, serverAddress)
 	} else if info.IndexServerAddress == "" {
-		fmt.Fprintf(log.GetInstance(), "Warning: Empty registry endpoint from daemon. Using system default: %s\n", serverAddress)
+		// log.Warnf("Warning: Empty registry endpoint from daemon. Using system default: %s", serverAddress)
 	} else {
 		serverAddress = info.IndexServerAddress
 	}

pkg/devspace/builder/docker/config.go

@@ -15,13 +15,11 @@ const dockerFileFolder = ".docker"
 
 var configDir = os.Getenv("DOCKER_CONFIG")
 
-func init() {
+func loadDockerConfig() (*configfile.ConfigFile, error) {
 	if configDir == "" {
 		configDir = filepath.Join(homedir.Get(), dockerFileFolder)
 	}
-}
 
-func loadDockerConfig() (*configfile.ConfigFile, error) {
 	return config.Load(configDir)
 }
 

pkg/devspace/builder/docker/docker.go

@@ -1,10 +1,12 @@
 package docker
 
 import (
+	"fmt"
 	"strings"
 
 	"context"
 
+	"github.com/covexo/devspace/pkg/util/log"
 	"github.com/docker/distribution/reference"
 	"github.com/docker/docker/pkg/term"
 	"github.com/docker/docker/registry"
@@ -149,47 +151,11 @@ func (b *Builder) BuildImage(contextPath, dockerfilePath string, options *types.
 
 // Authenticate authenticates the client with a remote registry
 func (b *Builder) Authenticate(user, password string, checkCredentialsStore bool) (*types.AuthConfig, error) {
-	ctx := context.Background()
-	authServer := getOfficialServer(ctx, b.client)
-	serverAddress := b.RegistryURL
-
-	if serverAddress == "" {
-		serverAddress = authServer
-	} else {
-		ref, err := reference.ParseNormalizedNamed(b.imageURL)
-		if err != nil {
-			return nil, err
-		}
-
-		repoInfo, err := registry.ParseRepositoryInfo(ref)
-		if err != nil {
-			return nil, err
-		}
-
-		if repoInfo.Index.Official {
-			serverAddress = authServer
-		}
-	}
-
-	authConfig, err := getDefaultAuthConfig(b.client, checkCredentialsStore, serverAddress, serverAddress == authServer)
-
-	if err != nil || authConfig.Username == "" || authConfig.Password == "" {
-		authConfig.Username = strings.TrimSpace(user)
-		authConfig.Password = strings.TrimSpace(password)
-	}
-
-	response, err := b.client.RegistryLogin(ctx, *authConfig)
+	authConfig, err := b.Login(user, password, checkCredentialsStore, false)
 	if err != nil {
 		return nil, err
 	}
 
-	if response.IdentityToken != "" {
-		authConfig.Password = ""
-		authConfig.IdentityToken = response.IdentityToken
-	}
-
-	b.authConfig = authConfig
-
 	// Cache authConfig for GetAuthConfig
 	authConfigs[b.RegistryURL] = authConfig
 
@@ -232,7 +198,6 @@ func GetAuthConfig(registryURL string) (*types.AuthConfig, error) {
 	}
 
 	authConfig, authConfigExists := authConfigs[registryURL]
-
 	if !authConfigExists {
 		dockerBuilder, err := NewBuilder(registryURL, "", "", false)
 		if err != nil {
@@ -244,5 +209,67 @@ func GetAuthConfig(registryURL string) (*types.AuthConfig, error) {
 			return nil, err
 		}
 	}
+
 	return authConfig, nil
 }
+
+// Login logs the user into docker
+func (b *Builder) Login(user, password string, checkCredentialsStore, saveAuthConfig bool) (*types.AuthConfig, error) {
+	ctx := context.Background()
+	authServer := getOfficialServer(ctx, b.client, log.GetInstance())
+	serverAddress := b.RegistryURL
+
+	if serverAddress == "" {
+		serverAddress = authServer
+	} else {
+		ref, err := reference.ParseNormalizedNamed(b.imageURL)
+		if err != nil {
+			return nil, err
+		}
+
+		repoInfo, err := registry.ParseRepositoryInfo(ref)
+		if err != nil {
+			return nil, err
+		}
+
+		if repoInfo.Index.Official {
+			serverAddress = authServer
+		}
+	}
+
+	authConfig, err := getDefaultAuthConfig(b.client, checkCredentialsStore, serverAddress, serverAddress == authServer)
+	if err != nil || authConfig.Username == "" || authConfig.Password == "" {
+		authConfig.Username = strings.TrimSpace(user)
+		authConfig.Password = strings.TrimSpace(password)
+	}
+
+	response, err := b.client.RegistryLogin(ctx, *authConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	if response.IdentityToken != "" {
+		authConfig.Password = ""
+		authConfig.IdentityToken = response.IdentityToken
+	}
+
+	if saveAuthConfig {
+		configfile, err := loadDockerConfig()
+		if err != nil {
+			return nil, err
+		}
+
+		err = configfile.GetCredentialsStore(serverAddress).Store(*authConfig)
+		if err != nil {
+			return nil, fmt.Errorf("Error saving auth info in credentials store: %v", err)
+		}
+
+		err = configfile.Save()
+		if err != nil {
+			return nil, fmt.Errorf("Error saving docker config: %v", err)
+		}
+	}
+
+	b.authConfig = authConfig
+	return b.authConfig, nil
+}

pkg/devspace/cloud/update.go

@@ -23,6 +23,7 @@ var UseDeployTarget = false
 type UpdateOptions struct {
 	UseKubeContext    bool
 	SwitchKubeContext bool
+	SkipSaveConfig    bool
 }
 
 // Update updates the cloud provider information if necessary
@@ -52,9 +53,6 @@ func Update(providerConfig ProviderConfig, options *UpdateOptions, log log.Logge
 	if dsConfig.Cluster.Namespace != nil {
 		devSpaceID = *dsConfig.Cluster.Namespace
 	}
-	if devSpaceID == "" && target != "" {
-		return fmt.Errorf("Cannot deploy to target %s without a devspace. You need to run `devspace up` beforehand", target)
-	}
 
 	domain, namespace, cluster, authInfo, err := CheckAuth(provider, devSpaceID, target, log)
 	if err != nil {
@@ -68,15 +66,15 @@ func Update(providerConfig ProviderConfig, options *UpdateOptions, log log.Logge
 
 	DevSpaceURL = domain
 
-	err = updateDevSpaceConfig(target, namespace, cluster, authInfo, options)
+	err = updateDevSpaceConfig(devSpaceID, target, namespace, cluster, authInfo, options)
 	if err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func updateDevSpaceConfig(target, namespace string, cluster *api.Cluster, authInfo *api.AuthInfo, options *UpdateOptions) error {
+func updateDevSpaceConfig(devSpaceID, target, namespace string, cluster *api.Cluster, authInfo *api.AuthInfo, options *UpdateOptions) error {
 	dsConfig := configutil.GetConfig()
 	overwriteConfig := configutil.GetOverwriteConfig()
 	saveConfig := false
@@ -143,7 +141,8 @@ func updateDevSpaceConfig(target, namespace string, cluster *api.Cluster, authIn
 		}
 	}
 
-	if saveConfig && target == "" {
+	// Either save when config has changed && devspace up or devspace deploy (with no up before)
+	if options.SkipSaveConfig == false && saveConfig && (target == "" || (target != "" && devSpaceID == "")) {
 		err := configutil.SaveConfig()
 		if err != nil {
 			return err