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