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