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