pull.go 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526
  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() (err error) {
  62. pr.HeadRepo, err = GetRepositoryByID(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) GetBaseRepo() (err error) {
  69. if pr.BaseRepo != nil {
  70. return nil
  71. }
  72. pr.BaseRepo, err = GetRepositoryByID(pr.BaseRepoID)
  73. if err != nil {
  74. return fmt.Errorf("GetRepositoryByID (base): %v", err)
  75. }
  76. return nil
  77. }
  78. func (pr *PullRequest) GetMerger() (err error) {
  79. if !pr.HasMerged || pr.Merger != nil {
  80. return nil
  81. }
  82. pr.Merger, err = GetUserByID(pr.MergerID)
  83. if IsErrUserNotExist(err) {
  84. pr.MergerID = -1
  85. pr.Merger = NewFakeUser()
  86. } else if err != nil {
  87. return fmt.Errorf("GetUserByID: %v", err)
  88. }
  89. return nil
  90. }
  91. // IsChecking returns true if this pull request is still checking conflict.
  92. func (pr *PullRequest) IsChecking() bool {
  93. return pr.Status == PULL_REQUEST_STATUS_CHECKING
  94. }
  95. // CanAutoMerge returns true if this pull request can be merged automatically.
  96. func (pr *PullRequest) CanAutoMerge() bool {
  97. return pr.Status == PULL_REQUEST_STATUS_MERGEABLE
  98. }
  99. // Merge merges pull request to base repository.
  100. func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository) (err error) {
  101. sess := x.NewSession()
  102. defer sessionRelease(sess)
  103. if err = sess.Begin(); err != nil {
  104. return err
  105. }
  106. if err = pr.Issue.changeStatus(sess, doer, true); err != nil {
  107. return fmt.Errorf("Issue.changeStatus: %v", err)
  108. }
  109. if err = pr.GetHeadRepo(); err != nil {
  110. return fmt.Errorf("GetHeadRepo: %v", err)
  111. }
  112. headRepoPath := RepoPath(pr.HeadUserName, pr.HeadRepo.Name)
  113. headGitRepo, err := git.OpenRepository(headRepoPath)
  114. if err != nil {
  115. return fmt.Errorf("OpenRepository: %v", err)
  116. }
  117. pr.MergedCommitID, err = headGitRepo.GetCommitIdOfBranch(pr.HeadBranch)
  118. if err != nil {
  119. return fmt.Errorf("GetCommitIdOfBranch: %v", err)
  120. }
  121. if err = mergePullRequestAction(sess, doer, pr.Issue.Repo, pr.Issue); err != nil {
  122. return fmt.Errorf("mergePullRequestAction: %v", err)
  123. }
  124. pr.HasMerged = true
  125. pr.Merged = time.Now()
  126. pr.MergerID = doer.Id
  127. if _, err = sess.Id(pr.ID).AllCols().Update(pr); err != nil {
  128. return fmt.Errorf("update pull request: %v", err)
  129. }
  130. // Clone base repo.
  131. tmpBasePath := path.Join("data/tmp/repos", com.ToStr(time.Now().Nanosecond())+".git")
  132. os.MkdirAll(path.Dir(tmpBasePath), os.ModePerm)
  133. defer os.RemoveAll(path.Dir(tmpBasePath))
  134. var stderr string
  135. if _, stderr, err = process.ExecTimeout(5*time.Minute,
  136. fmt.Sprintf("PullRequest.Merge(git clone): %s", tmpBasePath),
  137. "git", "clone", baseGitRepo.Path, tmpBasePath); err != nil {
  138. return fmt.Errorf("git clone: %s", stderr)
  139. }
  140. // Check out base branch.
  141. if _, stderr, err = process.ExecDir(-1, tmpBasePath,
  142. fmt.Sprintf("PullRequest.Merge(git checkout): %s", tmpBasePath),
  143. "git", "checkout", pr.BaseBranch); err != nil {
  144. return fmt.Errorf("git checkout: %s", stderr)
  145. }
  146. // Add head repo remote.
  147. if _, stderr, err = process.ExecDir(-1, tmpBasePath,
  148. fmt.Sprintf("PullRequest.Merge(git remote add): %s", tmpBasePath),
  149. "git", "remote", "add", "head_repo", headRepoPath); err != nil {
  150. return fmt.Errorf("git remote add[%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
  151. }
  152. // Merge commits.
  153. if _, stderr, err = process.ExecDir(-1, tmpBasePath,
  154. fmt.Sprintf("PullRequest.Merge(git fetch): %s", tmpBasePath),
  155. "git", "fetch", "head_repo"); err != nil {
  156. return fmt.Errorf("git fetch[%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
  157. }
  158. if _, stderr, err = process.ExecDir(-1, tmpBasePath,
  159. fmt.Sprintf("PullRequest.Merge(git merge): %s", tmpBasePath),
  160. "git", "merge", "--no-ff", "-m",
  161. fmt.Sprintf("Merge branch '%s' of %s/%s into %s", pr.HeadBranch, pr.HeadUserName, pr.HeadRepo.Name, pr.BaseBranch),
  162. "head_repo/"+pr.HeadBranch); err != nil {
  163. return fmt.Errorf("git merge[%s]: %s", tmpBasePath, stderr)
  164. }
  165. // Push back to upstream.
  166. if _, stderr, err = process.ExecDir(-1, tmpBasePath,
  167. fmt.Sprintf("PullRequest.Merge(git push): %s", tmpBasePath),
  168. "git", "push", baseGitRepo.Path, pr.BaseBranch); err != nil {
  169. return fmt.Errorf("git push: %s", stderr)
  170. }
  171. return sess.Commit()
  172. }
  173. // patchConflicts is a list of conflit description from Git.
  174. var patchConflicts = []string{
  175. "patch does not apply",
  176. "already exists in working directory",
  177. }
  178. // testPatch checks if patch can be merged to base repository without conflit.
  179. func (pr *PullRequest) testPatch() (err error) {
  180. if pr.BaseRepo == nil {
  181. pr.BaseRepo, err = GetRepositoryByID(pr.BaseRepoID)
  182. if err != nil {
  183. return fmt.Errorf("GetRepositoryByID: %v", err)
  184. }
  185. }
  186. patchPath, err := pr.BaseRepo.PatchPath(pr.Index)
  187. if err != nil {
  188. return fmt.Errorf("BaseRepo.PatchPath: %v", err)
  189. }
  190. // Fast fail if patch does not exist, this assumes data is cruppted.
  191. if !com.IsFile(patchPath) {
  192. log.Trace("PullRequest[%d].testPatch: ignored cruppted data", pr.ID)
  193. return nil
  194. }
  195. log.Trace("PullRequest[%d].testPatch(patchPath): %s", pr.ID, patchPath)
  196. if err := pr.BaseRepo.UpdateLocalCopy(); err != nil {
  197. return fmt.Errorf("UpdateLocalCopy: %v", err)
  198. }
  199. pr.Status = PULL_REQUEST_STATUS_CHECKING
  200. _, stderr, err := process.ExecDir(-1, pr.BaseRepo.LocalCopyPath(),
  201. fmt.Sprintf("testPatch(git apply --check): %d", pr.BaseRepo.ID),
  202. "git", "apply", "--check", patchPath)
  203. if err != nil {
  204. for i := range patchConflicts {
  205. if strings.Contains(stderr, patchConflicts[i]) {
  206. log.Trace("PullRequest[%d].testPatch(apply): has conflit", pr.ID)
  207. pr.Status = PULL_REQUEST_STATUS_CONFLICT
  208. return nil
  209. }
  210. }
  211. return fmt.Errorf("git apply --check: %v - %s", err, stderr)
  212. }
  213. return nil
  214. }
  215. // NewPullRequest creates new pull request with labels for repository.
  216. func NewPullRequest(repo *Repository, pull *Issue, labelIDs []int64, uuids []string, pr *PullRequest, patch []byte) (err error) {
  217. sess := x.NewSession()
  218. defer sessionRelease(sess)
  219. if err = sess.Begin(); err != nil {
  220. return err
  221. }
  222. if err = newIssue(sess, repo, pull, labelIDs, uuids, true); err != nil {
  223. return fmt.Errorf("newIssue: %v", err)
  224. }
  225. // Notify watchers.
  226. act := &Action{
  227. ActUserID: pull.Poster.Id,
  228. ActUserName: pull.Poster.Name,
  229. ActEmail: pull.Poster.Email,
  230. OpType: CREATE_PULL_REQUEST,
  231. Content: fmt.Sprintf("%d|%s", pull.Index, pull.Name),
  232. RepoID: repo.ID,
  233. RepoUserName: repo.Owner.Name,
  234. RepoName: repo.Name,
  235. IsPrivate: repo.IsPrivate,
  236. }
  237. if err = notifyWatchers(sess, act); err != nil {
  238. return err
  239. }
  240. pr.Index = pull.Index
  241. if err = repo.SavePatch(pr.Index, patch); err != nil {
  242. return fmt.Errorf("SavePatch: %v", err)
  243. }
  244. pr.BaseRepo = repo
  245. if err = pr.testPatch(); err != nil {
  246. return fmt.Errorf("testPatch: %v", err)
  247. }
  248. if pr.Status == PULL_REQUEST_STATUS_CHECKING {
  249. pr.Status = PULL_REQUEST_STATUS_MERGEABLE
  250. }
  251. pr.IssueID = pull.ID
  252. if _, err = sess.Insert(pr); err != nil {
  253. return fmt.Errorf("insert pull repo: %v", err)
  254. }
  255. return sess.Commit()
  256. }
  257. // GetUnmergedPullRequest returnss a pull request that is open and has not been merged
  258. // by given head/base and repo/branch.
  259. func GetUnmergedPullRequest(headRepoID, baseRepoID int64, headBranch, baseBranch string) (*PullRequest, error) {
  260. pr := new(PullRequest)
  261. has, err := x.Where("head_repo_id=? AND head_branch=? AND base_repo_id=? AND base_branch=? AND has_merged=? AND issue.is_closed=?",
  262. headRepoID, headBranch, baseRepoID, baseBranch, false, false).
  263. Join("INNER", "issue", "issue.id=pull_request.issue_id").Get(pr)
  264. if err != nil {
  265. return nil, err
  266. } else if !has {
  267. return nil, ErrPullRequestNotExist{0, 0, headRepoID, baseRepoID, headBranch, baseBranch}
  268. }
  269. return pr, nil
  270. }
  271. // GetUnmergedPullRequestsByHeadInfo returnss all pull requests that are open and has not been merged
  272. // by given head information (repo and branch).
  273. func GetUnmergedPullRequestsByHeadInfo(repoID int64, branch string) ([]*PullRequest, error) {
  274. prs := make([]*PullRequest, 0, 2)
  275. return prs, x.Where("head_repo_id=? AND head_branch=? AND has_merged=? AND issue.is_closed=?",
  276. repoID, branch, false, false).
  277. Join("INNER", "issue", "issue.id=pull_request.issue_id").Find(&prs)
  278. }
  279. // GetUnmergedPullRequestsByBaseInfo returnss all pull requests that are open and has not been merged
  280. // by given base information (repo and branch).
  281. func GetUnmergedPullRequestsByBaseInfo(repoID int64, branch string) ([]*PullRequest, error) {
  282. prs := make([]*PullRequest, 0, 2)
  283. return prs, x.Where("base_repo_id=? AND base_branch=? AND has_merged=? AND issue.is_closed=?",
  284. repoID, branch, false, false).
  285. Join("INNER", "issue", "issue.id=pull_request.issue_id").Find(&prs)
  286. }
  287. // GetPullRequestByID returns a pull request by given ID.
  288. func GetPullRequestByID(id int64) (*PullRequest, error) {
  289. pr := new(PullRequest)
  290. has, err := x.Id(id).Get(pr)
  291. if err != nil {
  292. return nil, err
  293. } else if !has {
  294. return nil, ErrPullRequestNotExist{id, 0, 0, 0, "", ""}
  295. }
  296. return pr, nil
  297. }
  298. // GetPullRequestByIssueID returns pull request by given issue ID.
  299. func GetPullRequestByIssueID(issueID int64) (*PullRequest, error) {
  300. pr := &PullRequest{
  301. IssueID: issueID,
  302. }
  303. has, err := x.Get(pr)
  304. if err != nil {
  305. return nil, err
  306. } else if !has {
  307. return nil, ErrPullRequestNotExist{0, issueID, 0, 0, "", ""}
  308. }
  309. return pr, nil
  310. }
  311. // Update updates all fields of pull request.
  312. func (pr *PullRequest) Update() error {
  313. _, err := x.Id(pr.ID).AllCols().Update(pr)
  314. return err
  315. }
  316. // Update updates specific fields of pull request.
  317. func (pr *PullRequest) UpdateCols(cols ...string) error {
  318. _, err := x.Id(pr.ID).Cols(cols...).Update(pr)
  319. return err
  320. }
  321. var PullRequestQueue = NewUniqueQueue(setting.Repository.PullRequestQueueLength)
  322. // UpdatePatch generates and saves a new patch.
  323. func (pr *PullRequest) UpdatePatch() error {
  324. if err := pr.GetHeadRepo(); err != nil {
  325. return fmt.Errorf("GetHeadRepo: %v", err)
  326. } else if pr.HeadRepo == nil {
  327. log.Trace("PullRequest[%d].UpdatePatch: ignored cruppted data", pr.ID)
  328. return nil
  329. }
  330. if err := pr.GetBaseRepo(); err != nil {
  331. return fmt.Errorf("GetBaseRepo: %v", err)
  332. }
  333. headRepoPath, err := pr.HeadRepo.RepoPath()
  334. if err != nil {
  335. return fmt.Errorf("HeadRepo.RepoPath: %v", err)
  336. }
  337. headGitRepo, err := git.OpenRepository(headRepoPath)
  338. if err != nil {
  339. return fmt.Errorf("OpenRepository: %v", err)
  340. }
  341. patch, err := headGitRepo.GetPatch(pr.MergeBase, pr.HeadBranch)
  342. if err != nil {
  343. return fmt.Errorf("GetPatch: %v", err)
  344. }
  345. if err = pr.BaseRepo.SavePatch(pr.Index, patch); err != nil {
  346. return fmt.Errorf("BaseRepo.SavePatch: %v", err)
  347. }
  348. return nil
  349. }
  350. // AddToTaskQueue adds itself to pull request test task queue.
  351. func (pr *PullRequest) AddToTaskQueue() {
  352. go PullRequestQueue.AddFunc(pr.ID, func() {
  353. pr.Status = PULL_REQUEST_STATUS_CHECKING
  354. if err := pr.UpdateCols("status"); err != nil {
  355. log.Error(5, "AddToTaskQueue.UpdateCols[%d].(add to queue): %v", pr.ID, err)
  356. }
  357. })
  358. }
  359. func addHeadRepoTasks(prs []*PullRequest) {
  360. for _, pr := range prs {
  361. log.Trace("addHeadRepoTasks[%d]: composing new test task", pr.ID)
  362. if err := pr.UpdatePatch(); err != nil {
  363. log.Error(4, "UpdatePatch: %v", err)
  364. continue
  365. }
  366. pr.AddToTaskQueue()
  367. }
  368. }
  369. // AddTestPullRequestTask adds new test tasks by given head/base repository and head/base branch,
  370. // and generate new patch for testing as needed.
  371. func AddTestPullRequestTask(repoID int64, branch string) {
  372. log.Trace("AddTestPullRequestTask[head_repo_id: %d, head_branch: %s]: finding pull requests", repoID, branch)
  373. prs, err := GetUnmergedPullRequestsByHeadInfo(repoID, branch)
  374. if err != nil {
  375. log.Error(4, "Find pull requests[head_repo_id: %d, head_branch: %s]: %v", repoID, branch, err)
  376. return
  377. }
  378. addHeadRepoTasks(prs)
  379. log.Trace("AddTestPullRequestTask[base_repo_id: %d, base_branch: %s]: finding pull requests", repoID, branch)
  380. prs, err = GetUnmergedPullRequestsByBaseInfo(repoID, branch)
  381. if err != nil {
  382. log.Error(4, "Find pull requests[base_repo_id: %d, base_branch: %s]: %v", repoID, branch, err)
  383. return
  384. }
  385. for _, pr := range prs {
  386. pr.AddToTaskQueue()
  387. }
  388. }
  389. // checkAndUpdateStatus checks if pull request is possible to levaing checking status,
  390. // and set to be either conflict or mergeable.
  391. func (pr *PullRequest) checkAndUpdateStatus() {
  392. // Status is not changed to conflict means mergeable.
  393. if pr.Status == PULL_REQUEST_STATUS_CHECKING {
  394. pr.Status = PULL_REQUEST_STATUS_MERGEABLE
  395. }
  396. // Make sure there is no waiting test to process before levaing the checking status.
  397. if !PullRequestQueue.Exist(pr.ID) {
  398. if err := pr.UpdateCols("status"); err != nil {
  399. log.Error(4, "Update[%d]: %v", pr.ID, err)
  400. }
  401. }
  402. }
  403. // TestPullRequests checks and tests untested patches of pull requests.
  404. // TODO: test more pull requests at same time.
  405. func TestPullRequests() {
  406. prs := make([]*PullRequest, 0, 10)
  407. x.Iterate(PullRequest{
  408. Status: PULL_REQUEST_STATUS_CHECKING,
  409. },
  410. func(idx int, bean interface{}) error {
  411. pr := bean.(*PullRequest)
  412. if err := pr.GetBaseRepo(); err != nil {
  413. log.Error(3, "GetBaseRepo: %v", err)
  414. return nil
  415. }
  416. if err := pr.testPatch(); err != nil {
  417. log.Error(3, "testPatch: %v", err)
  418. return nil
  419. }
  420. prs = append(prs, pr)
  421. return nil
  422. })
  423. // Update pull request status.
  424. for _, pr := range prs {
  425. pr.checkAndUpdateStatus()
  426. }
  427. // Start listening on new test requests.
  428. for prID := range PullRequestQueue.Queue() {
  429. log.Trace("TestPullRequests[%v]: processing test task", prID)
  430. PullRequestQueue.Remove(prID)
  431. pr, err := GetPullRequestByID(com.StrTo(prID).MustInt64())
  432. if err != nil {
  433. log.Error(4, "GetPullRequestByID[%d]: %v", prID, err)
  434. continue
  435. } else if err = pr.testPatch(); err != nil {
  436. log.Error(4, "testPatch[%d]: %v", pr.ID, err)
  437. continue
  438. }
  439. pr.checkAndUpdateStatus()
  440. }
  441. }
  442. func InitTestPullRequests() {
  443. go TestPullRequests()
  444. }