Use git partial clone and worktree to reduce network/file io

pkg/app/piped/deploysource/deploysource.go

@@ -211,6 +211,13 @@
 		return nil, err
 	}
 
+	// To avoid the git operation on copied source.
+	// TODO: do not copy the .git directory to improve the performance.
+	if err := os.RemoveAll(filepath.Join(dest, ".git")); err != nil {
+		fmt.Fprintf(lw, "Unable to remove the .git directory from the copied deploy source (%v)\n", err)
+		return nil, err
+	}
+
 	return &DeploySource{
 		RepoDir:                  dest,
 		AppDir:                   filepath.Join(dest, p.appGitPath.Path),

pkg/app/piped/driftdetector/cloudrun/detector.go

@@ -221,7 +221,7 @@
 	return d.reporter.ReportApplicationSyncState(ctx, app.Id, state)
 }
 
-func (d *detector) loadHeadServiceManifest(app *model.Application, repo git.Repo, headCommit git.Commit) (provider.ServiceManifest, error) {
+func (d *detector) loadHeadServiceManifest(app *model.Application, repo git.Worktree, headCommit git.Commit) (provider.ServiceManifest, error) {
 	var (
 		manifestCache = provider.ServiceManifestCache{
 			AppID:  app.Id,
@@ -263,6 +263,8 @@
 			if err != nil {
 				return provider.ServiceManifest{}, fmt.Errorf("failed to copy the cloned git repository (%w)", err)
 			}
+			defer repo.Clean()
+
 			repoDir := repo.GetPath()
 			appDir = filepath.Join(repoDir, app.GitPath.Path)
 		}

pkg/app/piped/driftdetector/ecs/detector.go

@@ -343,7 +343,7 @@
 	return live, head
 }
 
-func (d *detector) loadConfigs(app *model.Application, repo git.Repo, headCommit git.Commit) (provider.ECSManifests, error) {
+func (d *detector) loadConfigs(app *model.Application, repo git.Worktree, headCommit git.Commit) (provider.ECSManifests, error) {
 	var (
 		manifestCache = provider.ECSManifestsCache{
 			AppID:  app.Id,
@@ -387,6 +387,8 @@
 		if err != nil {
 			return provider.ECSManifests{}, fmt.Errorf("failed to copy the cloned git repository (%w)", err)
 		}
+		defer repo.Clean()
+
 		repoDir := repo.GetPath()
 		appDir = filepath.Join(repoDir, app.GitPath.Path)
 	}

pkg/app/piped/driftdetector/kubernetes/detector.go

@@ -236,7 +236,7 @@
 	return d.reporter.ReportApplicationSyncState(ctx, app.Id, state)
 }
 
-func (d *detector) loadHeadManifests(ctx context.Context, app *model.Application, repo git.Repo, headCommit git.Commit, watchingResourceKinds []provider.APIVersionKind) ([]provider.Manifest, error) {
+func (d *detector) loadHeadManifests(ctx context.Context, app *model.Application, repo git.Worktree, headCommit git.Commit, watchingResourceKinds []provider.APIVersionKind) ([]provider.Manifest, error) {
 	var (
 		manifestCache = provider.AppManifestsCache{
 			AppID:  app.Id,
@@ -278,6 +278,8 @@
 			if err != nil {
 				return nil, fmt.Errorf("failed to copy the cloned git repository (%w)", err)
 			}
+			defer repo.Clean()
+
 			repoDir = repo.GetPath()
 			appDir = filepath.Join(repoDir, app.GitPath.Path)
 		}

pkg/app/piped/driftdetector/lambda/detector.go

@@ -270,7 +270,7 @@
 	return cloneSpec
 }
 
-func (d *detector) loadHeadFunctionManifest(app *model.Application, repo git.Repo, headCommit git.Commit) (provider.FunctionManifest, error) {
+func (d *detector) loadHeadFunctionManifest(app *model.Application, repo git.Worktree, headCommit git.Commit) (provider.FunctionManifest, error) {
 	var (
 		manifestCache = provider.FunctionManifestCache{
 			AppID:  app.Id,
@@ -312,6 +312,8 @@
 			if err != nil {
 				return provider.FunctionManifest{}, fmt.Errorf("failed to copy the cloned git repository (%w)", err)
 			}
+			defer repo.Clean()
+
 			repoDir := repo.GetPath()
 			appDir = filepath.Join(repoDir, app.GitPath.Path)
 		}

pkg/app/piped/driftdetector/terraform/detector.go

@@ -169,7 +169,7 @@
 	}
 }
 
-func (d *detector) checkApplication(ctx context.Context, app *model.Application, repo git.Repo, headCommit git.Commit) error {
+func (d *detector) checkApplication(ctx context.Context, app *model.Application, repo git.Worktree, headCommit git.Commit) error {
 	var (
 		repoDir = repo.GetPath()
 		appDir  = filepath.Join(repoDir, app.GitPath.Path)
@@ -206,6 +206,8 @@
 		if err != nil {
 			return fmt.Errorf("failed to copy the cloned git repository (%w)", err)
 		}
+		defer repo.Clean()
+
 		repoDir = repo.GetPath()
 		appDir = filepath.Join(repoDir, app.GitPath.Path)
 	}

pkg/app/piped/eventwatcher/eventwatcher.go

@@ -319,7 +319,7 @@
 	if err != nil {
 		return fmt.Errorf("failed to create a new temporary directory: %w", err)
 	}
-	tmpRepo, err := repo.Copy(filepath.Join(tmpDir, "tmp-repo"))
+	tmpRepo, err := repo.CopyToModify(filepath.Join(tmpDir, "tmp-repo"))
 	if err != nil {
 		return fmt.Errorf("failed to copy the repository to the temporary directory: %w", err)
 	}
@@ -495,7 +495,7 @@
 	if err != nil {
 		return fmt.Errorf("failed to create a new temporary directory: %w", err)
 	}
-	tmpRepo, err := repo.Copy(filepath.Join(tmpDir, "tmp-repo"))
+	tmpRepo, err := repo.CopyToModify(filepath.Join(tmpDir, "tmp-repo"))
 	if err != nil {
 		return fmt.Errorf("failed to copy the repository to the temporary directory: %w", err)
 	}

pkg/app/pipedv1/deploysource/deploysource.go

@@ -191,6 +191,13 @@
 		return nil, err
 	}
 
+	// To avoid the git operation on copied source.
+	// TODO: do not copy the .git directory to improve the performance.
+	if err := os.RemoveAll(filepath.Join(dest, ".git")); err != nil {
+		fmt.Fprintf(lw, "Unable to remove the .git directory from the copied deploy source (%v)\n", err)
+		return nil, err
+	}
+
 	return &DeploySource{
 		RepoDir:                  dest,
 		AppDir:                   filepath.Join(dest, p.appGitPath.Path),

pkg/app/pipedv1/eventwatcher/eventwatcher.go

@@ -317,7 +317,7 @@
 	if err != nil {
 		return fmt.Errorf("failed to create a new temporary directory: %w", err)
 	}
-	tmpRepo, err := repo.Copy(filepath.Join(tmpDir, "tmp-repo"))
+	tmpRepo, err := repo.CopyToModify(filepath.Join(tmpDir, "tmp-repo"))
 	if err != nil {
 		return fmt.Errorf("failed to copy the repository to the temporary directory: %w", err)
 	}
@@ -478,7 +478,7 @@
 	if err != nil {
 		return fmt.Errorf("failed to create a new temporary directory: %w", err)
 	}
-	tmpRepo, err := repo.Copy(filepath.Join(tmpDir, "tmp-repo"))
+	tmpRepo, err := repo.CopyToModify(filepath.Join(tmpDir, "tmp-repo"))
 	if err != nil {
 		return fmt.Errorf("failed to copy the repository to the temporary directory: %w", err)
 	}

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=blob:none", remote, repoCachePath}
 				args = append(authArgs, args...)
 				return runGitCommand(ctx, c.gitPath, "", c.envsForRepo(remote), args...)
 			})
@@ -214,11 +214,12 @@ func (c *client) Clone(ctx context.Context, repoID, remote, branch, destination
 		}
 	}
 
-	args := []string{"clone"}
+	// git worktree add [-f] [--detach] [--checkout] [--lock [--reason <string>]]
+	//                   [--orphan] [(-b | -B) <new-branch>] <path> [<commit-ish>]
+	args := []string{"-C", repoCachePath, "worktree", "add", "--detach", destination}
 	if branch != "" {
-		args = append(args, "-b", branch)
+		args = append(args, branch)
 	}
-	args = append(args, repoCachePath, destination)
 
 	logger.Info("cloning a repo from cached one in local",
 		zap.String("src", repoCachePath),

pkg/git/repo.go

@@ -35,7 +35,8 @@
 type Repo interface {
 	GetPath() string
 	GetClonedBranch() string
-	Copy(dest string) (Repo, error)
+	Copy(dest string) (Worktree, error)
+	CopyToModify(dest string) (Repo, error)
 
 	ListCommits(ctx context.Context, visionRange string) ([]Commit, error)
 	GetLatestCommit(ctx context.Context) (Commit, error)
@@ -52,6 +53,17 @@
 	CommitChanges(ctx context.Context, branch, message string, newBranch bool, changes map[string][]byte, trailers map[string]string) error
 }
 
+// Worktree provides functions to get and handle git worktree.
+// It is a separate checkout of the repository.
+// It is used to make changes to the repository without affecting the main repository.
+// Worktree always does checkout with the detached HEAD, so it doesn't affect the main repository.
+type Worktree interface {
+	GetPath() string
+	Clean() error
+	Copy(dest string) (Worktree, error)
+	Checkout(ctx context.Context, commitish string) error
+}
+
 type repo struct {
 	dir          string
 	gitPath      string
@@ -60,6 +72,55 @@
 	gitEnvs      []string
 }
 
+// worktree is a git worktree.
+// It is a separate checkout of the repository.
+type worktree struct {
+	base         *repo
+	worktreePath string
+}
+
+func (r *worktree) runGitCommand(ctx context.Context, args ...string) ([]byte, error) {
+	cmd := exec.CommandContext(ctx, r.base.gitPath, args...)
+	cmd.Dir = r.worktreePath
+	cmd.Env = append(os.Environ(), r.base.gitEnvs...)
+	return cmd.CombinedOutput()
+}
+
+func (r *worktree) Copy(dest string) (Worktree, error) {
+	// garbage collecting worktrees
+	if _, err := r.runGitCommand(context.Background(), "worktree", "prune"); err != nil {
+		// ignore the error
+	}
+
+	if out, err := r.runGitCommand(context.Background(), "worktree", "add", "--detach", dest); err != nil {
+		return nil, formatCommandError(err, out)
+	}
+
+	return &worktree{
+		base:         r.base,
+		worktreePath: dest,
+	}, nil
+}
+
+func (r *worktree) GetPath() string {
+	return r.worktreePath
+}
+
+func (r *worktree) Clean() error {
+	if out, err := r.base.runGitCommand(context.Background(), "worktree", "remove", r.worktreePath); err != nil {
+		return formatCommandError(err, out)
+	}
+	return nil
+}
+
+func (r *worktree) Checkout(ctx context.Context, commitish string) error {
+	out, err := r.runGitCommand(ctx, "checkout", "--detach", commitish)
+	if err != nil {
+		return formatCommandError(err, out)
+	}
+	return nil
+}
+
 // NewRepo creates a new Repo instance.
 func NewRepo(dir, gitPath, remote, clonedBranch string, gitEnvs []string) *repo {
 	return &repo{
@@ -81,22 +142,55 @@
 	return r.clonedBranch
 }
 
-// Copy does copying the repository to the given destination.
+// Copy does copying the repository to the given destination using git worktree.
+// The repository is cloned to the given destination with the detached HEAD.
 // NOTE: the given “dest” must be a path that doesn’t exist yet.
-// If you don't, it copies the repo root itself to the given dest as a subdirectory.
-func (r *repo) Copy(dest string) (Repo, error) {
-	cmd := exec.Command("cp", "-rf", r.dir, dest)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
+// If you don't, you will get an error.
+func (r *repo) Copy(dest string) (Worktree, error) {
+	// garbage collecting worktrees
+	if _, err := r.runGitCommand(context.Background(), "worktree", "prune"); err != nil {
+		// ignore the error
+	}
+
+	if out, err := r.runGitCommand(context.Background(), "worktree", "add", "--detach", dest); err != nil {
 		return nil, formatCommandError(err, out)
 	}
 
-	return &repo{
+	return &worktree{
+		base:         r,
+		worktreePath: dest,
+	}, nil
+}
+
+// CopyToModify does cloning the repository to the given destination.
+// 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)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		return nil, formatCommandError(err, out)
+	}
+
+	cloned := &repo{
 		dir:          dest,
 		gitPath:      r.gitPath,
 		remote:       r.remote,
 		clonedBranch: r.clonedBranch,
-	}, nil
+		gitEnvs:      r.gitEnvs,
+	}
+
+	// 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
 }
 
 // ListCommits returns a list of commits in a given revision range.