Merge remote-tracking branch 'origin/main' into ssh-mirroring

services/mirror/mirror_pull.go

@@ -26,13 +26,11 @@ import (
 	ssh_module "code.gitea.io/gitea/modules/ssh"
 	"code.gitea.io/gitea/modules/timeutil"
 	"code.gitea.io/gitea/modules/util"
+	"code.gitea.io/gitea/services/migrations"
 	notify_service "code.gitea.io/gitea/services/notify"
 	repo_service "code.gitea.io/gitea/services/repository"
 )
 
-// gitShortEmptySha Git short empty SHA
-const gitShortEmptySha = "0000000"
-
 // UpdateAddress writes new address to Git repository and database
 func UpdateAddress(ctx context.Context, m *repo_model.Mirror, addr string) error {
 	u, err := giturl.ParseGitURL(addr)
@@ -73,159 +71,19 @@ func UpdateAddress(ctx context.Context, m *repo_model.Mirror, addr string) error
 	return repo_model.UpdateRepositoryColsNoAutoTime(ctx, m.Repo, "original_url")
 }
 
-// mirrorSyncResult contains information of a updated reference.
-// If the oldCommitID is "0000000", it means a new reference, the value of newCommitID is empty.
-// If the newCommitID is "0000000", it means the reference is deleted, the value of oldCommitID is empty.
-type mirrorSyncResult struct {
-	refName     git.RefName
-	oldCommitID string
-	newCommitID string
-}
-
-// parseRemoteUpdateOutput detects create, update and delete operations of references from upstream.
-// possible output example:
-/*
-// * [new tag]         v0.1.8     -> v0.1.8
-// * [new branch]      master     -> origin/master
-// * [new ref]         refs/pull/2/head  -> refs/pull/2/head"
-// - [deleted]         (none)     -> origin/test // delete a branch
-// - [deleted]         (none)     -> 1 // delete a tag
-//   957a993..a87ba5f  test       -> origin/test
-// + f895a1e...957a993 test       -> origin/test  (forced update)
-*/
-// TODO: return whether it's a force update
-func parseRemoteUpdateOutput(output, remoteName string) []*mirrorSyncResult {
-	results := make([]*mirrorSyncResult, 0, 3)
-	lines := strings.Split(output, "\n")
-	for i := range lines {
-		// Make sure reference name is presented before continue
-		idx := strings.Index(lines[i], "-> ")
-		if idx == -1 {
-			continue
-		}
-
-		refName := strings.TrimSpace(lines[i][idx+3:])
-
-		switch {
-		case strings.HasPrefix(lines[i], " * [new tag]"): // new tag
-			results = append(results, &mirrorSyncResult{
-				refName:     git.RefNameFromTag(refName),
-				oldCommitID: gitShortEmptySha,
-			})
-		case strings.HasPrefix(lines[i], " * [new branch]"): // new branch
-			refName = strings.TrimPrefix(refName, remoteName+"/")
-			results = append(results, &mirrorSyncResult{
-				refName:     git.RefNameFromBranch(refName),
-				oldCommitID: gitShortEmptySha,
-			})
-		case strings.HasPrefix(lines[i], " * [new ref]"): // new reference
-			results = append(results, &mirrorSyncResult{
-				refName:     git.RefName(refName),
-				oldCommitID: gitShortEmptySha,
-			})
-		case strings.HasPrefix(lines[i], " - "): // Delete reference
-			isTag := !strings.HasPrefix(refName, remoteName+"/")
-			var refFullName git.RefName
-			if strings.HasPrefix(refName, "refs/") {
-				refFullName = git.RefName(refName)
-			} else if isTag {
-				refFullName = git.RefNameFromTag(refName)
-			} else {
-				refFullName = git.RefNameFromBranch(strings.TrimPrefix(refName, remoteName+"/"))
-			}
-			results = append(results, &mirrorSyncResult{
-				refName:     refFullName,
-				newCommitID: gitShortEmptySha,
-			})
-		case strings.HasPrefix(lines[i], " + "): // Force update
-			if idx := strings.Index(refName, " "); idx > -1 {
-				refName = refName[:idx]
-			}
-			delimIdx := strings.Index(lines[i][3:], " ")
-			if delimIdx == -1 {
-				log.Error("SHA delimiter not found: %q", lines[i])
-				continue
-			}
-			shas := strings.Split(lines[i][3:delimIdx+3], "...")
-			if len(shas) != 2 {
-				log.Error("Expect two SHAs but not what found: %q", lines[i])
-				continue
-			}
-			var refFullName git.RefName
-			if strings.HasPrefix(refName, "refs/") {
-				refFullName = git.RefName(refName)
-			} else {
-				refFullName = git.RefNameFromBranch(strings.TrimPrefix(refName, remoteName+"/"))
-			}
-
-			results = append(results, &mirrorSyncResult{
-				refName:     refFullName,
-				oldCommitID: shas[0],
-				newCommitID: shas[1],
-			})
-		case strings.HasPrefix(lines[i], "   "): // New commits of a reference
-			delimIdx := strings.Index(lines[i][3:], " ")
-			if delimIdx == -1 {
-				log.Error("SHA delimiter not found: %q", lines[i])
-				continue
-			}
-			shas := strings.Split(lines[i][3:delimIdx+3], "..")
-			if len(shas) != 2 {
-				log.Error("Expect two SHAs but not what found: %q", lines[i])
-				continue
-			}
-			var refFullName git.RefName
-			if strings.HasPrefix(refName, "refs/") {
-				refFullName = git.RefName(refName)
-			} else {
-				refFullName = git.RefNameFromBranch(strings.TrimPrefix(refName, remoteName+"/"))
-			}
-
-			results = append(results, &mirrorSyncResult{
-				refName:     refFullName,
-				oldCommitID: shas[0],
-				newCommitID: shas[1],
-			})
-
-		default:
-			log.Warn("parseRemoteUpdateOutput: unexpected update line %q", lines[i])
-		}
-	}
-	return results
-}
-
-func pruneBrokenReferences(ctx context.Context,
-	m *repo_model.Mirror,
-	timeout time.Duration,
-	stdoutBuilder, stderrBuilder *strings.Builder,
-	isWiki bool,
-) error {
-	wiki := ""
-	var storageRepo gitrepo.Repository = m.Repo
-	if isWiki {
-		wiki = "Wiki "
-		storageRepo = m.Repo.WikiStorageRepo()
-	}
-
-	stderrBuilder.Reset()
-	stdoutBuilder.Reset()
-
-	pruneErr := gitrepo.GitRemotePrune(ctx, storageRepo, m.GetRemoteName(), timeout, stdoutBuilder, stderrBuilder)
+func pruneBrokenReferences(ctx context.Context, m *repo_model.Mirror, gitRepo gitrepo.Repository, timeout time.Duration) error {
+	cmd := gitcmd.NewCommand("remote", "prune").AddDynamicArguments(m.GetRemoteName()).WithTimeout(timeout)
+	stdout, _, pruneErr := gitrepo.RunCmdString(ctx, gitRepo, cmd)
 	if pruneErr != nil {
-		stdout := stdoutBuilder.String()
-		stderr := stderrBuilder.String()
-
-		// sanitize the output, since it may contain the remote address, which may
-		// contain a password
-		stderrMessage := util.SanitizeCredentialURLs(stderr)
+		// sanitize the output, since it may contain the remote address, which may contain a password
+		stderrMessage := util.SanitizeCredentialURLs(pruneErr.Stderr())
 		stdoutMessage := util.SanitizeCredentialURLs(stdout)
 
-		log.Error("Failed to prune mirror repository %s%-v references:\nStdout: %s\nStderr: %s\nErr: %v", wiki, m.Repo, stdoutMessage, stderrMessage, pruneErr)
-		desc := fmt.Sprintf("Failed to prune mirror repository %s'%s' references: %s", wiki, storageRepo.RelativePath(), stderrMessage)
+		log.Error("Failed to prune mirror repository %s references:\nStdout: %s\nStderr: %s\nErr: %v", gitRepo.RelativePath(), stdoutMessage, stderrMessage, pruneErr)
+		desc := fmt.Sprintf("Failed to prune mirror repository (%s) references: %s", m.Repo.FullName(), stderrMessage)
 		if err := system_model.CreateRepositoryNotice(desc); err != nil {
 			log.Error("CreateRepositoryNotice: %v", err)
 		}
-		// this if will only be reached on a successful prune so try to get the mirror again
 	}
 	return pruneErr
 }
@@ -249,117 +107,84 @@ func checkRecoverableSyncError(stderrMessage string) bool {
 }
 
 // runSync returns true if sync finished without error.
-// setupSSHAuth sets up SSH authentication for git operations if needed
-func setupSSHAuth(ctx context.Context, repo *repo_model.Repository, remoteURL string, runOpts *gitcmd.RunOpts) (func(), error) {
+// setupSSHAuth sets up SSH authentication for git operations if needed.
+// It returns the SSH agent socket path, a cleanup function, and any error.
+// If the URL is not SSH or no keypair is found, it returns empty string with a no-op cleanup.
+func setupSSHAuth(ctx context.Context, repo *repo_model.Repository, remoteURL string) (string, func(), error) {
 	if !IsSSHURL(remoteURL) {
-		return func() {}, nil
+		return "", func() {}, nil
 	}
 
 	keypair, err := GetSSHKeypairForURL(ctx, repo, remoteURL)
 	if err != nil {
-		return nil, fmt.Errorf("failed to get SSH keypair: %w", err)
+		return "", nil, fmt.Errorf("failed to get SSH keypair: %w", err)
 	}
 	if keypair == nil {
-		return func() {}, nil
+		return "", func() {}, nil
 	}
 
 	privateKey, err := keypair.GetDecryptedPrivateKey()
 	if err != nil {
-		return nil, fmt.Errorf("failed to decrypt private key: %w", err)
+		return "", nil, fmt.Errorf("failed to decrypt private key: %w", err)
 	}
 
 	socketPath, cleanup, err := ssh_module.CreateTemporaryAgent(privateKey)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create SSH agent: %w", err)
+		return "", nil, fmt.Errorf("failed to create SSH agent: %w", err)
 	}
 
-	runOpts.SSHAuthSock = socketPath
-
 	log.Debug("SSH agent created for repository %s with socket: %s", repo.FullName(), socketPath)
-	return cleanup, nil
+	return socketPath, cleanup, nil
 }
 
-func runSync(ctx context.Context, m *repo_model.Mirror) ([]*mirrorSyncResult, bool) {
-	repoPath := m.Repo.RepoPath()
-	wikiPath := m.Repo.WikiPath()
-	timeout := time.Duration(setting.Git.Timeout.Mirror) * time.Second
-
+func runSync(ctx context.Context, m *repo_model.Mirror) ([]*repo_module.SyncResult, bool) {
 	log.Trace("SyncMirrors [repo: %-v]: running git remote update...", m.Repo)
 
-	// use fetch but not remote update because git fetch support --tags but remote update doesn't
-	cmd := gitcmd.NewCommand("fetch")
-	if m.EnablePrune {
-		cmd.AddArguments("--prune")
-	}
-	cmd.AddArguments("--tags").AddDynamicArguments(m.GetRemoteName())
-
 	remoteURL, remoteErr := gitrepo.GitRemoteGetURL(ctx, m.Repo, m.GetRemoteName())
 	if remoteErr != nil {
 		log.Error("SyncMirrors [repo: %-v]: GetRemoteURL Error %v", m.Repo, remoteErr)
 		return nil, false
 	}
-
 	envs := proxy.EnvWithProxy(remoteURL.URL)
+	timeout := time.Duration(setting.Git.Timeout.Mirror) * time.Second
 
-	stdoutBuilder := strings.Builder{}
-	stderrBuilder := strings.Builder{}
-
-	runOpts := &gitcmd.RunOpts{
-		Timeout: timeout,
-		Dir:     repoPath,
-		Env:     envs,
-		Stdout:  &stdoutBuilder,
-		Stderr:  &stderrBuilder,
-	}
-
-	cleanup, err := setupSSHAuth(ctx, m.Repo, remoteURL.String(), runOpts)
-	if err != nil {
-		log.Error("SyncMirrors [repo: %-v]: SSH setup error %v", m.Repo, err)
+	// Setup SSH authentication if needed
+	sshAuthSock, cleanup, sshErr := setupSSHAuth(ctx, m.Repo, remoteURL.String())
+	if sshErr != nil {
+		log.Error("SyncMirrors [repo: %-v]: SSH setup error %v", m.Repo, sshErr)
 		return nil, false
 	}
 	defer cleanup()
 
-	if err := cmd.Run(ctx, runOpts); err != nil {
-		stdout := stdoutBuilder.String()
-		stderr := stderrBuilder.String()
+	// use fetch but not remote update because git fetch support --tags but remote update doesn't
+	cmdFetch := func() *gitcmd.Command {
+		cmd := gitcmd.NewCommand("fetch", "--tags")
+		if m.EnablePrune {
+			cmd.AddArguments("--prune")
+		}
+		return cmd.AddDynamicArguments(m.GetRemoteName()).WithTimeout(timeout).WithEnv(envs).WithSSHAuthSock(sshAuthSock)
+	}
 
+	var err error
+	fetchStdout, fetchStderr, err := gitrepo.RunCmdString(ctx, m.Repo, cmdFetch())
+	if err != nil {
 		// sanitize the output, since it may contain the remote address, which may contain a password
-		stderrMessage := util.SanitizeCredentialURLs(stderr)
-		stdoutMessage := util.SanitizeCredentialURLs(stdout)
+		stderrMessage := util.SanitizeCredentialURLs(fetchStderr)
+		stdoutMessage := util.SanitizeCredentialURLs(fetchStdout)
 
 		// Now check if the error is a resolve reference due to broken reference
-		if checkRecoverableSyncError(stderr) {
+		if checkRecoverableSyncError(fetchStderr) {
 			log.Warn("SyncMirrors [repo: %-v]: failed to update mirror repository due to broken references:\nStdout: %s\nStderr: %s\nErr: %v\nAttempting Prune", m.Repo, stdoutMessage, stderrMessage, err)
 			err = nil
-
 			// Attempt prune
-			pruneErr := pruneBrokenReferences(ctx, m, timeout, &stdoutBuilder, &stderrBuilder, false)
+			pruneErr := pruneBrokenReferences(ctx, m, m.Repo, timeout)
 			if pruneErr == nil {
 				// Successful prune - reattempt mirror
-				stderrBuilder.Reset()
-				stdoutBuilder.Reset()
-				retryRunOpts := &gitcmd.RunOpts{
-					Timeout: timeout,
-					Dir:     repoPath,
-					Stdout:  &stdoutBuilder,
-					Stderr:  &stderrBuilder,
-				}
-
-				retryCleanup, sshErr := setupSSHAuth(ctx, m.Repo, remoteURL.String(), retryRunOpts)
-				if sshErr != nil {
-					log.Error("SyncMirrors [repo: %-v]: SSH setup error on retry %v", m.Repo, sshErr)
-					return nil, false
-				}
-				defer retryCleanup()
-
-				if err = cmd.Run(ctx, retryRunOpts); err != nil {
-					stdout := stdoutBuilder.String()
-					stderr := stderrBuilder.String()
-
-					// sanitize the output, since it may contain the remote address, which may
-					// contain a password
-					stderrMessage = util.SanitizeCredentialURLs(stderr)
-					stdoutMessage = util.SanitizeCredentialURLs(stdout)
+				fetchStdout, fetchStderr, err = gitrepo.RunCmdString(ctx, m.Repo, cmdFetch())
+				if err != nil {
+					// sanitize the output, since it may contain the remote address, which may contain a password
+					stderrMessage = util.SanitizeCredentialURLs(fetchStderr)
+					stdoutMessage = util.SanitizeCredentialURLs(fetchStdout)
 				}
 			}
 		}
@@ -367,16 +192,14 @@ func runSync(ctx context.Context, m *repo_model.Mirror) ([]*mirrorSyncResult, bo
 		// If there is still an error (or there always was an error)
 		if err != nil {
 			log.Error("SyncMirrors [repo: %-v]: failed to update mirror repository:\nStdout: %s\nStderr: %s\nErr: %v", m.Repo, stdoutMessage, stderrMessage, err)
-			desc := fmt.Sprintf("Failed to update mirror repository '%s': %s", repoPath, stderrMessage)
-			if err = system_model.CreateRepositoryNotice(desc); err != nil {
+			desc := fmt.Sprintf("Failed to update mirror repository (%s): %s", m.Repo.FullName(), stderrMessage)
+			if err := system_model.CreateRepositoryNotice(desc); err != nil {
 				log.Error("CreateRepositoryNotice: %v", err)
 			}
 			return nil, false
 		}
 	}
-	output := stderrBuilder.String()
-
-	if err := git.WriteCommitGraph(ctx, repoPath); err != nil {
+	if err := gitrepo.WriteCommitGraph(ctx, m.Repo); err != nil {
 		log.Error("SyncMirrors [repo: %-v]: %v", m.Repo, err)
 	}
 
@@ -389,21 +212,24 @@ func runSync(ctx context.Context, m *repo_model.Mirror) ([]*mirrorSyncResult, bo
 	if m.LFS && setting.LFS.StartServer {
 		log.Trace("SyncMirrors [repo: %-v]: syncing LFS objects...", m.Repo)
 		endpoint := lfs.DetermineEndpoint(remoteURL.String(), m.LFSEndpoint)
-		lfsClient := lfs.NewClient(endpoint, nil)
+		lfsClient := lfs.NewClient(endpoint, migrations.NewMigrationHTTPTransport())
 		if err = repo_module.StoreMissingLfsObjectsInRepository(ctx, m.Repo, gitRepo, lfsClient); err != nil {
 			log.Error("SyncMirrors [repo: %-v]: failed to synchronize LFS objects for repository: %v", m.Repo.FullName(), err)
 		}
 	}
 
 	log.Trace("SyncMirrors [repo: %-v]: syncing branches...", m.Repo)
-	if _, err = repo_module.SyncRepoBranchesWithRepo(ctx, m.Repo, gitRepo, 0); err != nil {
+	_, results, err := repo_module.SyncRepoBranchesWithRepo(ctx, m.Repo, gitRepo, 0)
+	if err != nil {
 		log.Error("SyncMirrors [repo: %-v]: failed to synchronize branches: %v", m.Repo, err)
 	}
 
 	log.Trace("SyncMirrors [repo: %-v]: syncing releases with tags...", m.Repo)
-	if err = repo_module.SyncReleasesWithTags(ctx, m.Repo, gitRepo); err != nil {
+	tagResults, err := repo_module.SyncReleasesWithTags(ctx, m.Repo, gitRepo)
+	if err != nil {
 		log.Error("SyncMirrors [repo: %-v]: failed to synchronize tags to releases: %v", m.Repo, err)
 	}
+	results = append(results, tagResults...)
 	gitRepo.Close()
 
 	log.Trace("SyncMirrors [repo: %-v]: updating size of repository", m.Repo)
@@ -411,16 +237,16 @@ func runSync(ctx context.Context, m *repo_model.Mirror) ([]*mirrorSyncResult, bo
 		log.Error("SyncMirrors [repo: %-v]: failed to update size for mirror repository: %v", m.Repo.FullName(), err)
 	}
 
+	cmdRemoteUpdatePrune := func() *gitcmd.Command {
+		return gitcmd.NewCommand("remote", "update", "--prune").
+			AddDynamicArguments(m.GetRemoteName()).WithTimeout(timeout).WithEnv(envs).WithSSHAuthSock(sshAuthSock)
+	}
+
 	if repo_service.HasWiki(ctx, m.Repo) {
 		log.Trace("SyncMirrors [repo: %-v Wiki]: running git remote update...", m.Repo)
-		stderrBuilder.Reset()
-		stdoutBuilder.Reset()
-
-		if err := gitrepo.GitRemoteUpdatePrune(ctx, m.Repo.WikiStorageRepo(), m.GetRemoteName(),
-			timeout, &stdoutBuilder, &stderrBuilder); err != nil {
-			stdout := stdoutBuilder.String()
-			stderr := stderrBuilder.String()
-
+		// the result of "git remote update" is in stderr
+		stdout, stderr, err := gitrepo.RunCmdString(ctx, m.Repo.WikiStorageRepo(), cmdRemoteUpdatePrune())
+		if err != nil {
 			// sanitize the output, since it may contain the remote address, which may contain a password
 			stderrMessage := util.SanitizeCredentialURLs(stderr)
 			stdoutMessage := util.SanitizeCredentialURLs(stdout)
@@ -431,16 +257,11 @@ func runSync(ctx context.Context, m *repo_model.Mirror) ([]*mirrorSyncResult, bo
 				err = nil
 
 				// Attempt prune
-				pruneErr := pruneBrokenReferences(ctx, m, timeout, &stdoutBuilder, &stderrBuilder, true)
+				pruneErr := pruneBrokenReferences(ctx, m, m.Repo.WikiStorageRepo(), timeout)
 				if pruneErr == nil {
 					// Successful prune - reattempt mirror
-					stderrBuilder.Reset()
-					stdoutBuilder.Reset()
-
-					if err = gitrepo.GitRemoteUpdatePrune(ctx, m.Repo.WikiStorageRepo(), m.GetRemoteName(),
-						timeout, &stdoutBuilder, &stderrBuilder); err != nil {
-						stdout := stdoutBuilder.String()
-						stderr := stderrBuilder.String()
+					stdout, stderr, err = gitrepo.RunCmdString(ctx, m.Repo.WikiStorageRepo(), cmdRemoteUpdatePrune())
+					if err != nil {
 						stderrMessage = util.SanitizeCredentialURLs(stderr)
 						stdoutMessage = util.SanitizeCredentialURLs(stdout)
 					}
@@ -450,14 +271,14 @@ func runSync(ctx context.Context, m *repo_model.Mirror) ([]*mirrorSyncResult, bo
 			// If there is still an error (or there always was an error)
 			if err != nil {
 				log.Error("SyncMirrors [repo: %-v Wiki]: failed to update mirror repository wiki:\nStdout: %s\nStderr: %s\nErr: %v", m.Repo, stdoutMessage, stderrMessage, err)
-				desc := fmt.Sprintf("Failed to update mirror repository wiki '%s': %s", wikiPath, stderrMessage)
-				if err = system_model.CreateRepositoryNotice(desc); err != nil {
+				desc := fmt.Sprintf("Failed to update mirror repository wiki (%s): %s", m.Repo.FullName(), stderrMessage)
+				if err := system_model.CreateRepositoryNotice(desc); err != nil {
 					log.Error("CreateRepositoryNotice: %v", err)
 				}
 				return nil, false
 			}
 
-			if err := git.WriteCommitGraph(ctx, wikiPath); err != nil {
+			if err := gitrepo.WriteCommitGraph(ctx, m.Repo.WikiStorageRepo()); err != nil {
 				log.Error("SyncMirrors [repo: %-v]: %v", m.Repo, err)
 			}
 		}
@@ -476,7 +297,7 @@ func runSync(ctx context.Context, m *repo_model.Mirror) ([]*mirrorSyncResult, bo
 	}
 
 	m.UpdatedUnix = timeutil.TimeStampNow()
-	return parseRemoteUpdateOutput(output, m.GetRemoteName()), true
+	return results, true
 }
 
 func getRepoPullMirrorLockKey(repoID int64) string {
@@ -507,7 +328,7 @@ func SyncPullMirror(ctx context.Context, repoID int64) bool {
 		log.Error("SyncMirrors [repo_id: %v]: unable to GetMirrorByRepoID: %v", repoID, err)
 		return false
 	}
-	_ = m.GetRepository(ctx) // force load repository of mirror
+	repo := m.GetRepository(ctx) // force load repository of mirror
 
 	ctx, _, finished := process.GetManager().AddContext(ctx, fmt.Sprintf("Syncing Mirror %s/%s", m.Repo.OwnerName, m.Repo.Name))
 	defer finished()
@@ -545,42 +366,42 @@ func SyncPullMirror(ctx context.Context, repoID int64) bool {
 
 	for _, result := range results {
 		// Discard GitHub pull requests, i.e. refs/pull/*
-		if result.refName.IsPull() {
+		if result.RefName.IsPull() {
 			continue
 		}
 
 		// Create reference
-		if result.oldCommitID == gitShortEmptySha {
-			commitID, err := gitRepo.GetRefCommitID(result.refName.String())
+		if result.OldCommitID == "" {
+			commitID, err := gitRepo.GetRefCommitID(result.RefName.String())
 			if err != nil {
-				log.Error("SyncMirrors [repo: %-v]: unable to GetRefCommitID [ref_name: %s]: %v", m.Repo, result.refName, err)
+				log.Error("SyncMirrors [repo: %-v]: unable to GetRefCommitID [ref_name: %s]: %v", m.Repo, result.RefName, err)
 				continue
 			}
 			objectFormat := git.ObjectFormatFromName(m.Repo.ObjectFormatName)
 			notify_service.SyncPushCommits(ctx, m.Repo.MustOwner(ctx), m.Repo, &repo_module.PushUpdateOptions{
-				RefFullName: result.refName,
+				RefFullName: result.RefName,
 				OldCommitID: objectFormat.EmptyObjectID().String(),
 				NewCommitID: commitID,
 			}, repo_module.NewPushCommits())
-			notify_service.SyncCreateRef(ctx, m.Repo.MustOwner(ctx), m.Repo, result.refName, commitID)
+			notify_service.SyncCreateRef(ctx, m.Repo.MustOwner(ctx), m.Repo, result.RefName, commitID)
 			continue
 		}
 
 		// Delete reference
-		if result.newCommitID == gitShortEmptySha {
-			notify_service.SyncDeleteRef(ctx, m.Repo.MustOwner(ctx), m.Repo, result.refName)
+		if result.NewCommitID == "" {
+			notify_service.SyncDeleteRef(ctx, m.Repo.MustOwner(ctx), m.Repo, result.RefName)
 			continue
 		}
 
 		// Push commits
-		oldCommitID, err := git.GetFullCommitID(gitRepo.Ctx, gitRepo.Path, result.oldCommitID)
+		oldCommitID, err := gitrepo.GetFullCommitID(ctx, repo, result.OldCommitID)
 		if err != nil {
-			log.Error("SyncMirrors [repo: %-v]: unable to get GetFullCommitID[%s]: %v", m.Repo, result.oldCommitID, err)
+			log.Error("SyncMirrors [repo: %-v]: unable to get GetFullCommitID[%s]: %v", m.Repo, result.OldCommitID, err)
 			continue
 		}
-		newCommitID, err := git.GetFullCommitID(gitRepo.Ctx, gitRepo.Path, result.newCommitID)
+		newCommitID, err := gitrepo.GetFullCommitID(ctx, repo, result.NewCommitID)
 		if err != nil {
-			log.Error("SyncMirrors [repo: %-v]: unable to get GetFullCommitID [%s]: %v", m.Repo, result.newCommitID, err)
+			log.Error("SyncMirrors [repo: %-v]: unable to get GetFullCommitID [%s]: %v", m.Repo, result.NewCommitID, err)
 			continue
 		}
 		commits, err := gitRepo.CommitsBetweenIDs(newCommitID, oldCommitID)
@@ -604,7 +425,7 @@ func SyncPullMirror(ctx context.Context, repoID int64) bool {
 		theCommits.CompareURL = m.Repo.ComposeCompareURL(oldCommitID, newCommitID)
 
 		notify_service.SyncPushCommits(ctx, m.Repo.MustOwner(ctx), m.Repo, &repo_module.PushUpdateOptions{
-			RefFullName: result.refName,
+			RefFullName: result.RefName,
 			OldCommitID: oldCommitID,
 			NewCommitID: newCommitID,
 		}, theCommits)
@@ -618,7 +439,7 @@ func SyncPullMirror(ctx context.Context, repoID int64) bool {
 	}
 	if !isEmpty {
 		// Get latest commit date and update to current repository updated time
-		commitDate, err := git.GetLatestCommitTime(ctx, m.Repo.RepoPath())
+		commitDate, err := gitrepo.GetLatestCommitTime(ctx, m.Repo)
 		if err != nil {
 			log.Error("SyncMirrors [repo: %-v]: unable to GetLatestCommitDate: %v", m.Repo, err)
 			return false
@@ -643,7 +464,7 @@ func SyncPullMirror(ctx context.Context, repoID int64) bool {
 	return true
 }
 
-func checkAndUpdateEmptyRepository(ctx context.Context, m *repo_model.Mirror, results []*mirrorSyncResult) bool {
+func checkAndUpdateEmptyRepository(ctx context.Context, m *repo_model.Mirror, results []*repo_module.SyncResult) bool {
 	if !m.Repo.IsEmpty {
 		return true
 	}
@@ -657,11 +478,11 @@ func checkAndUpdateEmptyRepository(ctx context.Context, m *repo_model.Mirror, re
 	}
 	firstName := ""
 	for _, result := range results {
-		if !result.refName.IsBranch() {
+		if !result.RefName.IsBranch() {
 			continue
 		}
 
-		name := result.refName.BranchName()
+		name := result.RefName.BranchName()
 		if len(firstName) == 0 {
 			firstName = name
 		}
@@ -690,7 +511,7 @@ func checkAndUpdateEmptyRepository(ctx context.Context, m *repo_model.Mirror, re
 		// Update the is empty and default_branch columns
 		if err := repo_model.UpdateRepositoryColsWithAutoTime(ctx, m.Repo, "default_branch", "is_empty"); err != nil {
 			log.Error("Failed to update default branch of repository %-v. Error: %v", m.Repo, err)
-			desc := fmt.Sprintf("Failed to update default branch of repository '%s': %v", m.Repo.RepoPath(), err)
+			desc := fmt.Sprintf("Failed to update default branch of repository (%s): %v", m.Repo.FullName(), err)
 			if err = system_model.CreateRepositoryNotice(desc); err != nil {
 				log.Error("CreateRepositoryNotice: %v", err)
 			}

services/mirror/mirror_pull_test.go

@@ -9,62 +9,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func Test_parseRemoteUpdateOutput(t *testing.T) {
-	output := `
- * [new tag]         v0.1.8     -> v0.1.8
- * [new branch]      master     -> origin/master
- - [deleted]         (none)     -> origin/test1
- - [deleted]         (none)     -> tag1
- + f895a1e...957a993 test2      -> origin/test2  (forced update)
-   957a993..a87ba5f  test3      -> origin/test3
- * [new ref]               refs/pull/26595/head  -> refs/pull/26595/head
- * [new ref]               refs/pull/26595/merge -> refs/pull/26595/merge
-   e0639e38fb..6db2410489  refs/pull/25873/head  -> refs/pull/25873/head
- + 1c97ebc746...976d27d52f refs/pull/25873/merge -> refs/pull/25873/merge  (forced update)
-`
-	results := parseRemoteUpdateOutput(output, "origin")
-	assert.Len(t, results, 10)
-	assert.Equal(t, "refs/tags/v0.1.8", results[0].refName.String())
-	assert.Equal(t, gitShortEmptySha, results[0].oldCommitID)
-	assert.Empty(t, results[0].newCommitID)
-
-	assert.Equal(t, "refs/heads/master", results[1].refName.String())
-	assert.Equal(t, gitShortEmptySha, results[1].oldCommitID)
-	assert.Empty(t, results[1].newCommitID)
-
-	assert.Equal(t, "refs/heads/test1", results[2].refName.String())
-	assert.Empty(t, results[2].oldCommitID)
-	assert.Equal(t, gitShortEmptySha, results[2].newCommitID)
-
-	assert.Equal(t, "refs/tags/tag1", results[3].refName.String())
-	assert.Empty(t, results[3].oldCommitID)
-	assert.Equal(t, gitShortEmptySha, results[3].newCommitID)
-
-	assert.Equal(t, "refs/heads/test2", results[4].refName.String())
-	assert.Equal(t, "f895a1e", results[4].oldCommitID)
-	assert.Equal(t, "957a993", results[4].newCommitID)
-
-	assert.Equal(t, "refs/heads/test3", results[5].refName.String())
-	assert.Equal(t, "957a993", results[5].oldCommitID)
-	assert.Equal(t, "a87ba5f", results[5].newCommitID)
-
-	assert.Equal(t, "refs/pull/26595/head", results[6].refName.String())
-	assert.Equal(t, gitShortEmptySha, results[6].oldCommitID)
-	assert.Empty(t, results[6].newCommitID)
-
-	assert.Equal(t, "refs/pull/26595/merge", results[7].refName.String())
-	assert.Equal(t, gitShortEmptySha, results[7].oldCommitID)
-	assert.Empty(t, results[7].newCommitID)
-
-	assert.Equal(t, "refs/pull/25873/head", results[8].refName.String())
-	assert.Equal(t, "e0639e38fb", results[8].oldCommitID)
-	assert.Equal(t, "6db2410489", results[8].newCommitID)
-
-	assert.Equal(t, "refs/pull/25873/merge", results[9].refName.String())
-	assert.Equal(t, "1c97ebc746", results[9].oldCommitID)
-	assert.Equal(t, "976d27d52f", results[9].newCommitID)
-}
-
 func Test_checkRecoverableSyncError(t *testing.T) {
 	cases := []struct {
 		recoverable bool

services/mirror/mirror_push.go

@@ -24,6 +24,7 @@ import (
 	ssh_module "code.gitea.io/gitea/modules/ssh"
 	"code.gitea.io/gitea/modules/timeutil"
 	"code.gitea.io/gitea/modules/util"
+	"code.gitea.io/gitea/services/migrations"
 	repo_service "code.gitea.io/gitea/services/repository"
 )
 
@@ -128,14 +129,12 @@ func runPushSync(ctx context.Context, m *repo_model.PushMirror) error {
 
 	performPush := func(repo *repo_model.Repository, isWiki bool) error {
 		var storageRepo gitrepo.Repository = repo
-		path := repo.RepoPath()
 		if isWiki {
 			storageRepo = repo.WikiStorageRepo()
-			path = repo.WikiPath()
 		}
 		remoteURL, err := gitrepo.GitRemoteGetURL(ctx, storageRepo, m.RemoteName)
 		if err != nil {
-			log.Error("GetRemoteURL(%s) Error %v", path, err)
+			log.Error("GetRemoteURL(%s) Error %v", storageRepo.RelativePath(), err)
 			return errors.New("Unexpected error")
 		}
 
@@ -150,13 +149,13 @@ func runPushSync(ctx context.Context, m *repo_model.PushMirror) error {
 			defer gitRepo.Close()
 
 			endpoint := lfs.DetermineEndpoint(remoteURL.String(), "")
-			lfsClient := lfs.NewClient(endpoint, nil)
+			lfsClient := lfs.NewClient(endpoint, migrations.NewMigrationHTTPTransport())
 			if err := pushAllLFSObjects(ctx, gitRepo, lfsClient); err != nil {
 				return util.SanitizeErrorCredentialURLs(err)
 			}
 		}
 
-		log.Trace("Pushing %s mirror[%d] remote %s", path, m.ID, m.RemoteName)
+		log.Trace("Pushing %s mirror[%d] remote %s", storageRepo.RelativePath(), m.ID, m.RemoteName)
 
 		envs := proxy.EnvWithProxy(remoteURL.URL)
 
@@ -200,8 +199,8 @@ func runPushSync(ctx context.Context, m *repo_model.PushMirror) error {
 			}
 		}
 
-		if err := git.Push(ctx, path, pushOpts); err != nil {
-			log.Error("Error pushing %s mirror[%d] remote %s: %v", path, m.ID, m.RemoteName, err)
+		if err := gitrepo.PushToExternal(ctx, storageRepo, pushOpts); err != nil {
+			log.Error("Error pushing %s mirror[%d] remote %s: %v", storageRepo.RelativePath(), m.ID, m.RemoteName, err)
 
 			return util.SanitizeErrorCredentialURLs(err)
 		}
@@ -233,7 +232,9 @@ func pushAllLFSObjects(ctx context.Context, gitRepo *git.Repository, lfsClient l
 
 	pointerChan := make(chan lfs.PointerBlob)
 	errChan := make(chan error, 1)
-	go lfs.SearchPointerBlobs(ctx, gitRepo, pointerChan, errChan)
+	go func() {
+		errChan <- lfs.SearchPointerBlobs(ctx, gitRepo, pointerChan)
+	}()
 
 	uploadObjects := func(pointers []lfs.Pointer) error {
 		err := lfsClient.Upload(ctx, pointers, func(p lfs.Pointer, objectError error) (io.ReadCloser, error) {
@@ -283,13 +284,12 @@ func pushAllLFSObjects(ctx context.Context, gitRepo *git.Repository, lfsClient l
 		}
 	}
 
-	err, has := <-errChan
-	if has {
+	err := <-errChan
+	if err != nil {
 		log.Error("Error enumerating LFS objects for repository: %v", err)
-		return err
 	}
 
-	return nil
+	return err
 }
 
 func syncPushMirrorWithSyncOnCommit(ctx context.Context, repoID int64) {