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