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