use rawMerge (remove redundant code)

Author: 6543

services/pull/update.go

@@ -6,28 +6,13 @@ package pull
 
 import (
 	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
 
 	"code.gitea.io/gitea/models"
-	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/log"
-	"code.gitea.io/gitea/modules/setting"
-
-	"github.com/mcuadros/go-version"
 )
 
 // Update ToDo wip ...
 func Update(pull *models.PullRequest, doer *models.User, message string) (err error) {
-	binVersion, err := git.BinVersion()
-	if err != nil {
-		log.Error("git.BinVersion: %v", err)
-		return fmt.Errorf("Unable to get git version: %v", err)
-	}
-
 	//use merge functions but switch repo's and branches
 	pr := &models.PullRequest{
 		HeadRepoID: pull.BaseRepoID,
@@ -44,187 +29,9 @@ func Update(pull *models.PullRequest, doer *models.User, message string) (err er
 		return fmt.Errorf("LoadBaseRepo: %v", err)
 	}
 
-	// Clone base repo.
-	tmpBasePath, err := createTemporaryRepo(pr)
-	if err != nil {
-		log.Error("CreateTemporaryPath: %v", err)
+	if err := rawMerge(pr, doer, models.MergeStyleMerge, message); err != nil {
 		return err
 	}
-	defer func() {
-		if err := models.RemoveTemporaryPath(tmpBasePath); err != nil {
-			log.Error("Merge: RemoveTemporaryPath: %s", err)
-		}
-	}()
-
-	baseBranch := "base"
-	trackingBranch := "tracking"
-
-	var outbuf, errbuf strings.Builder
-
-	// Enable sparse-checkout
-	sparseCheckoutList, err := getDiffTree(tmpBasePath, baseBranch, trackingBranch)
-	if err != nil {
-		log.Error("getDiffTree(%s, %s, %s): %v", tmpBasePath, baseBranch, trackingBranch, err)
-		return fmt.Errorf("getDiffTree: %v", err)
-	}
-
-	infoPath := filepath.Join(tmpBasePath, ".git", "info")
-	if err := os.MkdirAll(infoPath, 0700); err != nil {
-		log.Error("Unable to create .git/info in %s: %v", tmpBasePath, err)
-		return fmt.Errorf("Unable to create .git/info in tmpBasePath: %v", err)
-	}
-
-	sparseCheckoutListPath := filepath.Join(infoPath, "sparse-checkout")
-	if err := ioutil.WriteFile(sparseCheckoutListPath, []byte(sparseCheckoutList), 0600); err != nil {
-		log.Error("Unable to write .git/info/sparse-checkout file in %s: %v", tmpBasePath, err)
-		return fmt.Errorf("Unable to write .git/info/sparse-checkout file in tmpBasePath: %v", err)
-	}
-
-	var gitConfigCommand func() *git.Command
-	if version.Compare(binVersion, "1.8.0", ">=") {
-		gitConfigCommand = func() *git.Command {
-			return git.NewCommand("config", "--local")
-		}
-	} else {
-		gitConfigCommand = func() *git.Command {
-			return git.NewCommand("config")
-		}
-	}
-
-	// Switch off LFS process (set required, clean and smudge here also)
-	if err := gitConfigCommand().AddArguments("filter.lfs.process", "").RunInDirPipeline(tmpBasePath, &outbuf, &errbuf); err != nil {
-		log.Error("git config [filter.lfs.process -> <> ]: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-		return fmt.Errorf("git config [filter.lfs.process -> <> ]: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-	}
-	outbuf.Reset()
-	errbuf.Reset()
-
-	if err := gitConfigCommand().AddArguments("filter.lfs.required", "false").RunInDirPipeline(tmpBasePath, &outbuf, &errbuf); err != nil {
-		log.Error("git config [filter.lfs.required -> <false> ]: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-		return fmt.Errorf("git config [filter.lfs.required -> <false> ]: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-	}
-	outbuf.Reset()
-	errbuf.Reset()
-
-	if err := gitConfigCommand().AddArguments("filter.lfs.clean", "").RunInDirPipeline(tmpBasePath, &outbuf, &errbuf); err != nil {
-		log.Error("git config [filter.lfs.clean -> <> ]: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-		return fmt.Errorf("git config [filter.lfs.clean -> <> ]: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-	}
-	outbuf.Reset()
-	errbuf.Reset()
-
-	if err := gitConfigCommand().AddArguments("filter.lfs.smudge", "").RunInDirPipeline(tmpBasePath, &outbuf, &errbuf); err != nil {
-		log.Error("git config [filter.lfs.smudge -> <> ]: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-		return fmt.Errorf("git config [filter.lfs.smudge -> <> ]: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-	}
-	outbuf.Reset()
-	errbuf.Reset()
-
-	if err := gitConfigCommand().AddArguments("core.sparseCheckout", "true").RunInDirPipeline(tmpBasePath, &outbuf, &errbuf); err != nil {
-		log.Error("git config [core.sparseCheckout -> true ]: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-		return fmt.Errorf("git config [core.sparsecheckout -> true]: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-	}
-	outbuf.Reset()
-	errbuf.Reset()
-
-	// Read base branch index
-	if err := git.NewCommand("read-tree", "HEAD").RunInDirPipeline(tmpBasePath, &outbuf, &errbuf); err != nil {
-		log.Error("git read-tree HEAD: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-		return fmt.Errorf("Unable to read base branch in to the index: %v\n%s\n%s", err, outbuf.String(), errbuf.String())
-	}
-	outbuf.Reset()
-	errbuf.Reset()
-
-	// Determine if we should sign
-	signArg := ""
-	if version.Compare(binVersion, "1.7.9", ">=") {
-		sign, keyID, _ := pr.SignMerge(doer, tmpBasePath, "HEAD", trackingBranch)
-		if sign {
-			signArg = "-S" + keyID
-		} else if version.Compare(binVersion, "2.0.0", ">=") {
-			signArg = "--no-gpg-sign"
-		}
-	}
-
-	sig := doer.NewGitSig()
-	commitTimeStr := time.Now().Format(time.RFC3339)
-
-	// Because this may call hooks we should pass in the environment
-	env := append(os.Environ(),
-		"GIT_AUTHOR_NAME="+sig.Name,
-		"GIT_AUTHOR_EMAIL="+sig.Email,
-		"GIT_AUTHOR_DATE="+commitTimeStr,
-		"GIT_COMMITTER_NAME="+sig.Name,
-		"GIT_COMMITTER_EMAIL="+sig.Email,
-		"GIT_COMMITTER_DATE="+commitTimeStr,
-	)
-
-	// Merge commits.
-	cmd := git.NewCommand("merge", "--no-ff", "--no-commit", trackingBranch)
-	if err := runMergeCommand(pr, models.MergeStyleMerge, cmd, tmpBasePath); err != nil {
-		log.Error("Unable to merge tracking into base: %v", err)
-		return err
-	}
-
-	if err := commitAndSignNoAuthor(pr, message, signArg, tmpBasePath, env); err != nil {
-		log.Error("Unable to make final commit: %v", err)
-		return err
-	}
-
-	// OK we should cache our current head and origin/headbranch
-	mergeHeadSHA, err := git.GetFullCommitID(tmpBasePath, "HEAD")
-	if err != nil {
-		return fmt.Errorf("Failed to get full commit id for HEAD: %v", err)
-	}
-	mergeBaseSHA, err := git.GetFullCommitID(tmpBasePath, "original_"+baseBranch)
-	if err != nil {
-		return fmt.Errorf("Failed to get full commit id for origin/%s: %v", pr.BaseBranch, err)
-	}
-
-	// Now it's questionable about where this should go - either after or before the push
-	// I think in the interests of data safety - failures to push to the lfs should prevent
-	// the merge as you can always remerge.
-	if setting.LFS.StartServer {
-		if err := LFSPush(tmpBasePath, mergeHeadSHA, mergeBaseSHA, pr); err != nil {
-			return err
-		}
-	}
-
-	var headUser *models.User
-	err = pr.HeadRepo.GetOwner()
-	if err != nil {
-		if !models.IsErrUserNotExist(err) {
-			log.Error("Can't find user: %d for head repository - %v", pr.HeadRepo.OwnerID, err)
-			return err
-		}
-		log.Error("Can't find user: %d for head repository - defaulting to doer: %s - %v", pr.HeadRepo.OwnerID, doer.Name, err)
-		headUser = doer
-	} else {
-		headUser = pr.HeadRepo.Owner
-	}
-
-	env = models.FullPushingEnvironment(
-		headUser,
-		doer,
-		pr.BaseRepo,
-		pr.BaseRepo.Name,
-		pr.ID,
-	)
-
-	// Push back to upstream.
-	if err := git.NewCommand("push", "origin", baseBranch+":"+pr.BaseBranch).RunInDirTimeoutEnvPipeline(env, -1, tmpBasePath, &outbuf, &errbuf); err != nil {
-		if strings.Contains(errbuf.String(), "non-fast-forward") {
-			return models.ErrMergePushOutOfDate{
-				Style:  models.MergeStyleMerge,
-				StdOut: outbuf.String(),
-				StdErr: errbuf.String(),
-				Err:    err,
-			}
-		}
-		return fmt.Errorf("git push: %s", errbuf.String())
-	}
-	outbuf.Reset()
-	errbuf.Reset()
 
 	//notification.NotifyPullRequestUpdated(pr, doer)
 	//trigger hooks and co ..