feat: add proxyCommands.gitCredentials

Author: FabianKramm

helper/cmd/proxycommands/configure.go

@@ -3,8 +3,10 @@ package proxycommands
 import (
 	"encoding/base64"
 	"fmt"
+	"github.com/mitchellh/go-homedir"
 	"io/ioutil"
 	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/loft-sh/devspace/helper/util/stderrlog"
@@ -24,6 +26,8 @@ type ConfigureCmd struct {
 	PrivateKey string
 	WorkingDir string
 
+	GitCredentials bool
+
 	Commands []string
 }
 
@@ -41,6 +45,7 @@ func NewConfigureCmd() *cobra.Command {
 	configureCmd.Flags().StringVar(&cmd.PrivateKey, "private-key", "", "Private key to use")
 	configureCmd.Flags().StringVar(&cmd.WorkingDir, "working-dir", "", "Working dir to use")
 	configureCmd.Flags().StringSliceVar(&cmd.Commands, "commands", []string{}, "Commands to overwrite")
+	configureCmd.Flags().BoolVar(&cmd.GitCredentials, "git-credentials", false, "If git credentials should get configured")
 	return configureCmd
 }
 
@@ -118,6 +123,24 @@ func (cmd *ConfigureCmd) Run(_ *cobra.Command, _ []string) error {
 		}
 	}
 
+	// now configure git credentials
+	if cmd.GitCredentials {
+		homeDir, err := homedir.Dir()
+		if err != nil {
+			return err
+		}
+
+		gitConfigPath := filepath.Join(homeDir, ".gitconfig")
+		out, err = ioutil.ReadFile(gitConfigPath)
+		if err != nil || !strings.Contains(string(out), "helper = \"/tmp/devspacehelper proxy-commands git-credentials\"") {
+			content := string(out) + "\n" + "[credential]" + "\n" + "        helper = \"/tmp/devspacehelper proxy-commands git-credentials\"\n"
+			err = ioutil.WriteFile(gitConfigPath, []byte(content), 0644)
+			if err != nil {
+				return errors.Wrap(err, "write git config")
+			}
+		}
+	}
+
 	// print working dir to stdout
 	fmt.Print(workingDir)
 	return nil

helper/cmd/proxycommands/git_credentials.go

@@ -0,0 +1,31 @@
+package proxycommands
+
+import (
+	"github.com/spf13/cobra"
+)
+
+// GitCredentials holds the cmd flags
+type GitCredentials struct{}
+
+// NewGitCredentialsCmd creates a new ssh command
+func NewGitCredentialsCmd() *cobra.Command {
+	cmd := &GitCredentials{}
+	runCmd := &cobra.Command{
+		Use:                "git-credentials",
+		Short:              "Retrieves git credentials from local",
+		DisableFlagParsing: true,
+		RunE:               cmd.Run,
+	}
+	return runCmd
+}
+
+// Run runs the command logic
+func (cmd *GitCredentials) Run(_ *cobra.Command, args []string) error {
+	if len(args) == 0 {
+		return nil
+	} else if args[0] != "get" {
+		return nil
+	}
+
+	return runProxyCommand([]string{"git-credentials", "credential", "fill"})
+}

helper/cmd/proxycommands/proxy_commands.go

@@ -14,5 +14,6 @@ func NewProxyCommands() *cobra.Command {
 
 	reverseCommandsCmd.AddCommand(NewConfigureCmd())
 	reverseCommandsCmd.AddCommand(NewRunCmd())
+	reverseCommandsCmd.AddCommand(NewGitCredentialsCmd())
 	return reverseCommandsCmd
 }

helper/cmd/proxycommands/run.go

