pull.go 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558
  1. // Copyright 2015 The Gogs Authors. All rights reserved.
  2. // Use of this source code is governed by a MIT-style
  3. // license that can be found in the LICENSE file.
  4. package models
  5. import (
  6. "fmt"
  7. "os"
  8. "path"
  9. "strings"
  10. "time"
  11. "github.com/Unknwon/com"
  12. "github.com/go-xorm/xorm"
  13. "github.com/gogits/gogs/modules/git"
  14. "github.com/gogits/gogs/modules/log"
  15. "github.com/gogits/gogs/modules/process"
  16. "github.com/gogits/gogs/modules/setting"
  17. )
  18. type PullRequestType int
  19. const (
  20. PULL_REQUEST_GOGS PullRequestType = iota
  21. PLLL_ERQUEST_GIT
  22. )
  23. type PullRequestStatus int
  24. const (
  25. PULL_REQUEST_STATUS_CONFLICT PullRequestStatus = iota
  26. PULL_REQUEST_STATUS_CHECKING
  27. PULL_REQUEST_STATUS_MERGEABLE
  28. )
  29. // PullRequest represents relation between pull request and repositories.
  30. type PullRequest struct {
  31. ID int64 `xorm:"pk autoincr"`
  32. Type PullRequestType
  33. Status PullRequestStatus
  34. IssueID int64 `xorm:"INDEX"`
  35. Issue *Issue `xorm:"-"`
  36. Index int64
  37. HeadRepoID int64
  38. HeadRepo *Repository `xorm:"-"`
  39. BaseRepoID int64
  40. BaseRepo *Repository `xorm:"-"`
  41. HeadUserName string
  42. HeadBranch string
  43. BaseBranch string
  44. MergeBase string `xorm:"VARCHAR(40)"`
  45. HasMerged bool
  46. MergedCommitID string `xorm:"VARCHAR(40)"`
  47. Merged time.Time
  48. MergerID int64
  49. Merger *User `xorm:"-"`
  50. }
  51. // Note: don't try to get Pull because will end up recursive querying.
  52. func (pr *PullRequest) AfterSet(colName string, _ xorm.Cell) {
  53. switch colName {
  54. case "merged":
  55. if !pr.HasMerged {
  56. return
  57. }
  58. pr.Merged = regulateTimeZone(pr.Merged)
  59. }
  60. }
  61. func (pr *PullRequest) getHeadRepo(e Engine) (err error) {
  62. pr.HeadRepo, err = getRepositoryByID(e, pr.HeadRepoID)
  63. if err != nil && !IsErrRepoNotExist(err) {
  64. return fmt.Errorf("getRepositoryByID(head): %v", err)
  65. }
  66. return nil
  67. }
  68. func (pr *PullRequest) GetHeadRepo() (err error) {
  69. return pr.getHeadRepo(x)
  70. }
  71. func (pr *PullRequest) GetBaseRepo() (err error) {
  72. if pr.BaseRepo != nil {
  73. return nil
  74. }
  75. pr.BaseRepo, err = GetRepositoryByID(pr.BaseRepoID)
  76. if err != nil {
  77. return fmt.Errorf("GetRepositoryByID(base): %v", err)
  78. }
  79. return nil
  80. }
  81. func (pr *PullRequest) GetMerger() (err error) {
  82. if !pr.HasMerged || pr.Merger != nil {
  83. return nil
  84. }
  85. pr.Merger, err = GetUserByID(pr.MergerID)
  86. if IsErrUserNotExist(err) {
  87. pr.MergerID = -1
  88. pr.Merger = NewFakeUser()
  89. } else if err != nil {
  90. return fmt.Errorf("GetUserByID: %v", err)
  91. }
  92. return nil
  93. }
  94. // IsChecking returns true if this pull request is still checking conflict.
  95. func (pr *PullRequest) IsChecking() bool {
  96. return pr.Status == PULL_REQUEST_STATUS_CHECKING
  97. }
  98. // CanAutoMerge returns true if this pull request can be merged automatically.
  99. func (pr *PullRequest) CanAutoMerge() bool {
  100. return pr.Status == PULL_REQUEST_STATUS_MERGEABLE
  101. }
  102. // Merge merges pull request to base repository.
  103. func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository) (err error) {
  104. sess := x.NewSession()
  105. defer sessionRelease(sess)
  106. if err = sess.Begin(); err != nil {
  107. return err
  108. }
  109. if err = pr.Issue.changeStatus(sess, doer, true); err != nil {
  110. return fmt.Errorf("Issue.changeStatus: %v", err)
  111. }
  112. if err = pr.getHeadRepo(sess); err != nil {
  113. return fmt.Errorf("getHeadRepo: %v", err)
  114. }
  115. headRepoPath := RepoPath(pr.HeadUserName, pr.HeadRepo.Name)
  116. headGitRepo, err := git.OpenRepository(headRepoPath)
  117. if err != nil {
  118. return fmt.Errorf("OpenRepository: %v", err)
  119. }
  120. pr.MergedCommitID, err = headGitRepo.GetCommitIdOfBranch(pr.HeadBranch)
  121. if err != nil {
  122. return fmt.Errorf("GetCommitIdOfBranch: %v", err)
  123. }
  124. if err = mergePullRequestAction(sess, doer, pr.Issue.Repo, pr.Issue); err != nil {
  125. return fmt.Errorf("mergePullRequestAction: %v", err)
  126. }
  127. pr.HasMerged = true
  128. pr.Merged = time.Now()
  129. pr.MergerID = doer.Id
  130. if _, err = sess.Id(pr.ID).AllCols().Update(pr); err != nil {
  131. return fmt.Errorf("update pull request: %v", err)
  132. }
  133. // Clone base repo.
  134. tmpBasePath := path.Join(setting.AppDataPath, "tmp/repos", com.ToStr(time.Now().Nanosecond())+".git")
  135. os.MkdirAll(path.Dir(tmpBasePath), os.ModePerm)
  136. defer os.RemoveAll(path.Dir(tmpBasePath))
  137. var stderr string
  138. if _, stderr, err = process.ExecTimeout(5*time.Minute,
  139. fmt.Sprintf("PullRequest.Merge(git clone): %s", tmpBasePath),
  140. "git", "clone", baseGitRepo.Path, tmpBasePath); err != nil {
  141. return fmt.Errorf("git clone: %s", stderr)
  142. }
  143. // Check out base branch.
  144. if _, stderr, err = process.ExecDir(-1, tmpBasePath,
  145. fmt.Sprintf("PullRequest.Merge(git checkout): %s", tmpBasePath),
  146. "git", "checkout", pr.BaseBranch); err != nil {
  147. return fmt.Errorf("git checkout: %s", stderr)
  148. }
  149. // Add head repo remote.
  150. if _, stderr, err = process.ExecDir(-1, tmpBasePath,
  151. fmt.Sprintf("PullRequest.Merge(git remote add): %s", tmpBasePath),
  152. "git", "remote", "add", "head_repo", headRepoPath); err != nil {
  153. return fmt.Errorf("git remote add[%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
  154. }
  155. // Merge commits.
  156. if _, stderr, err = process.ExecDir(-1, tmpBasePath,
  157. fmt.Sprintf("PullRequest.Merge(git fetch): %s", tmpBasePath),
  158. "git", "fetch", "head_repo"); err != nil {
  159. return fmt.Errorf("git fetch[%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
  160. }
  161. if _, stderr, err = process.ExecDir(-1, tmpBasePath,
  162. fmt.Sprintf("PullRequest.Merge(git merge): %s", tmpBasePath),
  163. "git", "merge", "--no-ff", "-m",
  164. fmt.Sprintf("Merge branch '%s' of %s/%s into %s", pr.HeadBranch, pr.HeadUserName, pr.HeadRepo.Name, pr.BaseBranch),
  165. "head_repo/"+pr.HeadBranch); err != nil {
  166. return fmt.Errorf("git merge[%s]: %s", tmpBasePath, stderr)
  167. }
  168. // Push back to upstream.
  169. if _, stderr, err = process.ExecDir(-1, tmpBasePath,
  170. fmt.Sprintf("PullRequest.Merge(git push): %s", tmpBasePath),
  171. "git", "push", baseGitRepo.Path, pr.BaseBranch); err != nil {
  172. return fmt.Errorf("git push: %s", stderr)
  173. }
  174. return sess.Commit()
  175. }
  176. // patchConflicts is a list of conflit description from Git.
  177. var patchConflicts = []string{
  178. "patch does not apply",
  179. "already exists in working directory",
  180. "unrecognized input",
  181. }
  182. // testPatch checks if patch can be merged to base repository without conflit.
  183. // FIXME: make a mechanism to clean up stable local copies.
  184. func (pr *PullRequest) testPatch() (err error) {
  185. if pr.BaseRepo == nil {
  186. pr.BaseRepo, err = GetRepositoryByID(pr.BaseRepoID)
  187. if err != nil {
  188. return fmt.Errorf("GetRepositoryByID: %v", err)
  189. }
  190. }
  191. patchPath, err := pr.BaseRepo.PatchPath(pr.Index)
  192. if err != nil {
  193. return fmt.Errorf("BaseRepo.PatchPath: %v", err)
  194. }
  195. // Fast fail if patch does not exist, this assumes data is cruppted.
  196. if !com.IsFile(patchPath) {
  197. log.Trace("PullRequest[%d].testPatch: ignored cruppted data", pr.ID)
  198. return nil
  199. }
  200. log.Trace("PullRequest[%d].testPatch(patchPath): %s", pr.ID, patchPath)
  201. if err := pr.BaseRepo.UpdateLocalCopy(); err != nil {
  202. return fmt.Errorf("UpdateLocalCopy: %v", err)
  203. }
  204. // Checkout base branch.
  205. _, stderr, err := process.ExecDir(-1, pr.BaseRepo.LocalCopyPath(),
  206. fmt.Sprintf("PullRequest.Merge(git checkout): %s", pr.BaseRepo.ID),
  207. "git", "checkout", pr.BaseBranch)
  208. if err != nil {
  209. return fmt.Errorf("git checkout: %s", stderr)
  210. }
  211. pr.Status = PULL_REQUEST_STATUS_CHECKING
  212. _, stderr, err = process.ExecDir(-1, pr.BaseRepo.LocalCopyPath(),
  213. fmt.Sprintf("testPatch(git apply --check): %d", pr.BaseRepo.ID),
  214. "git", "apply", "--check", patchPath)
  215. if err != nil {
  216. for i := range patchConflicts {
  217. if strings.Contains(stderr, patchConflicts[i]) {
  218. log.Trace("PullRequest[%d].testPatch(apply): has conflit", pr.ID)
  219. fmt.Println(stderr)
  220. pr.Status = PULL_REQUEST_STATUS_CONFLICT
  221. return nil
  222. }
  223. }
  224. return fmt.Errorf("git apply --check: %v - %s", err, stderr)
  225. }
  226. return nil
  227. }
  228. // NewPullRequest creates new pull request with labels for repository.
  229. func NewPullRequest(repo *Repository, pull *Issue, labelIDs []int64, uuids []string, pr *PullRequest, patch []byte) (err error) {
  230. sess := x.NewSession()
  231. defer sessionRelease(sess)
  232. if err = sess.Begin(); err != nil {
  233. return err
  234. }
  235. if err = newIssue(sess, repo, pull, labelIDs, uuids, true); err != nil {
  236. return fmt.Errorf("newIssue: %v", err)
  237. }
  238. // Notify watchers.
  239. act := &Action{
  240. ActUserID: pull.Poster.Id,
  241. ActUserName: pull.Poster.Name,
  242. ActEmail: pull.Poster.Email,
  243. OpType: CREATE_PULL_REQUEST,
  244. Content: fmt.Sprintf("%d|%s", pull.Index, pull.Name),
  245. RepoID: repo.ID,
  246. RepoUserName: repo.Owner.Name,
  247. RepoName: repo.Name,
  248. IsPrivate: repo.IsPrivate,
  249. }
  250. if err = notifyWatchers(sess, act); err != nil {
  251. return err
  252. }
  253. pr.Index = pull.Index
  254. if err = repo.SavePatch(pr.Index, patch); err != nil {
  255. return fmt.Errorf("SavePatch: %v", err)
  256. }
  257. pr.BaseRepo = repo
  258. if err = pr.testPatch(); err != nil {
  259. return fmt.Errorf("testPatch: %v", err)
  260. }
  261. if pr.Status == PULL_REQUEST_STATUS_CHECKING {
  262. pr.Status = PULL_REQUEST_STATUS_MERGEABLE
  263. }
  264. pr.IssueID = pull.ID
  265. if _, err = sess.Insert(pr); err != nil {
  266. return fmt.Errorf("insert pull repo: %v", err)
  267. }
  268. return sess.Commit()
  269. }
  270. // GetUnmergedPullRequest returnss a pull request that is open and has not been merged
  271. // by given head/base and repo/branch.
  272. func GetUnmergedPullRequest(headRepoID, baseRepoID int64, headBranch, baseBranch string) (*PullRequest, error) {
  273. pr := new(PullRequest)
  274. has, err := x.Where("head_repo_id=? AND head_branch=? AND base_repo_id=? AND base_branch=? AND has_merged=? AND issue.is_closed=?",
  275. headRepoID, headBranch, baseRepoID, baseBranch, false, false).
  276. Join("INNER", "issue", "issue.id=pull_request.issue_id").Get(pr)
  277. if err != nil {
  278. return nil, err
  279. } else if !has {
  280. return nil, ErrPullRequestNotExist{0, 0, headRepoID, baseRepoID, headBranch, baseBranch}
  281. }
  282. return pr, nil
  283. }
  284. // GetUnmergedPullRequestsByHeadInfo returnss all pull requests that are open and has not been merged
  285. // by given head information (repo and branch).
  286. func GetUnmergedPullRequestsByHeadInfo(repoID int64, branch string) ([]*PullRequest, error) {
  287. prs := make([]*PullRequest, 0, 2)
  288. return prs, x.Where("head_repo_id=? AND head_branch=? AND has_merged=? AND issue.is_closed=?",
  289. repoID, branch, false, false).
  290. Join("INNER", "issue", "issue.id=pull_request.issue_id").Find(&prs)
  291. }
  292. // GetUnmergedPullRequestsByBaseInfo returnss all pull requests that are open and has not been merged
  293. // by given base information (repo and branch).
  294. func GetUnmergedPullRequestsByBaseInfo(repoID int64, branch string) ([]*PullRequest, error) {
  295. prs := make([]*PullRequest, 0, 2)
  296. return prs, x.Where("base_repo_id=? AND base_branch=? AND has_merged=? AND issue.is_closed=?",
  297. repoID, branch, false, false).
  298. Join("INNER", "issue", "issue.id=pull_request.issue_id").Find(&prs)
  299. }
  300. // GetPullRequestByID returns a pull request by given ID.
  301. func GetPullRequestByID(id int64) (*PullRequest, error) {
  302. pr := new(PullRequest)
  303. has, err := x.Id(id).Get(pr)
  304. if err != nil {
  305. return nil, err
  306. } else if !has {
  307. return nil, ErrPullRequestNotExist{id, 0, 0, 0, "", ""}
  308. }
  309. return pr, nil
  310. }
  311. // GetPullRequestByIssueID returns pull request by given issue ID.
  312. func GetPullRequestByIssueID(issueID int64) (*PullRequest, error) {
  313. pr := &PullRequest{
  314. IssueID: issueID,
  315. }
  316. has, err := x.Get(pr)
  317. if err != nil {
  318. return nil, err
  319. } else if !has {
  320. return nil, ErrPullRequestNotExist{0, issueID, 0, 0, "", ""}
  321. }
  322. return pr, nil
  323. }
  324. // Update updates all fields of pull request.
  325. func (pr *PullRequest) Update() error {
  326. _, err := x.Id(pr.ID).AllCols().Update(pr)
  327. return err
  328. }
  329. // Update updates specific fields of pull request.
  330. func (pr *PullRequest) UpdateCols(cols ...string) error {
  331. _, err := x.Id(pr.ID).Cols(cols...).Update(pr)
  332. return err
  333. }
  334. var PullRequestQueue = NewUniqueQueue(setting.Repository.PullRequestQueueLength)
  335. // UpdatePatch generates and saves a new patch.
  336. func (pr *PullRequest) UpdatePatch() (err error) {
  337. if err = pr.GetHeadRepo(); err != nil {
  338. return fmt.Errorf("GetHeadRepo: %v", err)
  339. } else if pr.HeadRepo == nil {
  340. log.Trace("PullRequest[%d].UpdatePatch: ignored cruppted data", pr.ID)
  341. return nil
  342. }
  343. if err = pr.GetBaseRepo(); err != nil {
  344. return fmt.Errorf("GetBaseRepo: %v", err)
  345. } else if err = pr.BaseRepo.GetOwner(); err != nil {
  346. return fmt.Errorf("GetOwner: %v", err)
  347. }
  348. headRepoPath, err := pr.HeadRepo.RepoPath()
  349. if err != nil {
  350. return fmt.Errorf("HeadRepo.RepoPath: %v", err)
  351. }
  352. headGitRepo, err := git.OpenRepository(headRepoPath)
  353. if err != nil {
  354. return fmt.Errorf("OpenRepository: %v", err)
  355. }
  356. // Add a temporary remote.
  357. tmpRemote := com.ToStr(time.Now().UnixNano())
  358. if err = headGitRepo.AddRemote(tmpRemote, RepoPath(pr.BaseRepo.Owner.Name, pr.BaseRepo.Name)); err != nil {
  359. return fmt.Errorf("AddRemote: %v", err)
  360. }
  361. defer func() {
  362. headGitRepo.RemoveRemote(tmpRemote)
  363. }()
  364. remoteBranch := "remotes/" + tmpRemote + "/" + pr.BaseBranch
  365. pr.MergeBase, err = headGitRepo.GetMergeBase(remoteBranch, pr.HeadBranch)
  366. if err != nil {
  367. return fmt.Errorf("GetMergeBase: %v", err)
  368. } else if err = pr.Update(); err != nil {
  369. return fmt.Errorf("Update: %v", err)
  370. }
  371. patch, err := headGitRepo.GetPatch(pr.MergeBase, pr.HeadBranch)
  372. if err != nil {
  373. return fmt.Errorf("GetPatch: %v", err)
  374. }
  375. if err = pr.BaseRepo.SavePatch(pr.Index, patch); err != nil {
  376. return fmt.Errorf("BaseRepo.SavePatch: %v", err)
  377. }
  378. return nil
  379. }
  380. // AddToTaskQueue adds itself to pull request test task queue.
  381. func (pr *PullRequest) AddToTaskQueue() {
  382. go PullRequestQueue.AddFunc(pr.ID, func() {
  383. pr.Status = PULL_REQUEST_STATUS_CHECKING
  384. if err := pr.UpdateCols("status"); err != nil {
  385. log.Error(5, "AddToTaskQueue.UpdateCols[%d].(add to queue): %v", pr.ID, err)
  386. }
  387. })
  388. }
  389. func addHeadRepoTasks(prs []*PullRequest) {
  390. for _, pr := range prs {
  391. log.Trace("addHeadRepoTasks[%d]: composing new test task", pr.ID)
  392. if err := pr.UpdatePatch(); err != nil {
  393. log.Error(4, "UpdatePatch: %v", err)
  394. continue
  395. }
  396. pr.AddToTaskQueue()
  397. }
  398. }
  399. // AddTestPullRequestTask adds new test tasks by given head/base repository and head/base branch,
  400. // and generate new patch for testing as needed.
  401. func AddTestPullRequestTask(repoID int64, branch string) {
  402. log.Trace("AddTestPullRequestTask[head_repo_id: %d, head_branch: %s]: finding pull requests", repoID, branch)
  403. prs, err := GetUnmergedPullRequestsByHeadInfo(repoID, branch)
  404. if err != nil {
  405. log.Error(4, "Find pull requests[head_repo_id: %d, head_branch: %s]: %v", repoID, branch, err)
  406. return
  407. }
  408. addHeadRepoTasks(prs)
  409. log.Trace("AddTestPullRequestTask[base_repo_id: %d, base_branch: %s]: finding pull requests", repoID, branch)
  410. prs, err = GetUnmergedPullRequestsByBaseInfo(repoID, branch)
  411. if err != nil {
  412. log.Error(4, "Find pull requests[base_repo_id: %d, base_branch: %s]: %v", repoID, branch, err)
  413. return
  414. }
  415. for _, pr := range prs {
  416. pr.AddToTaskQueue()
  417. }
  418. }
  419. // checkAndUpdateStatus checks if pull request is possible to levaing checking status,
  420. // and set to be either conflict or mergeable.
  421. func (pr *PullRequest) checkAndUpdateStatus() {
  422. // Status is not changed to conflict means mergeable.
  423. if pr.Status == PULL_REQUEST_STATUS_CHECKING {
  424. pr.Status = PULL_REQUEST_STATUS_MERGEABLE
  425. }
  426. // Make sure there is no waiting test to process before levaing the checking status.
  427. if !PullRequestQueue.Exist(pr.ID) {
  428. if err := pr.UpdateCols("status"); err != nil {
  429. log.Error(4, "Update[%d]: %v", pr.ID, err)
  430. }
  431. }
  432. }
  433. // TestPullRequests checks and tests untested patches of pull requests.
  434. // TODO: test more pull requests at same time.
  435. func TestPullRequests() {
  436. prs := make([]*PullRequest, 0, 10)
  437. x.Iterate(PullRequest{
  438. Status: PULL_REQUEST_STATUS_CHECKING,
  439. },
  440. func(idx int, bean interface{}) error {
  441. pr := bean.(*PullRequest)
  442. if err := pr.GetBaseRepo(); err != nil {
  443. log.Error(3, "GetBaseRepo: %v", err)
  444. return nil
  445. }
  446. if err := pr.testPatch(); err != nil {
  447. log.Error(3, "testPatch: %v", err)
  448. return nil
  449. }
  450. prs = append(prs, pr)
  451. return nil
  452. })
  453. // Update pull request status.
  454. for _, pr := range prs {
  455. pr.checkAndUpdateStatus()
  456. }
  457. // Start listening on new test requests.
  458. for prID := range PullRequestQueue.Queue() {
  459. log.Trace("TestPullRequests[%v]: processing test task", prID)
  460. PullRequestQueue.Remove(prID)
  461. pr, err := GetPullRequestByID(com.StrTo(prID).MustInt64())
  462. if err != nil {
  463. log.Error(4, "GetPullRequestByID[%d]: %v", prID, err)
  464. continue
  465. } else if err = pr.testPatch(); err != nil {
  466. log.Error(4, "testPatch[%d]: %v", pr.ID, err)
  467. continue
  468. }
  469. pr.checkAndUpdateStatus()
  470. }
  471. }
  472. func InitTestPullRequests() {
  473. go TestPullRequests()
  474. }