first working version

routers/repo/pull.go

@@ -594,6 +594,75 @@ func ViewPullFiles(ctx *context.Context) {
  ctx.HTML(200, tplPullFiles)
 }
 
+// UpdatePullRequest merge master into PR
+func UpdatePullRequest(ctx *context.Context) {
+
+ issue := checkPullInfo(ctx)
+ if ctx.Written() {
+ return
+ }
+ if issue.IsClosed {
+ ctx.NotFound("MergePullRequest", nil)
+ return
+ }
+
+ if issue.PullRequest.HasMerged {
+ ctx.NotFound("MergePullRequest", nil)
+ return
+ }
+
+ if err := issue.PullRequest.LoadBaseRepo(); err != nil {
+ ctx.InternalServerError(err)
+ return
+ }
+ if err := issue.PullRequest.LoadHeadRepo(); err != nil {
+ ctx.InternalServerError(err)
+ return
+ }
+
+ headRepoPerm, err := models.GetUserRepoPermission(issue.PullRequest.HeadRepo, ctx.User)
+ if err != nil {
+ ctx.ServerError("GetUserRepoPermission", err)
+ return
+ }
+
+ allowedUpdate, err := pull_service.IsUserAllowedToUpdate(issue.PullRequest, headRepoPerm, ctx.User)
+ if err != nil {
+ ctx.ServerError("IsUserAllowedToMerge", err)
+ return
+ }
+
+ // ToDo: add check if maintainers are allowed to change branch ... (need migration & co)
+ if !allowedUpdate {
+ ctx.Flash.Error(ctx.Tr("repo.pulls.update_not_allowed"))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
+ return
+ }
+
+ // default merge commit message
+ message := fmt.Sprintf("Merge branch '%s' into %s", issue.PullRequest.BaseBranch, issue.PullRequest.HeadBranch)
+
+ if err = pull_service.Update(issue.PullRequest, ctx.User, message); err != nil {
+ sanitize := func(x string) string {
+ runes := []rune(x)
+
+ if len(runes) > 512 {
+ x = "..." + string(runes[len(runes)-512:])
+ }
+
+ return strings.Replace(html.EscapeString(x), "\n", "<br>", -1)
+ }
+ if models.IsErrMergeConflicts(err) {
+ conflictError := err.(models.ErrMergeConflicts)
+ ctx.Flash.Error(ctx.Tr("repo.pulls.merge_conflict", sanitize(conflictError.StdErr), sanitize(conflictError.StdOut)))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
+ return
+ }
+ ctx.ServerError("Update", err)
+ return
+ }
+}
+
 // MergePullRequest response for merging pull request
 func MergePullRequest(ctx *context.Context, form auth.MergePullRequestForm) {
  issue := checkPullInfo(ctx)

routers/routes/routes.go

@@ -855,6 +855,7 @@ func RegisterRoutes(m *macaron.Macaron) {
  m.Get(".patch", repo.DownloadPullPatch)
  m.Get("/commits", context.RepoRef(), repo.ViewPullCommits)
  m.Post("/merge", context.RepoMustNotBeArchived(), reqRepoPullsWriter, bindIgnErr(auth.MergePullRequestForm{}), repo.MergePullRequest)
+ m.Post("/update", repo.UpdatePullRequest)
  m.Post("/cleanup", context.RepoMustNotBeArchived(), context.RepoRef(), repo.CleanUpPullRequest)
  m.Group("/files", func() {
  m.Get("", context.RepoRef(), repo.SetEditorconfigIfExists, repo.SetDiffViewStyle, repo.SetWhitespaceBehavior, repo.ViewPullFiles)

services/pull/update.go

@@ -0,0 +1,259 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+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,
+ BaseRepoID: pull.HeadRepoID,
+ HeadBranch: pull.BaseBranch,
+ BaseBranch: pull.HeadBranch,
+ }
+
+ if err = pr.LoadHeadRepo(); err != nil {
+ log.Error("LoadHeadRepo: %v", err)
+ return fmt.Errorf("LoadHeadRepo: %v", err)
+ } else if err = pr.LoadBaseRepo(); err != nil {
+ log.Error("LoadBaseRepo: %v", err)
+ return fmt.Errorf("LoadBaseRepo: %v", err)
+ }
+
+ // Clone base repo.
+ tmpBasePath, err := createTemporaryRepo(pr)
+ if err != nil {
+ log.Error("CreateTemporaryPath: %v", err)
+ 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 ..
+
+ return nil
+}
+
+// IsUserAllowedToUpdate check if user is allowed to update PR with given permissions and branch protections
+func IsUserAllowedToUpdate(pull *models.PullRequest, p models.Permission, user *models.User) (bool, error) {
+ if p.IsAdmin() {
+ return true, nil
+ }
+ if !p.CanWrite(models.UnitTypeCode) {
+ return false, nil
+ }
+ pr := &models.PullRequest{
+ HeadRepoID: pull.BaseRepoID,
+ BaseRepoID: pull.HeadRepoID,
+ HeadBranch: pull.BaseBranch,
+ BaseBranch: pull.HeadBranch,
+ }
+ err := pr.LoadProtectedBranch()
+ if err != nil {
+ return false, err
+ }
+
+ if pr.ProtectedBranch == nil || pr.ProtectedBranch.IsUserMergeWhitelisted(user.ID) {
+ return true, nil
+ }
+
+ return false, nil
+}

web_src/js/index.js

@@ -1037,6 +1037,17 @@ function initRepository() {
  $('#comment-form').submit();
  });
 
+ // Pull Request update button
+ const $updatePRButton = $('#update-button');
+ $updatePRButton.on('click', () => {
+ $.post(`${window.location}/update`, {
+ _csrf: csrf
+ }).success(() => {
+ // eslint-disable-next-line no-restricted-globals
+ location.reload();
+ });
+ });
+
  // Pull Request merge button
  const $mergeButton = $('.merge-button > button');
  $mergeButton.on('click', function (e) {