@@ -30,6 +30,10 @@ func NewRunCmd() *cobra.Command {
 
 // Run runs the command logic
 func (cmd *RunCmd) Run(_ *cobra.Command, args []string) error {
+	return runProxyCommand(args)
+}
+
+func runProxyCommand(args []string) error {
 	key, err := ioutil.ReadFile(sshPrivateKeyPath)
 	if err != nil {
 		return errors.Wrap(err, "read private key")

pkg/devspace/config/versions/latest/schema.go

@@ -916,6 +916,9 @@ type RestartHelper struct {
 }
 
 type ProxyCommand struct {
+	// GitCredentials configures a git credentials helper inside the container that proxies local git credentials
+	GitCredentials bool `yaml:"gitCredentials,omitempty" json:"gitCredentials,omitempty"`
+
 	// Command is the name of the command that should be available in the remote container. DevSpace
 	// will create a small script for that inside the container that redirect command execution to
 	// the local computer.

pkg/devspace/services/proxycommands/commands.go

@@ -97,7 +97,11 @@ func startLocalSSH(ctx devspacecontext.Context, selector targetselector.TargetSe
 
 	// gather all commands that should get replaced in the container
 	commandsToReplace := []string{}
+	gitCredentials := false
 	for _, r := range reverseCommands {
+		if r.GitCredentials {
+			gitCredentials = true
+		}
 		if r.Command == "" {
 			continue
 		}
@@ -106,7 +110,14 @@ func startLocalSSH(ctx devspacecontext.Context, selector targetselector.TargetSe
 	}
 
 	// execute configure command in container
-	command := []string{inject.DevSpaceHelperContainerPath, "proxy-commands", "configure", "--public-key", base64.StdEncoding.EncodeToString([]byte(publicKey)), "--private-key", base64.StdEncoding.EncodeToString([]byte(privateKey)), "--commands", strings.Join(commandsToReplace, ",")}
+	command := []string{inject.DevSpaceHelperContainerPath, "proxy-commands", "configure", "--public-key", base64.StdEncoding.EncodeToString([]byte(publicKey)), "--private-key", base64.StdEncoding.EncodeToString([]byte(privateKey))}
+	if len(commandsToReplace) > 0 {
+		command = append(command, "--commands", strings.Join(commandsToReplace, ","))
+	}
+	if gitCredentials {
+		command = append(command, "--git-credentials")
+	}
+
 	stdout, stderr, err := ctx.KubeClient().ExecBuffered(ctx.Context(), container.Pod, container.Container.Name, command, nil)
 	if err != nil {
 		return fmt.Errorf("error setting up proxy commands in container: %s %s %v", string(stdout), string(stderr), err)

pkg/devspace/services/proxycommands/server.go

@@ -140,6 +140,10 @@ func (s *Server) getCommand(sess ssh.Session) (*exec.Cmd, *types.ProxyCommand, e
 
 	var reverseCommand *latest.ProxyCommand
 	for _, r := range s.commands {
+		if r.GitCredentials && command.Args[0] == "git-credentials" {
+			reverseCommand = r
+			break
+		}
 		if r.Command == command.Args[0] {
 			reverseCommand = r
 			break
@@ -153,6 +157,9 @@ func (s *Server) getCommand(sess ssh.Session) (*exec.Cmd, *types.ProxyCommand, e
 	if reverseCommand.LocalCommand != "" {
 		c = reverseCommand.LocalCommand
 	}
+	if reverseCommand.GitCredentials {
+		c = "git"
+	}
 
 	args := []string{}
 	for _, arg := range command.Args[1:] {
@@ -176,13 +183,16 @@ func (s *Server) getCommand(sess ssh.Session) (*exec.Cmd, *types.ProxyCommand, e
 	}
 
 	s.log.Debugf("run command '%s %s' locally", c, strings.Join(args, " "))
-	if !reverseCommand.SkipContainerEnv {
+	if !reverseCommand.SkipContainerEnv && !reverseCommand.GitCredentials {
 		cmd.Env = append(cmd.Env, command.Env...)
 	}
 	cmd.Env = append(cmd.Env, os.Environ()...)
 	for k, v := range reverseCommand.Env {
 		cmd.Env = append(cmd.Env, k+"="+v)
 	}
+	if reverseCommand.GitCredentials {
+		cmd.Env = append(cmd.Env, "GIT_ASKPASS=true")
+	}
 	return cmd, command, nil
 }