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