Cherry-pick to release-v0.51.x (#5772)

* Do treeless clone for git clone to improve performance (#5722)

Signed-off-by: Shinnosuke Sawada-Dazai <[email protected]>
Signed-off-by: pipecd-bot <[email protected]>

* remove temp sshKeyFile after use(#2215) (#5769)

Signed-off-by: hiep-tk <[email protected]>
Signed-off-by: pipecd-bot <[email protected]>

---------

Signed-off-by: Shinnosuke Sawada-Dazai <[email protected]>
Signed-off-by: pipecd-bot <[email protected]>
Signed-off-by: hiep-tk <[email protected]>
Co-authored-by: Shinnosuke Sawada-Dazai <[email protected]>
Co-authored-by: Hiep Trinh <[email protected]>

Author: 3 people

pkg/app/piped/cmd/piped/piped.go

@@ -175,10 +175,12 @@ func (p *piped) run(ctx context.Context, input cli.Input) (runErr error) {
 
 	// Configure SSH config if needed.
 	if cfg.Git.ShouldConfigureSSHConfig() {
-		if err := git.AddSSHConfig(cfg.Git); err != nil {
+		tempFile, err := git.AddSSHConfig(cfg.Git)
+		if err != nil {
 			input.Logger.Error("failed to configure ssh-config", zap.Error(err))
 			return err
 		}
+		defer os.Remove(tempFile)
 		input.Logger.Info("successfully configured ssh-config")
 	}
 

pkg/git/client.go

@@ -166,7 +166,7 @@ func (c *client) Clone(ctx context.Context, repoID, remote, branch, destination
 				return nil, err
 			}
 			out, err := retryCommand(3, time.Second, logger, func() ([]byte, error) {
-				args := []string{"clone", "--mirror", remote, repoCachePath}
+				args := []string{"clone", "--mirror", "--filter=tree:0", remote, repoCachePath}
 				args = append(authArgs, args...)
 				return runGitCommand(ctx, c.gitPath, "", c.envsForRepo(remote), args...)
 			})

pkg/git/repo.go

@@ -164,11 +164,12 @@ func (r *repo) Copy(dest string) (Worktree, error) {
 }
 
 // CopyToModify does cloning the repository to the given destination.
+// This method clones the repository from remote origin to the given destination, not from local repository.
 // The repository is cloned to the given destination with the .
 // NOTE: the given “dest” must be a path that doesn’t exist yet.
 // If you don't, you will get an error.
 func (r *repo) CopyToModify(dest string) (Repo, error) {
-	cmd := exec.Command(r.gitPath, "clone", r.dir, dest)
+	cmd := exec.Command(r.gitPath, "clone", "--filter=tree:0", "--branch", r.clonedBranch, r.remote, dest)
 	if out, err := cmd.CombinedOutput(); err != nil {
 		return nil, formatCommandError(err, out)
 	}
@@ -187,16 +188,6 @@ func (r *repo) CopyToModify(dest string) (Repo, error) {
 		}
 	}
 
-	// because we did a local cloning so set the remote url of origin
-	if err := cloned.setRemote(context.Background(), r.remote); err != nil {
-		return nil, err
-	}
-
-	// fetch the latest changes which doesn't exist in the local repository
-	if out, err := cloned.runGitCommand(context.Background(), "fetch"); err != nil {
-		return nil, formatCommandError(err, out)
-	}
-
 	return cloned, nil
 }
 

pkg/git/repo_test.go

@@ -288,9 +288,12 @@ func TestCopyToModify(t *testing.T) {
 	err = faker.makeRepo(org, repoName)
 	require.NoError(t, err)
 	r := &repo{
-		dir:     faker.repoDir(org, repoName),
-		gitPath: faker.gitPath,
-		remote:  faker.repoDir(org, repoName), // use the same directory as remote, it's not a real remote. it's strange but it's ok for testing.
+		dir:          faker.repoDir(org, repoName),
+		gitPath:      faker.gitPath,
+		remote:       faker.repoDir(org, repoName), // use the same directory as remote, it's not a real remote. it's strange but it's ok for testing.
+		username:     "test-user",
+		email:        "test-email",
+		clonedBranch: "master",
 	}
 
 	commits, err := r.ListCommits(ctx, "")

pkg/git/ssh_config.go

@@ -48,52 +48,61 @@ type sshConfig struct {
 	IdentityFile string
 }
 
-func AddSSHConfig(cfg config.PipedGit) error {
+func AddSSHConfig(cfg config.PipedGit) (string, error) {
 	cfgPath := cfg.SSHConfigFilePath
 	if cfgPath == "" {
 		home, err := os.UserHomeDir()
 		if err != nil {
-			return fmt.Errorf("failed to detect the current user's home directory: %w", err)
+			return "", fmt.Errorf("failed to detect the current user's home directory: %w", err)
 		}
 		cfgPath = path.Join(home, ".ssh", "config")
 	}
 	sshDir := filepath.Dir(cfgPath)
 
 	if err := os.MkdirAll(sshDir, 0700); err != nil {
-		return fmt.Errorf("failed to create a directory %s: %v", sshDir, err)
+		return "", fmt.Errorf("failed to create a directory %s: %v", sshDir, err)
 	}
 
 	sshKey, err := cfg.LoadSSHKey()
 	if err != nil {
-		return err
+		return "", err
 	}
 
 	sshKeyFile, err := os.CreateTemp(sshDir, "piped-ssh-key-*")
 	if err != nil {
-		return err
+		return "", err
 	}
+	needCleanUp := false
+	defer func() {
+		if needCleanUp {
+			os.Remove(sshKeyFile.Name())
+		}
+	}()
 
-	// TODO: Remove this key file when Piped terminating.
 	if _, err := sshKeyFile.Write(sshKey); err != nil {
-		return err
+		needCleanUp = true
+		return "", err
 	}
 
 	configData, err := generateSSHConfig(cfg, sshKeyFile.Name())
 	if err != nil {
-		return err
+		needCleanUp = true
+		return "", err
 	}
 
 	f, err := os.OpenFile(cfgPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
 	if err != nil {
-		return fmt.Errorf("could not create/append to %s: %v", cfgPath, err)
+		needCleanUp = true
+		return "", fmt.Errorf("could not create/append to %s: %v", cfgPath, err)
 	}
 	defer f.Close()
 
 	if _, err := f.Write([]byte(configData)); err != nil {
-		return fmt.Errorf("failed to write sshConfig to %s: %v", cfgPath, err)
+		needCleanUp = true
+		return "", fmt.Errorf("failed to write sshConfig to %s: %v", cfgPath, err)
 	}
 
-	return nil
+	return sshKeyFile.Name(), nil
 }
 
 func generateSSHConfig(cfg config.PipedGit, sshKeyFile string) (string, error) {