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