fetch instead of pull, try to detect different remote

Author: johnstcn

git/git.go

@@ -15,6 +15,7 @@ import (
 	giturls "github.com/chainguard-dev/git-urls"
 	"github.com/go-git/go-billy/v5"
 	"github.com/go-git/go-git/v5"
+	gitconfig "github.com/go-git/go-git/v5/config"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/cache"
 	"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
@@ -99,8 +100,7 @@ func CloneRepo(ctx context.Context, logf func(string, ...any), opts CloneRepoOpt
 		return false, fmt.Errorf("chroot .git: %w", err)
 	}
 	gitStorage := filesystem.NewStorage(gitDir, cache.NewObjectLRU(cache.DefaultMaxSize*10))
-	fsStorage := filesystem.NewStorage(fs, cache.NewObjectLRU(cache.DefaultMaxSize*10))
-	repo, err := git.Open(fsStorage, gitDir)
+	repo, err := git.Open(gitStorage, fs)
 	if err == nil {
 		// Repo exists, so fast-forward it.
 		return fastForwardRepo(ctx, logf, opts, repo, reference)
@@ -129,44 +129,107 @@ func CloneRepo(ctx context.Context, logf func(string, ...any), opts CloneRepoOpt
 	if err != nil {
 		return false, fmt.Errorf("clone %q: %w", opts.RepoURL, err)
 	}
-	if head, err := repo.Head(); err == nil && head != nil {
-		logf("cloned repo HEAD: %s", head.Hash().String())
+	if head, err := repoHead(repo); err != nil {
+		logf("failed to get repo HEAD: %s", err)
+	} else {
+		logf("cloned repo at %s", head)
 	}
 	return true, nil
 }
 
 func fastForwardRepo(ctx context.Context, logf func(string, ...any), opts CloneRepoOptions, repo *git.Repository, referenceName string) (bool, error) {
-	if head, err := repo.Head(); err == nil && head != nil {
-		logf("existing repo HEAD: %s", head.Hash().String())
+	if referenceName == "" {
+		referenceName = "refs/heads/main"
 	}
-	wt, err := repo.Worktree()
+	ref := plumbing.ReferenceName(referenceName)
+	headBefore, err := repoHead(repo)
 	if err != nil {
-		return false, fmt.Errorf("worktree: %w", err)
+		return false, err
 	}
-	err = wt.PullContext(ctx, &git.PullOptions{
-		RemoteName:      "", // use default remote
-		ReferenceName:   plumbing.ReferenceName(referenceName),
-		SingleBranch:    opts.SingleBranch,
-		Depth:           opts.Depth,
+	logf("existing repo HEAD: %s", headBefore)
+
+	remote, err := repo.Remote("origin")
+	if err != nil {
+		return false, fmt.Errorf("remote: %w", err)
+	}
+
+	if len(remote.Config().URLs) == 0 {
+		logf("remote %q has no URLs configured!", remote.String())
+		return false, nil
+	}
+
+	// If the remote URL differs, stop! We don't want to accidentally
+	// fetch from a different remote.
+	for _, u := range remote.Config().URLs {
+		if u != opts.RepoURL {
+			logf("remote %q has URL %q, expected %q", remote.String(), u, opts.RepoURL)
+			return false, nil
+		}
+	}
+
+	var refSpecs []gitconfig.RefSpec
+	if referenceName != "" {
+		// git checkout -b <branch> --track <remote>/<branch>
+		refSpecs = []gitconfig.RefSpec{
+			gitconfig.RefSpec(fmt.Sprintf("%s:%s", referenceName, referenceName)),
+		}
+	}
+
+	if err := remote.FetchContext(ctx, &git.FetchOptions{
 		Auth:            opts.RepoAuth,
-		Progress:        opts.Progress,
+		CABundle:        opts.CABundle,
+		Depth:           opts.Depth,
 		Force:           false,
 		InsecureSkipTLS: opts.Insecure,
-		CABundle:        opts.CABundle,
+		Progress:        opts.Progress,
 		ProxyOptions:    opts.ProxyOptions,
-	})
-	if err == nil {
-		if head, err := repo.Head(); err == nil && head != nil {
-			logf("fast-forwarded to %s", head.Hash().String())
+		RefSpecs:        refSpecs,
+		RemoteName:      "origin",
+	}); err != nil {
+		if err != git.NoErrAlreadyUpToDate {
+			return false, fmt.Errorf("fetch changes from remote: %w", err)
 		}
-		return true, nil
+		logf("repository is already up-to-date")
+	}
+
+	// Now that we've fetched changes from the remote,
+	// attempt to check out the requested reference.
+	wt, err := repo.Worktree()
+	if err != nil {
+		return false, fmt.Errorf("worktree: %w", err)
 	}
-	if errors.Is(err, git.NoErrAlreadyUpToDate) {
-		logf("existing repo already up-to-date")
+	st, err := wt.Status()
+	if err != nil {
+		return false, fmt.Errorf("status: %w", err)
+	}
+	// If the working tree is dirty, assume that the user wishes to
+	// test local changes. Skip the checkout.
+	if !st.IsClean() {
+		logf("working tree is dirty, skipping checkout")
 		return false, nil
 	}
-	logf("failed to fast-forward: %s", err.Error())
-	return false, err
+	if err := wt.Checkout(&git.CheckoutOptions{
+		Branch: ref,
+		// Note: we already checked that the working tree is clean, but I'd rather
+		//       err on the side of caution.
+		Keep: true,
+	}); err != nil {
+		return false, fmt.Errorf("checkout branch %s: %w", ref.String(), err)
+	}
+	headAfter, err := repoHead(repo)
+	if err != nil {
+		return false, fmt.Errorf("check repo HEAD: %w", err)
+	}
+	logf("checked out %s", headAfter)
+	return headBefore != headAfter, nil
+}
+
+func repoHead(repo *git.Repository) (string, error) {
+	head, err := repo.Head()
+	if err != nil {
+		return "", err
+	}
+	return head.Hash().String(), nil
 }
 
 // ShallowCloneRepo will clone the repository at the given URL into the given path

git/git_test.go

@@ -22,6 +22,7 @@ import (
 	"github.com/go-git/go-billy/v5/osfs"
 	githttp "github.com/go-git/go-git/v5/plumbing/transport/http"
 	gitssh "github.com/go-git/go-git/v5/plumbing/transport/ssh"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	gossh "golang.org/x/crypto/ssh"
 )
@@ -89,14 +90,24 @@ func TestCloneRepo(t *testing.T) {
 				srv := httptest.NewServer(authMW(gittest.NewServer(srvFS)))
 				clientFS := memfs.New()
 				// A repo already exists!
-				_ = gittest.NewRepo(t, clientFS)
+				_ = gittest.NewRepo(t, clientFS).Commit(gittest.Commit(t, "WRITEME.md", "I'm already here!", "Wow!"))
 				cloned, err := git.CloneRepo(context.Background(), t.Logf, git.CloneRepoOptions{
-					Path:    "/",
+					Path:    "/workspace",
 					RepoURL: srv.URL,
 					Storage: clientFS,
+					RepoAuth: &githttp.BasicAuth{
+						Username: tc.username,
+						Password: tc.password,
+					},
 				})
-				require.NoError(t, err)
-				require.False(t, cloned)
+				if tc.expectError != "" {
+					assert.ErrorContains(t, err, tc.expectError)
+				}
+				assert.False(t, cloned)
+
+				// Ensure we do not overwrite the existing repo.
+				readme := mustRead(t, clientFS, "/workspace/WRITEME.md")
+				assert.Equal(t, "I'm already here!", readme)
 			})
 
 			// Basic Auth