this repo has no description
tangled.org
1package pulls
2
3import (
4 "context"
5 "database/sql"
6 "encoding/json"
7 "errors"
8 "fmt"
9 "log"
10 "log/slog"
11 "net/http"
12 "slices"
13 "sort"
14 "strconv"
15 "strings"
16 "time"
17
18 "tangled.org/core/api/tangled"
19 "tangled.org/core/appview/config"
20 "tangled.org/core/appview/db"
21 pulls_indexer "tangled.org/core/appview/indexer/pulls"
22 "tangled.org/core/appview/mentions"
23 "tangled.org/core/appview/models"
24 "tangled.org/core/appview/notify"
25 "tangled.org/core/appview/oauth"
26 "tangled.org/core/appview/pages"
27 "tangled.org/core/appview/pages/markup"
28 "tangled.org/core/appview/pages/repoinfo"
29 "tangled.org/core/appview/reporesolver"
30 "tangled.org/core/appview/validator"
31 "tangled.org/core/appview/xrpcclient"
32 "tangled.org/core/idresolver"
33 "tangled.org/core/orm"
34 "tangled.org/core/patchutil"
35 "tangled.org/core/rbac"
36 "tangled.org/core/tid"
37 "tangled.org/core/types"
38
39 comatproto "github.com/bluesky-social/indigo/api/atproto"
40 "github.com/bluesky-social/indigo/atproto/syntax"
41 lexutil "github.com/bluesky-social/indigo/lex/util"
42 indigoxrpc "github.com/bluesky-social/indigo/xrpc"
43 "github.com/go-chi/chi/v5"
44 "github.com/google/uuid"
45)
46
47type Pulls struct {
48 oauth *oauth.OAuth
49 repoResolver *reporesolver.RepoResolver
50 pages *pages.Pages
51 idResolver *idresolver.Resolver
52 mentionsResolver *mentions.Resolver
53 db *db.DB
54 config *config.Config
55 notifier notify.Notifier
56 enforcer *rbac.Enforcer
57 logger *slog.Logger
58 validator *validator.Validator
59 indexer *pulls_indexer.Indexer
60}
61
62func New(
63 oauth *oauth.OAuth,
64 repoResolver *reporesolver.RepoResolver,
65 pages *pages.Pages,
66 resolver *idresolver.Resolver,
67 mentionsResolver *mentions.Resolver,
68 db *db.DB,
69 config *config.Config,
70 notifier notify.Notifier,
71 enforcer *rbac.Enforcer,
72 validator *validator.Validator,
73 indexer *pulls_indexer.Indexer,
74 logger *slog.Logger,
75) *Pulls {
76 return &Pulls{
77 oauth: oauth,
78 repoResolver: repoResolver,
79 pages: pages,
80 idResolver: resolver,
81 mentionsResolver: mentionsResolver,
82 db: db,
83 config: config,
84 notifier: notifier,
85 enforcer: enforcer,
86 logger: logger,
87 validator: validator,
88 indexer: indexer,
89 }
90}
91
92// htmx fragment
93func (s *Pulls) PullActions(w http.ResponseWriter, r *http.Request) {
94 switch r.Method {
95 case http.MethodGet:
96 user := s.oauth.GetUser(r)
97 f, err := s.repoResolver.Resolve(r)
98 if err != nil {
99 log.Println("failed to get repo and knot", err)
100 return
101 }
102
103 pull, ok := r.Context().Value("pull").(*models.Pull)
104 if !ok {
105 log.Println("failed to get pull")
106 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
107 return
108 }
109
110 // can be nil if this pull is not stacked
111 stack, _ := r.Context().Value("stack").(models.Stack)
112
113 roundNumberStr := chi.URLParam(r, "round")
114 roundNumber, err := strconv.Atoi(roundNumberStr)
115 if err != nil {
116 roundNumber = pull.LastRoundNumber()
117 }
118 if roundNumber >= len(pull.Submissions) {
119 http.Error(w, "bad round id", http.StatusBadRequest)
120 log.Println("failed to parse round id", err)
121 return
122 }
123
124 mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
125 branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
126 resubmitResult := pages.Unknown
127 if user.Did == pull.OwnerDid {
128 resubmitResult = s.resubmitCheck(r, f, pull, stack)
129 }
130
131 s.pages.PullActionsFragment(w, pages.PullActionsParams{
132 LoggedInUser: user,
133 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
134 Pull: pull,
135 RoundNumber: roundNumber,
136 MergeCheck: mergeCheckResponse,
137 ResubmitCheck: resubmitResult,
138 BranchDeleteStatus: branchDeleteStatus,
139 Stack: stack,
140 })
141 return
142 }
143}
144
145func (s *Pulls) RepoSinglePull(w http.ResponseWriter, r *http.Request) {
146 user := s.oauth.GetUser(r)
147 f, err := s.repoResolver.Resolve(r)
148 if err != nil {
149 log.Println("failed to get repo and knot", err)
150 return
151 }
152
153 pull, ok := r.Context().Value("pull").(*models.Pull)
154 if !ok {
155 log.Println("failed to get pull")
156 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
157 return
158 }
159
160 backlinks, err := db.GetBacklinks(s.db, pull.AtUri())
161 if err != nil {
162 log.Println("failed to get pull backlinks", err)
163 s.pages.Notice(w, "pull-error", "Failed to get pull. Try again later.")
164 return
165 }
166
167 // can be nil if this pull is not stacked
168 stack, _ := r.Context().Value("stack").(models.Stack)
169 abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull)
170
171 mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
172 branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
173 resubmitResult := pages.Unknown
174 if user != nil && user.Did == pull.OwnerDid {
175 resubmitResult = s.resubmitCheck(r, f, pull, stack)
176 }
177
178 m := make(map[string]models.Pipeline)
179
180 var shas []string
181 for _, s := range pull.Submissions {
182 shas = append(shas, s.SourceRev)
183 }
184 for _, p := range stack {
185 shas = append(shas, p.LatestSha())
186 }
187 for _, p := range abandonedPulls {
188 shas = append(shas, p.LatestSha())
189 }
190
191 ps, err := db.GetPipelineStatuses(
192 s.db,
193 len(shas),
194 orm.FilterEq("repo_owner", f.Did),
195 orm.FilterEq("repo_name", f.Name),
196 orm.FilterEq("knot", f.Knot),
197 orm.FilterIn("sha", shas),
198 )
199 if err != nil {
200 log.Printf("failed to fetch pipeline statuses: %s", err)
201 // non-fatal
202 }
203
204 for _, p := range ps {
205 m[p.Sha] = p
206 }
207
208 reactionMap, err := db.GetReactionMap(s.db, 20, pull.AtUri())
209 if err != nil {
210 log.Println("failed to get pull reactions")
211 s.pages.Notice(w, "pulls", "Failed to load pull. Try again later.")
212 }
213
214 userReactions := map[models.ReactionKind]bool{}
215 if user != nil {
216 userReactions = db.GetReactionStatusMap(s.db, user.Did, pull.AtUri())
217 }
218
219 labelDefs, err := db.GetLabelDefinitions(
220 s.db,
221 orm.FilterIn("at_uri", f.Labels),
222 orm.FilterContains("scope", tangled.RepoPullNSID),
223 )
224 if err != nil {
225 log.Println("failed to fetch labels", err)
226 s.pages.Error503(w)
227 return
228 }
229
230 defs := make(map[string]*models.LabelDefinition)
231 for _, l := range labelDefs {
232 defs[l.AtUri().String()] = &l
233 }
234
235 s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{
236 LoggedInUser: user,
237 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
238 Pull: pull,
239 Stack: stack,
240 AbandonedPulls: abandonedPulls,
241 Backlinks: backlinks,
242 BranchDeleteStatus: branchDeleteStatus,
243 MergeCheck: mergeCheckResponse,
244 ResubmitCheck: resubmitResult,
245 Pipelines: m,
246
247 OrderedReactionKinds: models.OrderedReactionKinds,
248 Reactions: reactionMap,
249 UserReacted: userReactions,
250
251 LabelDefs: defs,
252 })
253}
254
255func (s *Pulls) mergeCheck(r *http.Request, f *models.Repo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse {
256 if pull.State == models.PullMerged {
257 return types.MergeCheckResponse{}
258 }
259
260 scheme := "https"
261 if s.config.Core.Dev {
262 scheme = "http"
263 }
264 host := fmt.Sprintf("%s://%s", scheme, f.Knot)
265
266 xrpcc := indigoxrpc.Client{
267 Host: host,
268 }
269
270 patch := pull.LatestPatch()
271 if pull.IsStacked() {
272 // combine patches of substack
273 subStack := stack.Below(pull)
274 // collect the portion of the stack that is mergeable
275 mergeable := subStack.Mergeable()
276 // combine each patch
277 patch = mergeable.CombinedPatch()
278 }
279
280 resp, xe := tangled.RepoMergeCheck(
281 r.Context(),
282 &xrpcc,
283 &tangled.RepoMergeCheck_Input{
284 Did: f.Did,
285 Name: f.Name,
286 Branch: pull.TargetBranch,
287 Patch: patch,
288 },
289 )
290 if err := xrpcclient.HandleXrpcErr(xe); err != nil {
291 log.Println("failed to check for mergeability", "err", err)
292 return types.MergeCheckResponse{
293 Error: fmt.Sprintf("failed to check merge status: %s", err.Error()),
294 }
295 }
296
297 // convert xrpc response to internal types
298 conflicts := make([]types.ConflictInfo, len(resp.Conflicts))
299 for i, conflict := range resp.Conflicts {
300 conflicts[i] = types.ConflictInfo{
301 Filename: conflict.Filename,
302 Reason: conflict.Reason,
303 }
304 }
305
306 result := types.MergeCheckResponse{
307 IsConflicted: resp.Is_conflicted,
308 Conflicts: conflicts,
309 }
310
311 if resp.Message != nil {
312 result.Message = *resp.Message
313 }
314
315 if resp.Error != nil {
316 result.Error = *resp.Error
317 }
318
319 return result
320}
321
322func (s *Pulls) branchDeleteStatus(r *http.Request, repo *models.Repo, pull *models.Pull) *models.BranchDeleteStatus {
323 if pull.State != models.PullMerged {
324 return nil
325 }
326
327 user := s.oauth.GetUser(r)
328 if user == nil {
329 return nil
330 }
331
332 var branch string
333 // check if the branch exists
334 // NOTE: appview could cache branches/tags etc. for every repo by listening for gitRefUpdates
335 if pull.IsBranchBased() {
336 branch = pull.PullSource.Branch
337 } else if pull.IsForkBased() {
338 branch = pull.PullSource.Branch
339 repo = pull.PullSource.Repo
340 } else {
341 return nil
342 }
343
344 // deleted fork
345 if repo == nil {
346 return nil
347 }
348
349 // user can only delete branch if they are a collaborator in the repo that the branch belongs to
350 perms := s.enforcer.GetPermissionsInRepo(user.Did, repo.Knot, repo.DidSlashRepo())
351 if !slices.Contains(perms, "repo:push") {
352 return nil
353 }
354
355 scheme := "http"
356 if !s.config.Core.Dev {
357 scheme = "https"
358 }
359 host := fmt.Sprintf("%s://%s", scheme, repo.Knot)
360 xrpcc := &indigoxrpc.Client{
361 Host: host,
362 }
363
364 resp, err := tangled.RepoBranch(r.Context(), xrpcc, branch, fmt.Sprintf("%s/%s", repo.Did, repo.Name))
365 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
366 return nil
367 }
368
369 return &models.BranchDeleteStatus{
370 Repo: repo,
371 Branch: resp.Name,
372 }
373}
374
375func (s *Pulls) resubmitCheck(r *http.Request, repo *models.Repo, pull *models.Pull, stack models.Stack) pages.ResubmitResult {
376 if pull.State == models.PullMerged || pull.State == models.PullDeleted || pull.PullSource == nil {
377 return pages.Unknown
378 }
379
380 var knot, ownerDid, repoName string
381
382 if pull.PullSource.RepoAt != nil {
383 // fork-based pulls
384 sourceRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())
385 if err != nil {
386 log.Println("failed to get source repo", err)
387 return pages.Unknown
388 }
389
390 knot = sourceRepo.Knot
391 ownerDid = sourceRepo.Did
392 repoName = sourceRepo.Name
393 } else {
394 // pulls within the same repo
395 knot = repo.Knot
396 ownerDid = repo.Did
397 repoName = repo.Name
398 }
399
400 scheme := "http"
401 if !s.config.Core.Dev {
402 scheme = "https"
403 }
404 host := fmt.Sprintf("%s://%s", scheme, knot)
405 xrpcc := &indigoxrpc.Client{
406 Host: host,
407 }
408
409 didSlashName := fmt.Sprintf("%s/%s", ownerDid, repoName)
410 branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, didSlashName)
411 if err != nil {
412 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
413 log.Println("failed to call XRPC repo.branches", xrpcerr)
414 return pages.Unknown
415 }
416 log.Println("failed to reach knotserver", err)
417 return pages.Unknown
418 }
419
420 targetBranch := branchResp
421
422 latestSourceRev := pull.LatestSha()
423
424 if pull.IsStacked() && stack != nil {
425 top := stack[0]
426 latestSourceRev = top.LatestSha()
427 }
428
429 if latestSourceRev != targetBranch.Hash {
430 return pages.ShouldResubmit
431 }
432
433 return pages.ShouldNotResubmit
434}
435
436func (s *Pulls) RepoPullPatch(w http.ResponseWriter, r *http.Request) {
437 user := s.oauth.GetUser(r)
438
439 var diffOpts types.DiffOpts
440 if d := r.URL.Query().Get("diff"); d == "split" {
441 diffOpts.Split = true
442 }
443
444 pull, ok := r.Context().Value("pull").(*models.Pull)
445 if !ok {
446 log.Println("failed to get pull")
447 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
448 return
449 }
450
451 stack, _ := r.Context().Value("stack").(models.Stack)
452
453 roundId := chi.URLParam(r, "round")
454 roundIdInt, err := strconv.Atoi(roundId)
455 if err != nil || roundIdInt >= len(pull.Submissions) {
456 http.Error(w, "bad round id", http.StatusBadRequest)
457 log.Println("failed to parse round id", err)
458 return
459 }
460
461 patch := pull.Submissions[roundIdInt].CombinedPatch()
462 diff := patchutil.AsNiceDiff(patch, pull.TargetBranch)
463
464 s.pages.RepoPullPatchPage(w, pages.RepoPullPatchParams{
465 LoggedInUser: user,
466 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
467 Pull: pull,
468 Stack: stack,
469 Round: roundIdInt,
470 Submission: pull.Submissions[roundIdInt],
471 Diff: &diff,
472 DiffOpts: diffOpts,
473 })
474
475}
476
477func (s *Pulls) RepoPullInterdiff(w http.ResponseWriter, r *http.Request) {
478 user := s.oauth.GetUser(r)
479
480 var diffOpts types.DiffOpts
481 if d := r.URL.Query().Get("diff"); d == "split" {
482 diffOpts.Split = true
483 }
484
485 pull, ok := r.Context().Value("pull").(*models.Pull)
486 if !ok {
487 log.Println("failed to get pull")
488 s.pages.Notice(w, "pull-error", "Failed to get pull.")
489 return
490 }
491
492 roundId := chi.URLParam(r, "round")
493 roundIdInt, err := strconv.Atoi(roundId)
494 if err != nil || roundIdInt >= len(pull.Submissions) {
495 http.Error(w, "bad round id", http.StatusBadRequest)
496 log.Println("failed to parse round id", err)
497 return
498 }
499
500 if roundIdInt == 0 {
501 http.Error(w, "bad round id", http.StatusBadRequest)
502 log.Println("cannot interdiff initial submission")
503 return
504 }
505
506 currentPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt].CombinedPatch())
507 if err != nil {
508 log.Println("failed to interdiff; current patch malformed")
509 s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; current patch is invalid.")
510 return
511 }
512
513 previousPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt-1].CombinedPatch())
514 if err != nil {
515 log.Println("failed to interdiff; previous patch malformed")
516 s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; previous patch is invalid.")
517 return
518 }
519
520 interdiff := patchutil.Interdiff(previousPatch, currentPatch)
521
522 s.pages.RepoPullInterdiffPage(w, pages.RepoPullInterdiffParams{
523 LoggedInUser: s.oauth.GetUser(r),
524 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
525 Pull: pull,
526 Round: roundIdInt,
527 Interdiff: interdiff,
528 DiffOpts: diffOpts,
529 })
530}
531
532func (s *Pulls) RepoPullPatchRaw(w http.ResponseWriter, r *http.Request) {
533 pull, ok := r.Context().Value("pull").(*models.Pull)
534 if !ok {
535 log.Println("failed to get pull")
536 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
537 return
538 }
539
540 roundId := chi.URLParam(r, "round")
541 roundIdInt, err := strconv.Atoi(roundId)
542 if err != nil || roundIdInt >= len(pull.Submissions) {
543 http.Error(w, "bad round id", http.StatusBadRequest)
544 log.Println("failed to parse round id", err)
545 return
546 }
547
548 w.Header().Set("Content-Type", "text/plain; charset=utf-8")
549 w.Write([]byte(pull.Submissions[roundIdInt].Patch))
550}
551
552func (s *Pulls) RepoPulls(w http.ResponseWriter, r *http.Request) {
553 l := s.logger.With("handler", "RepoPulls")
554
555 user := s.oauth.GetUser(r)
556 params := r.URL.Query()
557
558 state := models.PullOpen
559 switch params.Get("state") {
560 case "closed":
561 state = models.PullClosed
562 case "merged":
563 state = models.PullMerged
564 }
565
566 f, err := s.repoResolver.Resolve(r)
567 if err != nil {
568 log.Println("failed to get repo and knot", err)
569 return
570 }
571
572 keyword := params.Get("q")
573
574 var ids []int64
575 searchOpts := models.PullSearchOptions{
576 Keyword: keyword,
577 RepoAt: f.RepoAt().String(),
578 State: state,
579 // Page: page,
580 }
581 l.Debug("searching with", "searchOpts", searchOpts)
582 if keyword != "" {
583 res, err := s.indexer.Search(r.Context(), searchOpts)
584 if err != nil {
585 l.Error("failed to search for pulls", "err", err)
586 return
587 }
588 ids = res.Hits
589 l.Debug("searched pulls with indexer", "count", len(ids))
590 } else {
591 ids, err = db.GetPullIDs(s.db, searchOpts)
592 if err != nil {
593 l.Error("failed to get all pull ids", "err", err)
594 return
595 }
596 l.Debug("indexed all pulls from the db", "count", len(ids))
597 }
598
599 pulls, err := db.GetPulls(
600 s.db,
601 orm.FilterIn("id", ids),
602 )
603 if err != nil {
604 log.Println("failed to get pulls", err)
605 s.pages.Notice(w, "pulls", "Failed to load pulls. Try again later.")
606 return
607 }
608
609 for _, p := range pulls {
610 var pullSourceRepo *models.Repo
611 if p.PullSource != nil {
612 if p.PullSource.RepoAt != nil {
613 pullSourceRepo, err = db.GetRepoByAtUri(s.db, p.PullSource.RepoAt.String())
614 if err != nil {
615 log.Printf("failed to get repo by at uri: %v", err)
616 continue
617 } else {
618 p.PullSource.Repo = pullSourceRepo
619 }
620 }
621 }
622 }
623
624 // we want to group all stacked PRs into just one list
625 stacks := make(map[string]models.Stack)
626 var shas []string
627 n := 0
628 for _, p := range pulls {
629 // store the sha for later
630 shas = append(shas, p.LatestSha())
631 // this PR is stacked
632 if p.StackId != "" {
633 // we have already seen this PR stack
634 if _, seen := stacks[p.StackId]; seen {
635 stacks[p.StackId] = append(stacks[p.StackId], p)
636 // skip this PR
637 } else {
638 stacks[p.StackId] = nil
639 pulls[n] = p
640 n++
641 }
642 } else {
643 pulls[n] = p
644 n++
645 }
646 }
647 pulls = pulls[:n]
648
649 ps, err := db.GetPipelineStatuses(
650 s.db,
651 len(shas),
652 orm.FilterEq("repo_owner", f.Did),
653 orm.FilterEq("repo_name", f.Name),
654 orm.FilterEq("knot", f.Knot),
655 orm.FilterIn("sha", shas),
656 )
657 if err != nil {
658 log.Printf("failed to fetch pipeline statuses: %s", err)
659 // non-fatal
660 }
661 m := make(map[string]models.Pipeline)
662 for _, p := range ps {
663 m[p.Sha] = p
664 }
665
666 labelDefs, err := db.GetLabelDefinitions(
667 s.db,
668 orm.FilterIn("at_uri", f.Labels),
669 orm.FilterContains("scope", tangled.RepoPullNSID),
670 )
671 if err != nil {
672 log.Println("failed to fetch labels", err)
673 s.pages.Error503(w)
674 return
675 }
676
677 defs := make(map[string]*models.LabelDefinition)
678 for _, l := range labelDefs {
679 defs[l.AtUri().String()] = &l
680 }
681
682 s.pages.RepoPulls(w, pages.RepoPullsParams{
683 LoggedInUser: s.oauth.GetUser(r),
684 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
685 Pulls: pulls,
686 LabelDefs: defs,
687 FilteringBy: state,
688 FilterQuery: keyword,
689 Stacks: stacks,
690 Pipelines: m,
691 })
692}
693
694func (s *Pulls) PullComment(w http.ResponseWriter, r *http.Request) {
695 user := s.oauth.GetUser(r)
696 f, err := s.repoResolver.Resolve(r)
697 if err != nil {
698 log.Println("failed to get repo and knot", err)
699 return
700 }
701
702 pull, ok := r.Context().Value("pull").(*models.Pull)
703 if !ok {
704 log.Println("failed to get pull")
705 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
706 return
707 }
708
709 roundNumberStr := chi.URLParam(r, "round")
710 roundNumber, err := strconv.Atoi(roundNumberStr)
711 if err != nil || roundNumber >= len(pull.Submissions) {
712 http.Error(w, "bad round id", http.StatusBadRequest)
713 log.Println("failed to parse round id", err)
714 return
715 }
716
717 switch r.Method {
718 case http.MethodGet:
719 s.pages.PullNewCommentFragment(w, pages.PullNewCommentParams{
720 LoggedInUser: user,
721 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
722 Pull: pull,
723 RoundNumber: roundNumber,
724 })
725 return
726 case http.MethodPost:
727 body := r.FormValue("body")
728 if body == "" {
729 s.pages.Notice(w, "pull", "Comment body is required")
730 return
731 }
732
733 mentions, references := s.mentionsResolver.Resolve(r.Context(), body)
734
735 // Start a transaction
736 tx, err := s.db.BeginTx(r.Context(), nil)
737 if err != nil {
738 log.Println("failed to start transaction", err)
739 s.pages.Notice(w, "pull-comment", "Failed to create comment.")
740 return
741 }
742 defer tx.Rollback()
743
744 createdAt := time.Now().Format(time.RFC3339)
745
746 client, err := s.oauth.AuthorizedClient(r)
747 if err != nil {
748 log.Println("failed to get authorized client", err)
749 s.pages.Notice(w, "pull-comment", "Failed to create comment.")
750 return
751 }
752 atResp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
753 Collection: tangled.RepoPullCommentNSID,
754 Repo: user.Did,
755 Rkey: tid.TID(),
756 Record: &lexutil.LexiconTypeDecoder{
757 Val: &tangled.RepoPullComment{
758 Pull: pull.AtUri().String(),
759 Body: body,
760 CreatedAt: createdAt,
761 },
762 },
763 })
764 if err != nil {
765 log.Println("failed to create pull comment", err)
766 s.pages.Notice(w, "pull-comment", "Failed to create comment.")
767 return
768 }
769
770 comment := &models.PullComment{
771 OwnerDid: user.Did,
772 RepoAt: f.RepoAt().String(),
773 PullId: pull.PullId,
774 Body: body,
775 CommentAt: atResp.Uri,
776 SubmissionId: pull.Submissions[roundNumber].ID,
777 Mentions: mentions,
778 References: references,
779 }
780
781 // Create the pull comment in the database with the commentAt field
782 commentId, err := db.NewPullComment(tx, comment)
783 if err != nil {
784 log.Println("failed to create pull comment", err)
785 s.pages.Notice(w, "pull-comment", "Failed to create comment.")
786 return
787 }
788
789 // Commit the transaction
790 if err = tx.Commit(); err != nil {
791 log.Println("failed to commit transaction", err)
792 s.pages.Notice(w, "pull-comment", "Failed to create comment.")
793 return
794 }
795
796 s.notifier.NewPullComment(r.Context(), comment, mentions)
797
798 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
799 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId))
800 return
801 }
802}
803
804func (s *Pulls) NewPull(w http.ResponseWriter, r *http.Request) {
805 user := s.oauth.GetUser(r)
806 f, err := s.repoResolver.Resolve(r)
807 if err != nil {
808 log.Println("failed to get repo and knot", err)
809 return
810 }
811
812 switch r.Method {
813 case http.MethodGet:
814 scheme := "http"
815 if !s.config.Core.Dev {
816 scheme = "https"
817 }
818 host := fmt.Sprintf("%s://%s", scheme, f.Knot)
819 xrpcc := &indigoxrpc.Client{
820 Host: host,
821 }
822
823 repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
824 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
825 if err != nil {
826 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
827 log.Println("failed to call XRPC repo.branches", xrpcerr)
828 s.pages.Error503(w)
829 return
830 }
831 log.Println("failed to fetch branches", err)
832 return
833 }
834
835 var result types.RepoBranchesResponse
836 if err := json.Unmarshal(xrpcBytes, &result); err != nil {
837 log.Println("failed to decode XRPC response", err)
838 s.pages.Error503(w)
839 return
840 }
841
842 // can be one of "patch", "branch" or "fork"
843 strategy := r.URL.Query().Get("strategy")
844 // ignored if strategy is "patch"
845 sourceBranch := r.URL.Query().Get("sourceBranch")
846 targetBranch := r.URL.Query().Get("targetBranch")
847
848 s.pages.RepoNewPull(w, pages.RepoNewPullParams{
849 LoggedInUser: user,
850 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
851 Branches: result.Branches,
852 Strategy: strategy,
853 SourceBranch: sourceBranch,
854 TargetBranch: targetBranch,
855 Title: r.URL.Query().Get("title"),
856 Body: r.URL.Query().Get("body"),
857 })
858
859 case http.MethodPost:
860 title := r.FormValue("title")
861 body := r.FormValue("body")
862 targetBranch := r.FormValue("targetBranch")
863 fromFork := r.FormValue("fork")
864 sourceBranch := r.FormValue("sourceBranch")
865 patch := r.FormValue("patch")
866
867 if targetBranch == "" {
868 s.pages.Notice(w, "pull", "Target branch is required.")
869 return
870 }
871
872 // Determine PR type based on input parameters
873 roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
874 isPushAllowed := roles.IsPushAllowed()
875 isBranchBased := isPushAllowed && sourceBranch != "" && fromFork == ""
876 isForkBased := fromFork != "" && sourceBranch != ""
877 isPatchBased := patch != "" && !isBranchBased && !isForkBased
878 isStacked := r.FormValue("isStacked") == "on"
879
880 if isPatchBased && !patchutil.IsFormatPatch(patch) {
881 if title == "" {
882 s.pages.Notice(w, "pull", "Title is required for git-diff patches.")
883 return
884 }
885 sanitizer := markup.NewSanitizer()
886 if st := strings.TrimSpace(sanitizer.SanitizeDescription(title)); (st) == "" {
887 s.pages.Notice(w, "pull", "Title is empty after HTML sanitization")
888 return
889 }
890 }
891
892 // Validate we have at least one valid PR creation method
893 if !isBranchBased && !isPatchBased && !isForkBased {
894 s.pages.Notice(w, "pull", "Neither source branch nor patch supplied.")
895 return
896 }
897
898 // Can't mix branch-based and patch-based approaches
899 if isBranchBased && patch != "" {
900 s.pages.Notice(w, "pull", "Cannot select both patch and source branch.")
901 return
902 }
903
904 // us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
905 // if err != nil {
906 // log.Printf("failed to create unsigned client to %s: %v", f.Knot, err)
907 // s.pages.Notice(w, "pull", "Failed to create a pull request. Try again later.")
908 // return
909 // }
910
911 // TODO: make capabilities an xrpc call
912 caps := struct {
913 PullRequests struct {
914 FormatPatch bool
915 BranchSubmissions bool
916 ForkSubmissions bool
917 PatchSubmissions bool
918 }
919 }{
920 PullRequests: struct {
921 FormatPatch bool
922 BranchSubmissions bool
923 ForkSubmissions bool
924 PatchSubmissions bool
925 }{
926 FormatPatch: true,
927 BranchSubmissions: true,
928 ForkSubmissions: true,
929 PatchSubmissions: true,
930 },
931 }
932
933 // caps, err := us.Capabilities()
934 // if err != nil {
935 // log.Println("error fetching knot caps", f.Knot, err)
936 // s.pages.Notice(w, "pull", "Failed to create a pull request. Try again later.")
937 // return
938 // }
939
940 if !caps.PullRequests.FormatPatch {
941 s.pages.Notice(w, "pull", "This knot doesn't support format-patch. Unfortunately, there is no fallback for now.")
942 return
943 }
944
945 // Handle the PR creation based on the type
946 if isBranchBased {
947 if !caps.PullRequests.BranchSubmissions {
948 s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?")
949 return
950 }
951 s.handleBranchBasedPull(w, r, f, user, title, body, targetBranch, sourceBranch, isStacked)
952 } else if isForkBased {
953 if !caps.PullRequests.ForkSubmissions {
954 s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?")
955 return
956 }
957 s.handleForkBasedPull(w, r, f, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)
958 } else if isPatchBased {
959 if !caps.PullRequests.PatchSubmissions {
960 s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.")
961 return
962 }
963 s.handlePatchBasedPull(w, r, f, user, title, body, targetBranch, patch, isStacked)
964 }
965 return
966 }
967}
968
969func (s *Pulls) handleBranchBasedPull(
970 w http.ResponseWriter,
971 r *http.Request,
972 repo *models.Repo,
973 user *oauth.User,
974 title,
975 body,
976 targetBranch,
977 sourceBranch string,
978 isStacked bool,
979) {
980 scheme := "http"
981 if !s.config.Core.Dev {
982 scheme = "https"
983 }
984 host := fmt.Sprintf("%s://%s", scheme, repo.Knot)
985 xrpcc := &indigoxrpc.Client{
986 Host: host,
987 }
988
989 didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
990 xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, didSlashRepo, targetBranch, sourceBranch)
991 if err != nil {
992 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
993 log.Println("failed to call XRPC repo.compare", xrpcerr)
994 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
995 return
996 }
997 log.Println("failed to compare", err)
998 s.pages.Notice(w, "pull", err.Error())
999 return
1000 }
1001
1002 var comparison types.RepoFormatPatchResponse
1003 if err := json.Unmarshal(xrpcBytes, &comparison); err != nil {
1004 log.Println("failed to decode XRPC compare response", err)
1005 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1006 return
1007 }
1008
1009 sourceRev := comparison.Rev2
1010 patch := comparison.FormatPatchRaw
1011 combined := comparison.CombinedPatchRaw
1012
1013 if err := s.validator.ValidatePatch(&patch); err != nil {
1014 s.logger.Error("failed to validate patch", "err", err)
1015 s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")
1016 return
1017 }
1018
1019 pullSource := &models.PullSource{
1020 Branch: sourceBranch,
1021 }
1022 recordPullSource := &tangled.RepoPull_Source{
1023 Branch: sourceBranch,
1024 Sha: comparison.Rev2,
1025 }
1026
1027 s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)
1028}
1029
1030func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) {
1031 if err := s.validator.ValidatePatch(&patch); err != nil {
1032 s.logger.Error("patch validation failed", "err", err)
1033 s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")
1034 return
1035 }
1036
1037 s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked)
1038}
1039
1040func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {
1041 repoString := strings.SplitN(forkRepo, "/", 2)
1042 forkOwnerDid := repoString[0]
1043 repoName := repoString[1]
1044 fork, err := db.GetForkByDid(s.db, forkOwnerDid, repoName)
1045 if errors.Is(err, sql.ErrNoRows) {
1046 s.pages.Notice(w, "pull", "No such fork.")
1047 return
1048 } else if err != nil {
1049 log.Println("failed to fetch fork:", err)
1050 s.pages.Notice(w, "pull", "Failed to fetch fork.")
1051 return
1052 }
1053
1054 client, err := s.oauth.ServiceClient(
1055 r,
1056 oauth.WithService(fork.Knot),
1057 oauth.WithLxm(tangled.RepoHiddenRefNSID),
1058 oauth.WithDev(s.config.Core.Dev),
1059 )
1060
1061 resp, err := tangled.RepoHiddenRef(
1062 r.Context(),
1063 client,
1064 &tangled.RepoHiddenRef_Input{
1065 ForkRef: sourceBranch,
1066 RemoteRef: targetBranch,
1067 Repo: fork.RepoAt().String(),
1068 },
1069 )
1070 if err := xrpcclient.HandleXrpcErr(err); err != nil {
1071 s.pages.Notice(w, "pull", err.Error())
1072 return
1073 }
1074
1075 if !resp.Success {
1076 errorMsg := "Failed to create pull request"
1077 if resp.Error != nil {
1078 errorMsg = fmt.Sprintf("Failed to create pull request: %s", *resp.Error)
1079 }
1080 s.pages.Notice(w, "pull", errorMsg)
1081 return
1082 }
1083
1084 hiddenRef := fmt.Sprintf("hidden/%s/%s", sourceBranch, targetBranch)
1085 // We're now comparing the sourceBranch (on the fork) against the hiddenRef which is tracking
1086 // the targetBranch on the target repository. This code is a bit confusing, but here's an example:
1087 // hiddenRef: hidden/feature-1/main (on repo-fork)
1088 // targetBranch: main (on repo-1)
1089 // sourceBranch: feature-1 (on repo-fork)
1090 forkScheme := "http"
1091 if !s.config.Core.Dev {
1092 forkScheme = "https"
1093 }
1094 forkHost := fmt.Sprintf("%s://%s", forkScheme, fork.Knot)
1095 forkXrpcc := &indigoxrpc.Client{
1096 Host: forkHost,
1097 }
1098
1099 forkRepoId := fmt.Sprintf("%s/%s", fork.Did, fork.Name)
1100 forkXrpcBytes, err := tangled.RepoCompare(r.Context(), forkXrpcc, forkRepoId, hiddenRef, sourceBranch)
1101 if err != nil {
1102 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1103 log.Println("failed to call XRPC repo.compare for fork", xrpcerr)
1104 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1105 return
1106 }
1107 log.Println("failed to compare across branches", err)
1108 s.pages.Notice(w, "pull", err.Error())
1109 return
1110 }
1111
1112 var comparison types.RepoFormatPatchResponse
1113 if err := json.Unmarshal(forkXrpcBytes, &comparison); err != nil {
1114 log.Println("failed to decode XRPC compare response for fork", err)
1115 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1116 return
1117 }
1118
1119 sourceRev := comparison.Rev2
1120 patch := comparison.FormatPatchRaw
1121 combined := comparison.CombinedPatchRaw
1122
1123 if err := s.validator.ValidatePatch(&patch); err != nil {
1124 s.logger.Error("failed to validate patch", "err", err)
1125 s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")
1126 return
1127 }
1128
1129 forkAtUri := fork.RepoAt()
1130 forkAtUriStr := forkAtUri.String()
1131
1132 pullSource := &models.PullSource{
1133 Branch: sourceBranch,
1134 RepoAt: &forkAtUri,
1135 }
1136 recordPullSource := &tangled.RepoPull_Source{
1137 Branch: sourceBranch,
1138 Repo: &forkAtUriStr,
1139 Sha: sourceRev,
1140 }
1141
1142 s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)
1143}
1144
1145func (s *Pulls) createPullRequest(
1146 w http.ResponseWriter,
1147 r *http.Request,
1148 repo *models.Repo,
1149 user *oauth.User,
1150 title, body, targetBranch string,
1151 patch string,
1152 combined string,
1153 sourceRev string,
1154 pullSource *models.PullSource,
1155 recordPullSource *tangled.RepoPull_Source,
1156 isStacked bool,
1157) {
1158 if isStacked {
1159 // creates a series of PRs, each linking to the previous, identified by jj's change-id
1160 s.createStackedPullRequest(
1161 w,
1162 r,
1163 repo,
1164 user,
1165 targetBranch,
1166 patch,
1167 sourceRev,
1168 pullSource,
1169 )
1170 return
1171 }
1172
1173 client, err := s.oauth.AuthorizedClient(r)
1174 if err != nil {
1175 log.Println("failed to get authorized client", err)
1176 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1177 return
1178 }
1179
1180 tx, err := s.db.BeginTx(r.Context(), nil)
1181 if err != nil {
1182 log.Println("failed to start tx")
1183 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1184 return
1185 }
1186 defer tx.Rollback()
1187
1188 // We've already checked earlier if it's diff-based and title is empty,
1189 // so if it's still empty now, it's intentionally skipped owing to format-patch.
1190 if title == "" || body == "" {
1191 formatPatches, err := patchutil.ExtractPatches(patch)
1192 if err != nil {
1193 s.pages.Notice(w, "pull", fmt.Sprintf("Failed to extract patches: %v", err))
1194 return
1195 }
1196 if len(formatPatches) == 0 {
1197 s.pages.Notice(w, "pull", "No patches found in the supplied format-patch.")
1198 return
1199 }
1200
1201 if title == "" {
1202 title = formatPatches[0].Title
1203 }
1204 if body == "" {
1205 body = formatPatches[0].Body
1206 }
1207 }
1208
1209 mentions, references := s.mentionsResolver.Resolve(r.Context(), body)
1210
1211 rkey := tid.TID()
1212 initialSubmission := models.PullSubmission{
1213 Patch: patch,
1214 Combined: combined,
1215 SourceRev: sourceRev,
1216 }
1217 pull := &models.Pull{
1218 Title: title,
1219 Body: body,
1220 TargetBranch: targetBranch,
1221 OwnerDid: user.Did,
1222 RepoAt: repo.RepoAt(),
1223 Rkey: rkey,
1224 Mentions: mentions,
1225 References: references,
1226 Submissions: []*models.PullSubmission{
1227 &initialSubmission,
1228 },
1229 PullSource: pullSource,
1230 }
1231 err = db.NewPull(tx, pull)
1232 if err != nil {
1233 log.Println("failed to create pull request", err)
1234 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1235 return
1236 }
1237 pullId, err := db.NextPullId(tx, repo.RepoAt())
1238 if err != nil {
1239 log.Println("failed to get pull id", err)
1240 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1241 return
1242 }
1243
1244 blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch))
1245 if err != nil {
1246 log.Println("failed to upload patch", err)
1247 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1248 return
1249 }
1250
1251 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
1252 Collection: tangled.RepoPullNSID,
1253 Repo: user.Did,
1254 Rkey: rkey,
1255 Record: &lexutil.LexiconTypeDecoder{
1256 Val: &tangled.RepoPull{
1257 Title: title,
1258 Target: &tangled.RepoPull_Target{
1259 Repo: string(repo.RepoAt()),
1260 Branch: targetBranch,
1261 },
1262 PatchBlob: blob.Blob,
1263 Source: recordPullSource,
1264 CreatedAt: time.Now().Format(time.RFC3339),
1265 },
1266 },
1267 })
1268 if err != nil {
1269 log.Println("failed to create pull request", err)
1270 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1271 return
1272 }
1273
1274 if err = tx.Commit(); err != nil {
1275 log.Println("failed to create pull request", err)
1276 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1277 return
1278 }
1279
1280 s.notifier.NewPull(r.Context(), pull)
1281
1282 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)
1283 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pullId))
1284}
1285
1286func (s *Pulls) createStackedPullRequest(
1287 w http.ResponseWriter,
1288 r *http.Request,
1289 repo *models.Repo,
1290 user *oauth.User,
1291 targetBranch string,
1292 patch string,
1293 sourceRev string,
1294 pullSource *models.PullSource,
1295) {
1296 // run some necessary checks for stacked-prs first
1297
1298 // must be branch or fork based
1299 if sourceRev == "" {
1300 log.Println("stacked PR from patch-based pull")
1301 s.pages.Notice(w, "pull", "Stacking is only supported on branch and fork based pull-requests.")
1302 return
1303 }
1304
1305 formatPatches, err := patchutil.ExtractPatches(patch)
1306 if err != nil {
1307 log.Println("failed to extract patches", err)
1308 s.pages.Notice(w, "pull", fmt.Sprintf("Failed to extract patches: %v", err))
1309 return
1310 }
1311
1312 // must have atleast 1 patch to begin with
1313 if len(formatPatches) == 0 {
1314 log.Println("empty patches")
1315 s.pages.Notice(w, "pull", "No patches found in the generated format-patch.")
1316 return
1317 }
1318
1319 // build a stack out of this patch
1320 stackId := uuid.New()
1321 stack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pullSource, stackId.String())
1322 if err != nil {
1323 log.Println("failed to create stack", err)
1324 s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err))
1325 return
1326 }
1327
1328 client, err := s.oauth.AuthorizedClient(r)
1329 if err != nil {
1330 log.Println("failed to get authorized client", err)
1331 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1332 return
1333 }
1334
1335 // apply all record creations at once
1336 var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem
1337 for _, p := range stack {
1338 blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(p.LatestPatch()))
1339 if err != nil {
1340 log.Println("failed to upload patch blob", err)
1341 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1342 return
1343 }
1344
1345 record := p.AsRecord()
1346 record.PatchBlob = blob.Blob
1347 writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
1348 RepoApplyWrites_Create: &comatproto.RepoApplyWrites_Create{
1349 Collection: tangled.RepoPullNSID,
1350 Rkey: &p.Rkey,
1351 Value: &lexutil.LexiconTypeDecoder{
1352 Val: &record,
1353 },
1354 },
1355 })
1356 }
1357 _, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{
1358 Repo: user.Did,
1359 Writes: writes,
1360 })
1361 if err != nil {
1362 log.Println("failed to create stacked pull request", err)
1363 s.pages.Notice(w, "pull", "Failed to create stacked pull request. Try again later.")
1364 return
1365 }
1366
1367 // create all pulls at once
1368 tx, err := s.db.BeginTx(r.Context(), nil)
1369 if err != nil {
1370 log.Println("failed to start tx")
1371 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1372 return
1373 }
1374 defer tx.Rollback()
1375
1376 for _, p := range stack {
1377 err = db.NewPull(tx, p)
1378 if err != nil {
1379 log.Println("failed to create pull request", err)
1380 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1381 return
1382 }
1383
1384 }
1385
1386 if err = tx.Commit(); err != nil {
1387 log.Println("failed to create pull request", err)
1388 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1389 return
1390 }
1391
1392 // notify about each pull
1393 //
1394 // this is performed after tx.Commit, because it could result in a locked DB otherwise
1395 for _, p := range stack {
1396 s.notifier.NewPull(r.Context(), p)
1397 }
1398
1399 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)
1400 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls", ownerSlashRepo))
1401}
1402
1403func (s *Pulls) ValidatePatch(w http.ResponseWriter, r *http.Request) {
1404 _, err := s.repoResolver.Resolve(r)
1405 if err != nil {
1406 log.Println("failed to get repo and knot", err)
1407 return
1408 }
1409
1410 patch := r.FormValue("patch")
1411 if patch == "" {
1412 s.pages.Notice(w, "patch-error", "Patch is required.")
1413 return
1414 }
1415
1416 if err := s.validator.ValidatePatch(&patch); err != nil {
1417 s.logger.Error("faield to validate patch", "err", err)
1418 s.pages.Notice(w, "patch-error", "Invalid patch format. Please provide a valid git diff or format-patch.")
1419 return
1420 }
1421
1422 if patchutil.IsFormatPatch(patch) {
1423 s.pages.Notice(w, "patch-preview", "git-format-patch detected. Title and description are optional; if left out, they will be extracted from the first commit.")
1424 } else {
1425 s.pages.Notice(w, "patch-preview", "Regular git-diff detected. Please provide a title and description.")
1426 }
1427}
1428
1429func (s *Pulls) PatchUploadFragment(w http.ResponseWriter, r *http.Request) {
1430 user := s.oauth.GetUser(r)
1431
1432 s.pages.PullPatchUploadFragment(w, pages.PullPatchUploadParams{
1433 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
1434 })
1435}
1436
1437func (s *Pulls) CompareBranchesFragment(w http.ResponseWriter, r *http.Request) {
1438 user := s.oauth.GetUser(r)
1439 f, err := s.repoResolver.Resolve(r)
1440 if err != nil {
1441 log.Println("failed to get repo and knot", err)
1442 return
1443 }
1444
1445 scheme := "http"
1446 if !s.config.Core.Dev {
1447 scheme = "https"
1448 }
1449 host := fmt.Sprintf("%s://%s", scheme, f.Knot)
1450 xrpcc := &indigoxrpc.Client{
1451 Host: host,
1452 }
1453
1454 repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
1455 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
1456 if err != nil {
1457 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1458 log.Println("failed to call XRPC repo.branches", xrpcerr)
1459 s.pages.Error503(w)
1460 return
1461 }
1462 log.Println("failed to fetch branches", err)
1463 return
1464 }
1465
1466 var result types.RepoBranchesResponse
1467 if err := json.Unmarshal(xrpcBytes, &result); err != nil {
1468 log.Println("failed to decode XRPC response", err)
1469 s.pages.Error503(w)
1470 return
1471 }
1472
1473 branches := result.Branches
1474 sort.Slice(branches, func(i int, j int) bool {
1475 return branches[i].Commit.Committer.When.After(branches[j].Commit.Committer.When)
1476 })
1477
1478 withoutDefault := []types.Branch{}
1479 for _, b := range branches {
1480 if b.IsDefault {
1481 continue
1482 }
1483 withoutDefault = append(withoutDefault, b)
1484 }
1485
1486 s.pages.PullCompareBranchesFragment(w, pages.PullCompareBranchesParams{
1487 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
1488 Branches: withoutDefault,
1489 })
1490}
1491
1492func (s *Pulls) CompareForksFragment(w http.ResponseWriter, r *http.Request) {
1493 user := s.oauth.GetUser(r)
1494
1495 forks, err := db.GetForksByDid(s.db, user.Did)
1496 if err != nil {
1497 log.Println("failed to get forks", err)
1498 return
1499 }
1500
1501 s.pages.PullCompareForkFragment(w, pages.PullCompareForkParams{
1502 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
1503 Forks: forks,
1504 Selected: r.URL.Query().Get("fork"),
1505 })
1506}
1507
1508func (s *Pulls) CompareForksBranchesFragment(w http.ResponseWriter, r *http.Request) {
1509 user := s.oauth.GetUser(r)
1510
1511 f, err := s.repoResolver.Resolve(r)
1512 if err != nil {
1513 log.Println("failed to get repo and knot", err)
1514 return
1515 }
1516
1517 forkVal := r.URL.Query().Get("fork")
1518 repoString := strings.SplitN(forkVal, "/", 2)
1519 forkOwnerDid := repoString[0]
1520 forkName := repoString[1]
1521 // fork repo
1522 repo, err := db.GetRepo(
1523 s.db,
1524 orm.FilterEq("did", forkOwnerDid),
1525 orm.FilterEq("name", forkName),
1526 )
1527 if err != nil {
1528 log.Println("failed to get repo", "did", forkOwnerDid, "name", forkName, "err", err)
1529 return
1530 }
1531
1532 sourceScheme := "http"
1533 if !s.config.Core.Dev {
1534 sourceScheme = "https"
1535 }
1536 sourceHost := fmt.Sprintf("%s://%s", sourceScheme, repo.Knot)
1537 sourceXrpcc := &indigoxrpc.Client{
1538 Host: sourceHost,
1539 }
1540
1541 sourceRepo := fmt.Sprintf("%s/%s", forkOwnerDid, repo.Name)
1542 sourceXrpcBytes, err := tangled.RepoBranches(r.Context(), sourceXrpcc, "", 0, sourceRepo)
1543 if err != nil {
1544 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1545 log.Println("failed to call XRPC repo.branches for source", xrpcerr)
1546 s.pages.Error503(w)
1547 return
1548 }
1549 log.Println("failed to fetch source branches", err)
1550 return
1551 }
1552
1553 // Decode source branches
1554 var sourceBranches types.RepoBranchesResponse
1555 if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil {
1556 log.Println("failed to decode source branches XRPC response", err)
1557 s.pages.Error503(w)
1558 return
1559 }
1560
1561 targetScheme := "http"
1562 if !s.config.Core.Dev {
1563 targetScheme = "https"
1564 }
1565 targetHost := fmt.Sprintf("%s://%s", targetScheme, f.Knot)
1566 targetXrpcc := &indigoxrpc.Client{
1567 Host: targetHost,
1568 }
1569
1570 targetRepo := fmt.Sprintf("%s/%s", f.Did, f.Name)
1571 targetXrpcBytes, err := tangled.RepoBranches(r.Context(), targetXrpcc, "", 0, targetRepo)
1572 if err != nil {
1573 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1574 log.Println("failed to call XRPC repo.branches for target", xrpcerr)
1575 s.pages.Error503(w)
1576 return
1577 }
1578 log.Println("failed to fetch target branches", err)
1579 return
1580 }
1581
1582 // Decode target branches
1583 var targetBranches types.RepoBranchesResponse
1584 if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil {
1585 log.Println("failed to decode target branches XRPC response", err)
1586 s.pages.Error503(w)
1587 return
1588 }
1589
1590 sort.Slice(sourceBranches.Branches, func(i int, j int) bool {
1591 return sourceBranches.Branches[i].Commit.Committer.When.After(sourceBranches.Branches[j].Commit.Committer.When)
1592 })
1593
1594 s.pages.PullCompareForkBranchesFragment(w, pages.PullCompareForkBranchesParams{
1595 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
1596 SourceBranches: sourceBranches.Branches,
1597 TargetBranches: targetBranches.Branches,
1598 })
1599}
1600
1601func (s *Pulls) ResubmitPull(w http.ResponseWriter, r *http.Request) {
1602 user := s.oauth.GetUser(r)
1603
1604 pull, ok := r.Context().Value("pull").(*models.Pull)
1605 if !ok {
1606 log.Println("failed to get pull")
1607 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
1608 return
1609 }
1610
1611 switch r.Method {
1612 case http.MethodGet:
1613 s.pages.PullResubmitFragment(w, pages.PullResubmitParams{
1614 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
1615 Pull: pull,
1616 })
1617 return
1618 case http.MethodPost:
1619 if pull.IsPatchBased() {
1620 s.resubmitPatch(w, r)
1621 return
1622 } else if pull.IsBranchBased() {
1623 s.resubmitBranch(w, r)
1624 return
1625 } else if pull.IsForkBased() {
1626 s.resubmitFork(w, r)
1627 return
1628 }
1629 }
1630}
1631
1632func (s *Pulls) resubmitPatch(w http.ResponseWriter, r *http.Request) {
1633 user := s.oauth.GetUser(r)
1634
1635 pull, ok := r.Context().Value("pull").(*models.Pull)
1636 if !ok {
1637 log.Println("failed to get pull")
1638 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
1639 return
1640 }
1641
1642 f, err := s.repoResolver.Resolve(r)
1643 if err != nil {
1644 log.Println("failed to get repo and knot", err)
1645 return
1646 }
1647
1648 if user.Did != pull.OwnerDid {
1649 log.Println("unauthorized user")
1650 w.WriteHeader(http.StatusUnauthorized)
1651 return
1652 }
1653
1654 patch := r.FormValue("patch")
1655
1656 s.resubmitPullHelper(w, r, f, user, pull, patch, "", "")
1657}
1658
1659func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {
1660 user := s.oauth.GetUser(r)
1661
1662 pull, ok := r.Context().Value("pull").(*models.Pull)
1663 if !ok {
1664 log.Println("failed to get pull")
1665 s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.")
1666 return
1667 }
1668
1669 f, err := s.repoResolver.Resolve(r)
1670 if err != nil {
1671 log.Println("failed to get repo and knot", err)
1672 return
1673 }
1674
1675 if user.Did != pull.OwnerDid {
1676 log.Println("unauthorized user")
1677 w.WriteHeader(http.StatusUnauthorized)
1678 return
1679 }
1680
1681 roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
1682 if !roles.IsPushAllowed() {
1683 log.Println("unauthorized user")
1684 w.WriteHeader(http.StatusUnauthorized)
1685 return
1686 }
1687
1688 scheme := "http"
1689 if !s.config.Core.Dev {
1690 scheme = "https"
1691 }
1692 host := fmt.Sprintf("%s://%s", scheme, f.Knot)
1693 xrpcc := &indigoxrpc.Client{
1694 Host: host,
1695 }
1696
1697 repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
1698 xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, pull.TargetBranch, pull.PullSource.Branch)
1699 if err != nil {
1700 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1701 log.Println("failed to call XRPC repo.compare", xrpcerr)
1702 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1703 return
1704 }
1705 log.Printf("compare request failed: %s", err)
1706 s.pages.Notice(w, "resubmit-error", err.Error())
1707 return
1708 }
1709
1710 var comparison types.RepoFormatPatchResponse
1711 if err := json.Unmarshal(xrpcBytes, &comparison); err != nil {
1712 log.Println("failed to decode XRPC compare response", err)
1713 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1714 return
1715 }
1716
1717 sourceRev := comparison.Rev2
1718 patch := comparison.FormatPatchRaw
1719 combined := comparison.CombinedPatchRaw
1720
1721 s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)
1722}
1723
1724func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {
1725 user := s.oauth.GetUser(r)
1726
1727 pull, ok := r.Context().Value("pull").(*models.Pull)
1728 if !ok {
1729 log.Println("failed to get pull")
1730 s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.")
1731 return
1732 }
1733
1734 f, err := s.repoResolver.Resolve(r)
1735 if err != nil {
1736 log.Println("failed to get repo and knot", err)
1737 return
1738 }
1739
1740 if user.Did != pull.OwnerDid {
1741 log.Println("unauthorized user")
1742 w.WriteHeader(http.StatusUnauthorized)
1743 return
1744 }
1745
1746 forkRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())
1747 if err != nil {
1748 log.Println("failed to get source repo", err)
1749 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1750 return
1751 }
1752
1753 // update the hidden tracking branch to latest
1754 client, err := s.oauth.ServiceClient(
1755 r,
1756 oauth.WithService(forkRepo.Knot),
1757 oauth.WithLxm(tangled.RepoHiddenRefNSID),
1758 oauth.WithDev(s.config.Core.Dev),
1759 )
1760 if err != nil {
1761 log.Printf("failed to connect to knot server: %v", err)
1762 return
1763 }
1764
1765 resp, err := tangled.RepoHiddenRef(
1766 r.Context(),
1767 client,
1768 &tangled.RepoHiddenRef_Input{
1769 ForkRef: pull.PullSource.Branch,
1770 RemoteRef: pull.TargetBranch,
1771 Repo: forkRepo.RepoAt().String(),
1772 },
1773 )
1774 if err := xrpcclient.HandleXrpcErr(err); err != nil {
1775 s.pages.Notice(w, "resubmit-error", err.Error())
1776 return
1777 }
1778 if !resp.Success {
1779 log.Println("Failed to update tracking ref.", "err", resp.Error)
1780 s.pages.Notice(w, "resubmit-error", "Failed to update tracking ref.")
1781 return
1782 }
1783
1784 hiddenRef := fmt.Sprintf("hidden/%s/%s", pull.PullSource.Branch, pull.TargetBranch)
1785 // extract patch by performing compare
1786 forkScheme := "http"
1787 if !s.config.Core.Dev {
1788 forkScheme = "https"
1789 }
1790 forkHost := fmt.Sprintf("%s://%s", forkScheme, forkRepo.Knot)
1791 forkRepoId := fmt.Sprintf("%s/%s", forkRepo.Did, forkRepo.Name)
1792 forkXrpcBytes, err := tangled.RepoCompare(r.Context(), &indigoxrpc.Client{Host: forkHost}, forkRepoId, hiddenRef, pull.PullSource.Branch)
1793 if err != nil {
1794 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1795 log.Println("failed to call XRPC repo.compare for fork", xrpcerr)
1796 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1797 return
1798 }
1799 log.Printf("failed to compare branches: %s", err)
1800 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1801 return
1802 }
1803
1804 var forkComparison types.RepoFormatPatchResponse
1805 if err := json.Unmarshal(forkXrpcBytes, &forkComparison); err != nil {
1806 log.Println("failed to decode XRPC compare response for fork", err)
1807 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1808 return
1809 }
1810
1811 // Use the fork comparison we already made
1812 comparison := forkComparison
1813
1814 sourceRev := comparison.Rev2
1815 patch := comparison.FormatPatchRaw
1816 combined := comparison.CombinedPatchRaw
1817
1818 s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)
1819}
1820
1821func (s *Pulls) resubmitPullHelper(
1822 w http.ResponseWriter,
1823 r *http.Request,
1824 repo *models.Repo,
1825 user *oauth.User,
1826 pull *models.Pull,
1827 patch string,
1828 combined string,
1829 sourceRev string,
1830) {
1831 if pull.IsStacked() {
1832 log.Println("resubmitting stacked PR")
1833 s.resubmitStackedPullHelper(w, r, repo, user, pull, patch, pull.StackId)
1834 return
1835 }
1836
1837 if err := s.validator.ValidatePatch(&patch); err != nil {
1838 s.pages.Notice(w, "resubmit-error", err.Error())
1839 return
1840 }
1841
1842 if patch == pull.LatestPatch() {
1843 s.pages.Notice(w, "resubmit-error", "Patch is identical to previous submission.")
1844 return
1845 }
1846
1847 // validate sourceRev if branch/fork based
1848 if pull.IsBranchBased() || pull.IsForkBased() {
1849 if sourceRev == pull.LatestSha() {
1850 s.pages.Notice(w, "resubmit-error", "This branch has not changed since the last submission.")
1851 return
1852 }
1853 }
1854
1855 tx, err := s.db.BeginTx(r.Context(), nil)
1856 if err != nil {
1857 log.Println("failed to start tx")
1858 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1859 return
1860 }
1861 defer tx.Rollback()
1862
1863 pullAt := pull.AtUri()
1864 newRoundNumber := len(pull.Submissions)
1865 newPatch := patch
1866 newSourceRev := sourceRev
1867 combinedPatch := combined
1868 err = db.ResubmitPull(tx, pullAt, newRoundNumber, newPatch, combinedPatch, newSourceRev)
1869 if err != nil {
1870 log.Println("failed to create pull request", err)
1871 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1872 return
1873 }
1874 client, err := s.oauth.AuthorizedClient(r)
1875 if err != nil {
1876 log.Println("failed to authorize client")
1877 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1878 return
1879 }
1880
1881 ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, user.Did, pull.Rkey)
1882 if err != nil {
1883 // failed to get record
1884 s.pages.Notice(w, "resubmit-error", "Failed to update pull, no record found on PDS.")
1885 return
1886 }
1887
1888 blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch))
1889 if err != nil {
1890 log.Println("failed to upload patch blob", err)
1891 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
1892 return
1893 }
1894 record := pull.AsRecord()
1895 record.PatchBlob = blob.Blob
1896 record.CreatedAt = time.Now().Format(time.RFC3339)
1897
1898 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
1899 Collection: tangled.RepoPullNSID,
1900 Repo: user.Did,
1901 Rkey: pull.Rkey,
1902 SwapRecord: ex.Cid,
1903 Record: &lexutil.LexiconTypeDecoder{
1904 Val: &record,
1905 },
1906 })
1907 if err != nil {
1908 log.Println("failed to update record", err)
1909 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
1910 return
1911 }
1912
1913 if err = tx.Commit(); err != nil {
1914 log.Println("failed to commit transaction", err)
1915 s.pages.Notice(w, "resubmit-error", "Failed to resubmit pull.")
1916 return
1917 }
1918
1919 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)
1920 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
1921}
1922
1923func (s *Pulls) resubmitStackedPullHelper(
1924 w http.ResponseWriter,
1925 r *http.Request,
1926 repo *models.Repo,
1927 user *oauth.User,
1928 pull *models.Pull,
1929 patch string,
1930 stackId string,
1931) {
1932 targetBranch := pull.TargetBranch
1933
1934 origStack, _ := r.Context().Value("stack").(models.Stack)
1935 newStack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pull.PullSource, stackId)
1936 if err != nil {
1937 log.Println("failed to create resubmitted stack", err)
1938 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
1939 return
1940 }
1941
1942 // find the diff between the stacks, first, map them by changeId
1943 origById := make(map[string]*models.Pull)
1944 newById := make(map[string]*models.Pull)
1945 for _, p := range origStack {
1946 origById[p.ChangeId] = p
1947 }
1948 for _, p := range newStack {
1949 newById[p.ChangeId] = p
1950 }
1951
1952 // commits that got deleted: corresponding pull is closed
1953 // commits that got added: new pull is created
1954 // commits that got updated: corresponding pull is resubmitted & new round begins
1955 additions := make(map[string]*models.Pull)
1956 deletions := make(map[string]*models.Pull)
1957 updated := make(map[string]struct{})
1958
1959 // pulls in orignal stack but not in new one
1960 for _, op := range origStack {
1961 if _, ok := newById[op.ChangeId]; !ok {
1962 deletions[op.ChangeId] = op
1963 }
1964 }
1965
1966 // pulls in new stack but not in original one
1967 for _, np := range newStack {
1968 if _, ok := origById[np.ChangeId]; !ok {
1969 additions[np.ChangeId] = np
1970 }
1971 }
1972
1973 // NOTE: this loop can be written in any of above blocks,
1974 // but is written separately in the interest of simpler code
1975 for _, np := range newStack {
1976 if op, ok := origById[np.ChangeId]; ok {
1977 // pull exists in both stacks
1978 updated[op.ChangeId] = struct{}{}
1979 }
1980 }
1981
1982 tx, err := s.db.Begin()
1983 if err != nil {
1984 log.Println("failed to start transaction", err)
1985 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
1986 return
1987 }
1988 defer tx.Rollback()
1989
1990 client, err := s.oauth.AuthorizedClient(r)
1991 if err != nil {
1992 log.Println("failed to authorize client")
1993 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1994 return
1995 }
1996
1997 // pds updates to make
1998 var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem
1999
2000 // deleted pulls are marked as deleted in the DB
2001 for _, p := range deletions {
2002 // do not do delete already merged PRs
2003 if p.State == models.PullMerged {
2004 continue
2005 }
2006
2007 err := db.DeletePull(tx, p.RepoAt, p.PullId)
2008 if err != nil {
2009 log.Println("failed to delete pull", err, p.PullId)
2010 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
2011 return
2012 }
2013 writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
2014 RepoApplyWrites_Delete: &comatproto.RepoApplyWrites_Delete{
2015 Collection: tangled.RepoPullNSID,
2016 Rkey: p.Rkey,
2017 },
2018 })
2019 }
2020
2021 // new pulls are created
2022 for _, p := range additions {
2023 err := db.NewPull(tx, p)
2024 if err != nil {
2025 log.Println("failed to create pull", err, p.PullId)
2026 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
2027 return
2028 }
2029
2030 blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch))
2031 if err != nil {
2032 log.Println("failed to upload patch blob", err)
2033 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
2034 return
2035 }
2036 record := p.AsRecord()
2037 record.PatchBlob = blob.Blob
2038 writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
2039 RepoApplyWrites_Create: &comatproto.RepoApplyWrites_Create{
2040 Collection: tangled.RepoPullNSID,
2041 Rkey: &p.Rkey,
2042 Value: &lexutil.LexiconTypeDecoder{
2043 Val: &record,
2044 },
2045 },
2046 })
2047 }
2048
2049 // updated pulls are, well, updated; to start a new round
2050 for id := range updated {
2051 op, _ := origById[id]
2052 np, _ := newById[id]
2053
2054 // do not update already merged PRs
2055 if op.State == models.PullMerged {
2056 continue
2057 }
2058
2059 // resubmit the new pull
2060 pullAt := op.AtUri()
2061 newRoundNumber := len(op.Submissions)
2062 newPatch := np.LatestPatch()
2063 combinedPatch := np.LatestSubmission().Combined
2064 newSourceRev := np.LatestSha()
2065 err := db.ResubmitPull(tx, pullAt, newRoundNumber, newPatch, combinedPatch, newSourceRev)
2066 if err != nil {
2067 log.Println("failed to update pull", err, op.PullId)
2068 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
2069 return
2070 }
2071
2072 blob, err := comatproto.RepoUploadBlob(r.Context(), client, strings.NewReader(patch))
2073 if err != nil {
2074 log.Println("failed to upload patch blob", err)
2075 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
2076 return
2077 }
2078 record := np.AsRecord()
2079 record.PatchBlob = blob.Blob
2080 writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
2081 RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{
2082 Collection: tangled.RepoPullNSID,
2083 Rkey: op.Rkey,
2084 Value: &lexutil.LexiconTypeDecoder{
2085 Val: &record,
2086 },
2087 },
2088 })
2089 }
2090
2091 // update parent-change-id relations for the entire stack
2092 for _, p := range newStack {
2093 err := db.SetPullParentChangeId(
2094 tx,
2095 p.ParentChangeId,
2096 // these should be enough filters to be unique per-stack
2097 orm.FilterEq("repo_at", p.RepoAt.String()),
2098 orm.FilterEq("owner_did", p.OwnerDid),
2099 orm.FilterEq("change_id", p.ChangeId),
2100 )
2101
2102 if err != nil {
2103 log.Println("failed to update pull", err, p.PullId)
2104 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
2105 return
2106 }
2107 }
2108
2109 err = tx.Commit()
2110 if err != nil {
2111 log.Println("failed to resubmit pull", err)
2112 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
2113 return
2114 }
2115
2116 _, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{
2117 Repo: user.Did,
2118 Writes: writes,
2119 })
2120 if err != nil {
2121 log.Println("failed to create stacked pull request", err)
2122 s.pages.Notice(w, "pull", "Failed to create stacked pull request. Try again later.")
2123 return
2124 }
2125
2126 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)
2127 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2128}
2129
2130func (s *Pulls) MergePull(w http.ResponseWriter, r *http.Request) {
2131 user := s.oauth.GetUser(r)
2132 f, err := s.repoResolver.Resolve(r)
2133 if err != nil {
2134 log.Println("failed to resolve repo:", err)
2135 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
2136 return
2137 }
2138
2139 pull, ok := r.Context().Value("pull").(*models.Pull)
2140 if !ok {
2141 log.Println("failed to get pull")
2142 s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.")
2143 return
2144 }
2145
2146 var pullsToMerge models.Stack
2147 pullsToMerge = append(pullsToMerge, pull)
2148 if pull.IsStacked() {
2149 stack, ok := r.Context().Value("stack").(models.Stack)
2150 if !ok {
2151 log.Println("failed to get stack")
2152 s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.")
2153 return
2154 }
2155
2156 // combine patches of substack
2157 subStack := stack.StrictlyBelow(pull)
2158 // collect the portion of the stack that is mergeable
2159 mergeable := subStack.Mergeable()
2160 // add to total patch
2161 pullsToMerge = append(pullsToMerge, mergeable...)
2162 }
2163
2164 patch := pullsToMerge.CombinedPatch()
2165
2166 ident, err := s.idResolver.ResolveIdent(r.Context(), pull.OwnerDid)
2167 if err != nil {
2168 log.Printf("resolving identity: %s", err)
2169 w.WriteHeader(http.StatusNotFound)
2170 return
2171 }
2172
2173 email, err := db.GetPrimaryEmail(s.db, pull.OwnerDid)
2174 if err != nil {
2175 log.Printf("failed to get primary email: %s", err)
2176 }
2177
2178 authorName := ident.Handle.String()
2179 mergeInput := &tangled.RepoMerge_Input{
2180 Did: f.Did,
2181 Name: f.Name,
2182 Branch: pull.TargetBranch,
2183 Patch: patch,
2184 CommitMessage: &pull.Title,
2185 AuthorName: &authorName,
2186 }
2187
2188 if pull.Body != "" {
2189 mergeInput.CommitBody = &pull.Body
2190 }
2191
2192 if email.Address != "" {
2193 mergeInput.AuthorEmail = &email.Address
2194 }
2195
2196 client, err := s.oauth.ServiceClient(
2197 r,
2198 oauth.WithService(f.Knot),
2199 oauth.WithLxm(tangled.RepoMergeNSID),
2200 oauth.WithDev(s.config.Core.Dev),
2201 )
2202 if err != nil {
2203 log.Printf("failed to connect to knot server: %v", err)
2204 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
2205 return
2206 }
2207
2208 err = tangled.RepoMerge(r.Context(), client, mergeInput)
2209 if err := xrpcclient.HandleXrpcErr(err); err != nil {
2210 s.pages.Notice(w, "pull-merge-error", err.Error())
2211 return
2212 }
2213
2214 tx, err := s.db.Begin()
2215 if err != nil {
2216 log.Println("failed to start transcation", err)
2217 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
2218 return
2219 }
2220 defer tx.Rollback()
2221
2222 for _, p := range pullsToMerge {
2223 err := db.MergePull(tx, f.RepoAt(), p.PullId)
2224 if err != nil {
2225 log.Printf("failed to update pull request status in database: %s", err)
2226 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
2227 return
2228 }
2229 p.State = models.PullMerged
2230 }
2231
2232 err = tx.Commit()
2233 if err != nil {
2234 // TODO: this is unsound, we should also revert the merge from the knotserver here
2235 log.Printf("failed to update pull request status in database: %s", err)
2236 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
2237 return
2238 }
2239
2240 // notify about the pull merge
2241 for _, p := range pullsToMerge {
2242 s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
2243 }
2244
2245 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
2246 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2247}
2248
2249func (s *Pulls) ClosePull(w http.ResponseWriter, r *http.Request) {
2250 user := s.oauth.GetUser(r)
2251
2252 f, err := s.repoResolver.Resolve(r)
2253 if err != nil {
2254 log.Println("malformed middleware")
2255 return
2256 }
2257
2258 pull, ok := r.Context().Value("pull").(*models.Pull)
2259 if !ok {
2260 log.Println("failed to get pull")
2261 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
2262 return
2263 }
2264
2265 // auth filter: only owner or collaborators can close
2266 roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
2267 isOwner := roles.IsOwner()
2268 isCollaborator := roles.IsCollaborator()
2269 isPullAuthor := user.Did == pull.OwnerDid
2270 isCloseAllowed := isOwner || isCollaborator || isPullAuthor
2271 if !isCloseAllowed {
2272 log.Println("failed to close pull")
2273 s.pages.Notice(w, "pull-close", "You are unauthorized to close this pull.")
2274 return
2275 }
2276
2277 // Start a transaction
2278 tx, err := s.db.BeginTx(r.Context(), nil)
2279 if err != nil {
2280 log.Println("failed to start transaction", err)
2281 s.pages.Notice(w, "pull-close", "Failed to close pull.")
2282 return
2283 }
2284 defer tx.Rollback()
2285
2286 var pullsToClose []*models.Pull
2287 pullsToClose = append(pullsToClose, pull)
2288
2289 // if this PR is stacked, then we want to close all PRs below this one on the stack
2290 if pull.IsStacked() {
2291 stack := r.Context().Value("stack").(models.Stack)
2292 subStack := stack.StrictlyBelow(pull)
2293 pullsToClose = append(pullsToClose, subStack...)
2294 }
2295
2296 for _, p := range pullsToClose {
2297 // Close the pull in the database
2298 err = db.ClosePull(tx, f.RepoAt(), p.PullId)
2299 if err != nil {
2300 log.Println("failed to close pull", err)
2301 s.pages.Notice(w, "pull-close", "Failed to close pull.")
2302 return
2303 }
2304 p.State = models.PullClosed
2305 }
2306
2307 // Commit the transaction
2308 if err = tx.Commit(); err != nil {
2309 log.Println("failed to commit transaction", err)
2310 s.pages.Notice(w, "pull-close", "Failed to close pull.")
2311 return
2312 }
2313
2314 for _, p := range pullsToClose {
2315 s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
2316 }
2317
2318 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
2319 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2320}
2321
2322func (s *Pulls) ReopenPull(w http.ResponseWriter, r *http.Request) {
2323 user := s.oauth.GetUser(r)
2324
2325 f, err := s.repoResolver.Resolve(r)
2326 if err != nil {
2327 log.Println("failed to resolve repo", err)
2328 s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")
2329 return
2330 }
2331
2332 pull, ok := r.Context().Value("pull").(*models.Pull)
2333 if !ok {
2334 log.Println("failed to get pull")
2335 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
2336 return
2337 }
2338
2339 // auth filter: only owner or collaborators can close
2340 roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}
2341 isOwner := roles.IsOwner()
2342 isCollaborator := roles.IsCollaborator()
2343 isPullAuthor := user.Did == pull.OwnerDid
2344 isCloseAllowed := isOwner || isCollaborator || isPullAuthor
2345 if !isCloseAllowed {
2346 log.Println("failed to close pull")
2347 s.pages.Notice(w, "pull-close", "You are unauthorized to close this pull.")
2348 return
2349 }
2350
2351 // Start a transaction
2352 tx, err := s.db.BeginTx(r.Context(), nil)
2353 if err != nil {
2354 log.Println("failed to start transaction", err)
2355 s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")
2356 return
2357 }
2358 defer tx.Rollback()
2359
2360 var pullsToReopen []*models.Pull
2361 pullsToReopen = append(pullsToReopen, pull)
2362
2363 // if this PR is stacked, then we want to reopen all PRs above this one on the stack
2364 if pull.IsStacked() {
2365 stack := r.Context().Value("stack").(models.Stack)
2366 subStack := stack.StrictlyAbove(pull)
2367 pullsToReopen = append(pullsToReopen, subStack...)
2368 }
2369
2370 for _, p := range pullsToReopen {
2371 // Close the pull in the database
2372 err = db.ReopenPull(tx, f.RepoAt(), p.PullId)
2373 if err != nil {
2374 log.Println("failed to close pull", err)
2375 s.pages.Notice(w, "pull-close", "Failed to close pull.")
2376 return
2377 }
2378 p.State = models.PullOpen
2379 }
2380
2381 // Commit the transaction
2382 if err = tx.Commit(); err != nil {
2383 log.Println("failed to commit transaction", err)
2384 s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")
2385 return
2386 }
2387
2388 for _, p := range pullsToReopen {
2389 s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
2390 }
2391
2392 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
2393 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2394}
2395
2396func (s *Pulls) newStack(ctx context.Context, repo *models.Repo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {
2397 formatPatches, err := patchutil.ExtractPatches(patch)
2398 if err != nil {
2399 return nil, fmt.Errorf("Failed to extract patches: %v", err)
2400 }
2401
2402 // must have atleast 1 patch to begin with
2403 if len(formatPatches) == 0 {
2404 return nil, fmt.Errorf("No patches found in the generated format-patch.")
2405 }
2406
2407 // the stack is identified by a UUID
2408 var stack models.Stack
2409 parentChangeId := ""
2410 for _, fp := range formatPatches {
2411 // all patches must have a jj change-id
2412 changeId, err := fp.ChangeId()
2413 if err != nil {
2414 return nil, fmt.Errorf("Stacking is only supported if all patches contain a change-id commit header.")
2415 }
2416
2417 title := fp.Title
2418 body := fp.Body
2419 rkey := tid.TID()
2420
2421 mentions, references := s.mentionsResolver.Resolve(ctx, body)
2422
2423 initialSubmission := models.PullSubmission{
2424 Patch: fp.Raw,
2425 SourceRev: fp.SHA,
2426 Combined: fp.Raw,
2427 }
2428 pull := models.Pull{
2429 Title: title,
2430 Body: body,
2431 TargetBranch: targetBranch,
2432 OwnerDid: user.Did,
2433 RepoAt: repo.RepoAt(),
2434 Rkey: rkey,
2435 Mentions: mentions,
2436 References: references,
2437 Submissions: []*models.PullSubmission{
2438 &initialSubmission,
2439 },
2440 PullSource: pullSource,
2441 Created: time.Now(),
2442
2443 StackId: stackId,
2444 ChangeId: changeId,
2445 ParentChangeId: parentChangeId,
2446 }
2447
2448 stack = append(stack, &pull)
2449
2450 parentChangeId = changeId
2451 }
2452
2453 return stack, nil
2454}