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"
31 "tangled.org/core/appview/pages/repoinfo"
32 "tangled.org/core/appview/pagination"
33 "tangled.org/core/appview/reporesolver"
34 "tangled.org/core/appview/validator"
35 "tangled.org/core/appview/xrpcclient"
36 "tangled.org/core/idresolver"
37 "tangled.org/core/orm"
38 "tangled.org/core/patchutil"
39 "tangled.org/core/rbac"
40 "tangled.org/core/tid"
41 "tangled.org/core/types"
42
43 comatproto "github.com/bluesky-social/indigo/api/atproto"
44 "github.com/bluesky-social/indigo/atproto/syntax"
45 lexutil "github.com/bluesky-social/indigo/lex/util"
46 indigoxrpc "github.com/bluesky-social/indigo/xrpc"
47 "github.com/go-chi/chi/v5"
48 "github.com/google/uuid"
49)
50
51type Pulls struct {
52 oauth *oauth.OAuth
53 repoResolver *reporesolver.RepoResolver
54 pages *pages.Pages
55 idResolver *idresolver.Resolver
56 mentionsResolver *mentions.Resolver
57 db *db.DB
58 config *config.Config
59 notifier notify.Notifier
60 enforcer *rbac.Enforcer
61 logger *slog.Logger
62 validator *validator.Validator
63 indexer *pulls_indexer.Indexer
64}
65
66func New(
67 oauth *oauth.OAuth,
68 repoResolver *reporesolver.RepoResolver,
69 pages *pages.Pages,
70 resolver *idresolver.Resolver,
71 mentionsResolver *mentions.Resolver,
72 db *db.DB,
73 config *config.Config,
74 notifier notify.Notifier,
75 enforcer *rbac.Enforcer,
76 validator *validator.Validator,
77 indexer *pulls_indexer.Indexer,
78 logger *slog.Logger,
79) *Pulls {
80 return &Pulls{
81 oauth: oauth,
82 repoResolver: repoResolver,
83 pages: pages,
84 idResolver: resolver,
85 mentionsResolver: mentionsResolver,
86 db: db,
87 config: config,
88 notifier: notifier,
89 enforcer: enforcer,
90 logger: logger,
91 validator: validator,
92 indexer: indexer,
93 }
94}
95
96// htmx fragment
97func (s *Pulls) PullActions(w http.ResponseWriter, r *http.Request) {
98 switch r.Method {
99 case http.MethodGet:
100 user := s.oauth.GetMultiAccountUser(r)
101 f, err := s.repoResolver.Resolve(r)
102 if err != nil {
103 log.Println("failed to get repo and knot", err)
104 return
105 }
106
107 pull, ok := r.Context().Value("pull").(*models.Pull)
108 if !ok {
109 log.Println("failed to get pull")
110 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
111 return
112 }
113
114 // can be nil if this pull is not stacked
115 stack, _ := r.Context().Value("stack").(models.Stack)
116
117 roundNumberStr := chi.URLParam(r, "round")
118 roundNumber, err := strconv.Atoi(roundNumberStr)
119 if err != nil {
120 roundNumber = pull.LastRoundNumber()
121 }
122 if roundNumber >= len(pull.Submissions) {
123 http.Error(w, "bad round id", http.StatusBadRequest)
124 log.Println("failed to parse round id", err)
125 return
126 }
127
128 mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
129 branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
130 resubmitResult := pages.Unknown
131 if user.Active.Did == pull.OwnerDid {
132 resubmitResult = s.resubmitCheck(r, f, pull, stack)
133 }
134
135 s.pages.PullActionsFragment(w, pages.PullActionsParams{
136 LoggedInUser: user,
137 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
138 Pull: pull,
139 RoundNumber: roundNumber,
140 MergeCheck: mergeCheckResponse,
141 ResubmitCheck: resubmitResult,
142 BranchDeleteStatus: branchDeleteStatus,
143 Stack: stack,
144 })
145 return
146 }
147}
148
149func (s *Pulls) repoPullHelper(w http.ResponseWriter, r *http.Request, interdiff bool) {
150 user := s.oauth.GetMultiAccountUser(r)
151 f, err := s.repoResolver.Resolve(r)
152 if err != nil {
153 log.Println("failed to get repo and knot", err)
154 return
155 }
156
157 pull, ok := r.Context().Value("pull").(*models.Pull)
158 if !ok {
159 log.Println("failed to get pull")
160 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
161 return
162 }
163
164 backlinks, err := db.GetBacklinks(s.db, pull.AtUri())
165 if err != nil {
166 log.Println("failed to get pull backlinks", err)
167 s.pages.Notice(w, "pull-error", "Failed to get pull. Try again later.")
168 return
169 }
170
171 roundId := chi.URLParam(r, "round")
172 roundIdInt := pull.LastRoundNumber()
173 if r, err := strconv.Atoi(roundId); err == nil {
174 roundIdInt = r
175 }
176 if roundIdInt >= len(pull.Submissions) {
177 http.Error(w, "bad round id", http.StatusBadRequest)
178 log.Println("failed to parse round id", err)
179 return
180 }
181
182 var diffOpts types.DiffOpts
183 if d := r.URL.Query().Get("diff"); d == "split" {
184 diffOpts.Split = true
185 }
186
187 // can be nil if this pull is not stacked
188 stack, _ := r.Context().Value("stack").(models.Stack)
189 abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull)
190
191 mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
192 branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
193 resubmitResult := pages.Unknown
194 if user != nil && user.Active != nil && user.Active.Did == pull.OwnerDid {
195 resubmitResult = s.resubmitCheck(r, f, pull, stack)
196 }
197
198 m := make(map[string]models.Pipeline)
199
200 var shas []string
201 for _, s := range pull.Submissions {
202 shas = append(shas, s.SourceRev)
203 }
204 for _, p := range stack {
205 shas = append(shas, p.LatestSha())
206 }
207 for _, p := range abandonedPulls {
208 shas = append(shas, p.LatestSha())
209 }
210
211 ps, err := db.GetPipelineStatuses(
212 s.db,
213 len(shas),
214 orm.FilterEq("repo_owner", f.Did),
215 orm.FilterEq("repo_name", f.Name),
216 orm.FilterEq("knot", f.Knot),
217 orm.FilterIn("sha", shas),
218 )
219 if err != nil {
220 log.Printf("failed to fetch pipeline statuses: %s", err)
221 // non-fatal
222 }
223
224 for _, p := range ps {
225 m[p.Sha] = p
226 }
227
228 reactionMap, err := db.GetReactionMap(s.db, 20, pull.AtUri())
229 if err != nil {
230 log.Println("failed to get pull reactions")
231 s.pages.Notice(w, "pulls", "Failed to load pull. Try again later.")
232 }
233
234 userReactions := map[models.ReactionKind]bool{}
235 if user != nil {
236 userReactions = db.GetReactionStatusMap(s.db, user.Active.Did, pull.AtUri())
237 }
238
239 labelDefs, err := db.GetLabelDefinitions(
240 s.db,
241 orm.FilterIn("at_uri", f.Labels),
242 orm.FilterContains("scope", tangled.RepoPullNSID),
243 )
244 if err != nil {
245 log.Println("failed to fetch labels", err)
246 s.pages.Error503(w)
247 return
248 }
249
250 defs := make(map[string]*models.LabelDefinition)
251 for _, l := range labelDefs {
252 defs[l.AtUri().String()] = &l
253 }
254
255 patch := pull.Submissions[roundIdInt].CombinedPatch()
256 var diff types.DiffRenderer
257 diff = patchutil.AsNiceDiff(patch, pull.TargetBranch)
258
259 if interdiff {
260 currentPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt].CombinedPatch())
261 if err != nil {
262 log.Println("failed to interdiff; current patch malformed")
263 s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; current patch is invalid.")
264 return
265 }
266
267 previousPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt-1].CombinedPatch())
268 if err != nil {
269 log.Println("failed to interdiff; previous patch malformed")
270 s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; previous patch is invalid.")
271 return
272 }
273
274 diff = patchutil.Interdiff(previousPatch, currentPatch)
275 }
276
277 s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{
278 LoggedInUser: user,
279 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
280 Pull: pull,
281 Stack: stack,
282 AbandonedPulls: abandonedPulls,
283 Backlinks: backlinks,
284 BranchDeleteStatus: branchDeleteStatus,
285 MergeCheck: mergeCheckResponse,
286 ResubmitCheck: resubmitResult,
287 Pipelines: m,
288 Diff: diff,
289 DiffOpts: diffOpts,
290 ActiveRound: roundIdInt,
291 IsInterdiff: interdiff,
292
293 OrderedReactionKinds: models.OrderedReactionKinds,
294 Reactions: reactionMap,
295 UserReacted: userReactions,
296
297 LabelDefs: defs,
298 })
299}
300
301func (s *Pulls) RepoSinglePull(w http.ResponseWriter, r *http.Request) {
302 s.repoPullHelper(w, r, false)
303}
304
305func (s *Pulls) mergeCheck(r *http.Request, f *models.Repo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse {
306 if pull.State == models.PullMerged {
307 return types.MergeCheckResponse{}
308 }
309
310 scheme := "https"
311 if s.config.Core.Dev {
312 scheme = "http"
313 }
314 host := fmt.Sprintf("%s://%s", scheme, f.Knot)
315
316 xrpcc := indigoxrpc.Client{
317 Host: host,
318 }
319
320 patch := pull.LatestPatch()
321 if pull.IsStacked() {
322 // combine patches of substack
323 subStack := stack.Below(pull)
324 // collect the portion of the stack that is mergeable
325 mergeable := subStack.Mergeable()
326 // combine each patch
327 patch = mergeable.CombinedPatch()
328 }
329
330 resp, xe := tangled.RepoMergeCheck(
331 r.Context(),
332 &xrpcc,
333 &tangled.RepoMergeCheck_Input{
334 Did: f.Did,
335 Name: f.Name,
336 Branch: pull.TargetBranch,
337 Patch: patch,
338 },
339 )
340 if err := xrpcclient.HandleXrpcErr(xe); err != nil {
341 log.Println("failed to check for mergeability", "err", err)
342 return types.MergeCheckResponse{
343 Error: fmt.Sprintf("failed to check merge status: %s", err.Error()),
344 }
345 }
346
347 // convert xrpc response to internal types
348 conflicts := make([]types.ConflictInfo, len(resp.Conflicts))
349 for i, conflict := range resp.Conflicts {
350 conflicts[i] = types.ConflictInfo{
351 Filename: conflict.Filename,
352 Reason: conflict.Reason,
353 }
354 }
355
356 result := types.MergeCheckResponse{
357 IsConflicted: resp.Is_conflicted,
358 Conflicts: conflicts,
359 }
360
361 if resp.Message != nil {
362 result.Message = *resp.Message
363 }
364
365 if resp.Error != nil {
366 result.Error = *resp.Error
367 }
368
369 return result
370}
371
372func (s *Pulls) branchDeleteStatus(r *http.Request, repo *models.Repo, pull *models.Pull) *models.BranchDeleteStatus {
373 if pull.State != models.PullMerged {
374 return nil
375 }
376
377 user := s.oauth.GetMultiAccountUser(r)
378 if user == nil {
379 return nil
380 }
381
382 var branch string
383 // check if the branch exists
384 // NOTE: appview could cache branches/tags etc. for every repo by listening for gitRefUpdates
385 if pull.IsBranchBased() {
386 branch = pull.PullSource.Branch
387 } else if pull.IsForkBased() {
388 branch = pull.PullSource.Branch
389 repo = pull.PullSource.Repo
390 } else {
391 return nil
392 }
393
394 // deleted fork
395 if repo == nil {
396 return nil
397 }
398
399 // user can only delete branch if they are a collaborator in the repo that the branch belongs to
400 perms := s.enforcer.GetPermissionsInRepo(user.Active.Did, repo.Knot, repo.DidSlashRepo())
401 if !slices.Contains(perms, "repo:push") {
402 return nil
403 }
404
405 scheme := "http"
406 if !s.config.Core.Dev {
407 scheme = "https"
408 }
409 host := fmt.Sprintf("%s://%s", scheme, repo.Knot)
410 xrpcc := &indigoxrpc.Client{
411 Host: host,
412 }
413
414 resp, err := tangled.RepoBranch(r.Context(), xrpcc, branch, fmt.Sprintf("%s/%s", repo.Did, repo.Name))
415 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
416 return nil
417 }
418
419 return &models.BranchDeleteStatus{
420 Repo: repo,
421 Branch: resp.Name,
422 }
423}
424
425func (s *Pulls) resubmitCheck(r *http.Request, repo *models.Repo, pull *models.Pull, stack models.Stack) pages.ResubmitResult {
426 if pull.State == models.PullMerged || pull.State == models.PullDeleted || pull.PullSource == nil {
427 return pages.Unknown
428 }
429
430 var knot, ownerDid, repoName string
431
432 if pull.PullSource.RepoAt != nil {
433 // fork-based pulls
434 sourceRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())
435 if err != nil {
436 log.Println("failed to get source repo", err)
437 return pages.Unknown
438 }
439
440 knot = sourceRepo.Knot
441 ownerDid = sourceRepo.Did
442 repoName = sourceRepo.Name
443 } else {
444 // pulls within the same repo
445 knot = repo.Knot
446 ownerDid = repo.Did
447 repoName = repo.Name
448 }
449
450 scheme := "http"
451 if !s.config.Core.Dev {
452 scheme = "https"
453 }
454 host := fmt.Sprintf("%s://%s", scheme, knot)
455 xrpcc := &indigoxrpc.Client{
456 Host: host,
457 }
458
459 didSlashName := fmt.Sprintf("%s/%s", ownerDid, repoName)
460 branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, didSlashName)
461 if err != nil {
462 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
463 log.Println("failed to call XRPC repo.branches", xrpcerr)
464 return pages.Unknown
465 }
466 log.Println("failed to reach knotserver", err)
467 return pages.Unknown
468 }
469
470 targetBranch := branchResp
471
472 latestSourceRev := pull.LatestSha()
473
474 if pull.IsStacked() && stack != nil {
475 top := stack[0]
476 latestSourceRev = top.LatestSha()
477 }
478
479 if latestSourceRev != targetBranch.Hash {
480 return pages.ShouldResubmit
481 }
482
483 return pages.ShouldNotResubmit
484}
485
486func (s *Pulls) RepoPullPatch(w http.ResponseWriter, r *http.Request) {
487 s.repoPullHelper(w, r, false)
488}
489
490func (s *Pulls) RepoPullInterdiff(w http.ResponseWriter, r *http.Request) {
491 s.repoPullHelper(w, r, true)
492}
493
494func (s *Pulls) RepoPullPatchRaw(w http.ResponseWriter, r *http.Request) {
495 pull, ok := r.Context().Value("pull").(*models.Pull)
496 if !ok {
497 log.Println("failed to get pull")
498 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
499 return
500 }
501
502 roundId := chi.URLParam(r, "round")
503 roundIdInt, err := strconv.Atoi(roundId)
504 if err != nil || roundIdInt >= len(pull.Submissions) {
505 http.Error(w, "bad round id", http.StatusBadRequest)
506 log.Println("failed to parse round id", err)
507 return
508 }
509
510 w.Header().Set("Content-Type", "text/plain; charset=utf-8")
511 w.Write([]byte(pull.Submissions[roundIdInt].Patch))
512}
513
514func (s *Pulls) RepoPulls(w http.ResponseWriter, r *http.Request) {
515 l := s.logger.With("handler", "RepoPulls")
516
517 user := s.oauth.GetMultiAccountUser(r)
518 params := r.URL.Query()
519
520 state := models.PullOpen
521 switch params.Get("state") {
522 case "closed":
523 state = models.PullClosed
524 case "merged":
525 state = models.PullMerged
526 }
527
528 page := pagination.FromContext(r.Context())
529
530 f, err := s.repoResolver.Resolve(r)
531 if err != nil {
532 log.Println("failed to get repo and knot", err)
533 return
534 }
535
536 var totalPulls int
537 switch state {
538 case models.PullOpen:
539 totalPulls = f.RepoStats.PullCount.Open
540 case models.PullMerged:
541 totalPulls = f.RepoStats.PullCount.Merged
542 case models.PullClosed:
543 totalPulls = f.RepoStats.PullCount.Closed
544 }
545
546 keyword := params.Get("q")
547
548 var pulls []*models.Pull
549 searchOpts := models.PullSearchOptions{
550 Keyword: keyword,
551 RepoAt: f.RepoAt().String(),
552 State: state,
553 Page: page,
554 }
555 l.Debug("searching with", "searchOpts", searchOpts)
556 if keyword != "" {
557 res, err := s.indexer.Search(r.Context(), searchOpts)
558 if err != nil {
559 l.Error("failed to search for pulls", "err", err)
560 return
561 }
562 totalPulls = int(res.Total)
563 l.Debug("searched pulls with indexer", "count", len(res.Hits))
564
565 pulls, err = db.GetPulls(
566 s.db,
567 orm.FilterIn("id", res.Hits),
568 )
569 if err != nil {
570 log.Println("failed to get pulls", err)
571 s.pages.Notice(w, "pulls", "Failed to load pulls. Try again later.")
572 return
573 }
574 } else {
575 pulls, err = db.GetPullsPaginated(
576 s.db,
577 page,
578 orm.FilterEq("repo_at", f.RepoAt()),
579 orm.FilterEq("state", searchOpts.State),
580 )
581 if err != nil {
582 log.Println("failed to get pulls", err)
583 s.pages.Notice(w, "pulls", "Failed to load pulls. Try again later.")
584 return
585 }
586 }
587
588 for _, p := range pulls {
589 var pullSourceRepo *models.Repo
590 if p.PullSource != nil {
591 if p.PullSource.RepoAt != nil {
592 pullSourceRepo, err = db.GetRepoByAtUri(s.db, p.PullSource.RepoAt.String())
593 if err != nil {
594 log.Printf("failed to get repo by at uri: %v", err)
595 continue
596 } else {
597 p.PullSource.Repo = pullSourceRepo
598 }
599 }
600 }
601 }
602
603 // we want to group all stacked PRs into just one list
604 stacks := make(map[string]models.Stack)
605 var shas []string
606 n := 0
607 for _, p := range pulls {
608 // store the sha for later
609 shas = append(shas, p.LatestSha())
610 // this PR is stacked
611 if p.StackId != "" {
612 // we have already seen this PR stack
613 if _, seen := stacks[p.StackId]; seen {
614 stacks[p.StackId] = append(stacks[p.StackId], p)
615 // skip this PR
616 } else {
617 stacks[p.StackId] = nil
618 pulls[n] = p
619 n++
620 }
621 } else {
622 pulls[n] = p
623 n++
624 }
625 }
626 pulls = pulls[:n]
627
628 ps, err := db.GetPipelineStatuses(
629 s.db,
630 len(shas),
631 orm.FilterEq("repo_owner", f.Did),
632 orm.FilterEq("repo_name", f.Name),
633 orm.FilterEq("knot", f.Knot),
634 orm.FilterIn("sha", shas),
635 )
636 if err != nil {
637 log.Printf("failed to fetch pipeline statuses: %s", err)
638 // non-fatal
639 }
640 m := make(map[string]models.Pipeline)
641 for _, p := range ps {
642 m[p.Sha] = p
643 }
644
645 labelDefs, err := db.GetLabelDefinitions(
646 s.db,
647 orm.FilterIn("at_uri", f.Labels),
648 orm.FilterContains("scope", tangled.RepoPullNSID),
649 )
650 if err != nil {
651 log.Println("failed to fetch labels", err)
652 s.pages.Error503(w)
653 return
654 }
655
656 defs := make(map[string]*models.LabelDefinition)
657 for _, l := range labelDefs {
658 defs[l.AtUri().String()] = &l
659 }
660
661 s.pages.RepoPulls(w, pages.RepoPullsParams{
662 LoggedInUser: s.oauth.GetMultiAccountUser(r),
663 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
664 Pulls: pulls,
665 LabelDefs: defs,
666 FilteringBy: state,
667 FilterQuery: keyword,
668 Stacks: stacks,
669 Pipelines: m,
670 Page: page,
671 PullCount: totalPulls,
672 })
673}
674
675func (s *Pulls) PullComment(w http.ResponseWriter, r *http.Request) {
676 user := s.oauth.GetMultiAccountUser(r)
677 f, err := s.repoResolver.Resolve(r)
678 if err != nil {
679 log.Println("failed to get repo and knot", err)
680 return
681 }
682
683 pull, ok := r.Context().Value("pull").(*models.Pull)
684 if !ok {
685 log.Println("failed to get pull")
686 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
687 return
688 }
689
690 roundNumberStr := chi.URLParam(r, "round")
691 roundNumber, err := strconv.Atoi(roundNumberStr)
692 if err != nil || roundNumber >= len(pull.Submissions) {
693 http.Error(w, "bad round id", http.StatusBadRequest)
694 log.Println("failed to parse round id", err)
695 return
696 }
697
698 switch r.Method {
699 case http.MethodGet:
700 s.pages.PullNewCommentFragment(w, pages.PullNewCommentParams{
701 LoggedInUser: user,
702 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
703 Pull: pull,
704 RoundNumber: roundNumber,
705 })
706 return
707 case http.MethodPost:
708 body := r.FormValue("body")
709 if body == "" {
710 s.pages.Notice(w, "pull", "Comment body is required")
711 return
712 }
713
714 mentions, references := s.mentionsResolver.Resolve(r.Context(), body)
715
716 // Start a transaction
717 tx, err := s.db.BeginTx(r.Context(), nil)
718 if err != nil {
719 log.Println("failed to start transaction", err)
720 s.pages.Notice(w, "pull-comment", "Failed to create comment.")
721 return
722 }
723 defer tx.Rollback()
724
725 createdAt := time.Now().Format(time.RFC3339)
726
727 client, err := s.oauth.AuthorizedClient(r)
728 if err != nil {
729 log.Println("failed to get authorized client", err)
730 s.pages.Notice(w, "pull-comment", "Failed to create comment.")
731 return
732 }
733 atResp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
734 Collection: tangled.RepoPullCommentNSID,
735 Repo: user.Active.Did,
736 Rkey: tid.TID(),
737 Record: &lexutil.LexiconTypeDecoder{
738 Val: &tangled.RepoPullComment{
739 Pull: pull.AtUri().String(),
740 Body: body,
741 CreatedAt: createdAt,
742 },
743 },
744 })
745 if err != nil {
746 log.Println("failed to create pull comment", err)
747 s.pages.Notice(w, "pull-comment", "Failed to create comment.")
748 return
749 }
750
751 comment := &models.PullComment{
752 OwnerDid: user.Active.Did,
753 RepoAt: f.RepoAt().String(),
754 PullId: pull.PullId,
755 Body: body,
756 CommentAt: atResp.Uri,
757 SubmissionId: pull.Submissions[roundNumber].ID,
758 Mentions: mentions,
759 References: references,
760 }
761
762 // Create the pull comment in the database with the commentAt field
763 commentId, err := db.NewPullComment(tx, comment)
764 if err != nil {
765 log.Println("failed to create pull comment", err)
766 s.pages.Notice(w, "pull-comment", "Failed to create comment.")
767 return
768 }
769
770 // Commit the transaction
771 if err = tx.Commit(); err != nil {
772 log.Println("failed to commit transaction", err)
773 s.pages.Notice(w, "pull-comment", "Failed to create comment.")
774 return
775 }
776
777 s.notifier.NewPullComment(r.Context(), comment, mentions)
778
779 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
780 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId))
781 return
782 }
783}
784
785func (s *Pulls) NewPull(w http.ResponseWriter, r *http.Request) {
786 user := s.oauth.GetMultiAccountUser(r)
787 f, err := s.repoResolver.Resolve(r)
788 if err != nil {
789 log.Println("failed to get repo and knot", err)
790 return
791 }
792
793 switch r.Method {
794 case http.MethodGet:
795 scheme := "http"
796 if !s.config.Core.Dev {
797 scheme = "https"
798 }
799 host := fmt.Sprintf("%s://%s", scheme, f.Knot)
800 xrpcc := &indigoxrpc.Client{
801 Host: host,
802 }
803
804 repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
805 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
806 if err != nil {
807 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
808 log.Println("failed to call XRPC repo.branches", xrpcerr)
809 s.pages.Error503(w)
810 return
811 }
812 log.Println("failed to fetch branches", err)
813 return
814 }
815
816 var result types.RepoBranchesResponse
817 if err := json.Unmarshal(xrpcBytes, &result); err != nil {
818 log.Println("failed to decode XRPC response", err)
819 s.pages.Error503(w)
820 return
821 }
822
823 // can be one of "patch", "branch" or "fork"
824 strategy := r.URL.Query().Get("strategy")
825 // ignored if strategy is "patch"
826 sourceBranch := r.URL.Query().Get("sourceBranch")
827 targetBranch := r.URL.Query().Get("targetBranch")
828
829 s.pages.RepoNewPull(w, pages.RepoNewPullParams{
830 LoggedInUser: user,
831 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
832 Branches: result.Branches,
833 Strategy: strategy,
834 SourceBranch: sourceBranch,
835 TargetBranch: targetBranch,
836 Title: r.URL.Query().Get("title"),
837 Body: r.URL.Query().Get("body"),
838 })
839
840 case http.MethodPost:
841 title := r.FormValue("title")
842 body := r.FormValue("body")
843 targetBranch := r.FormValue("targetBranch")
844 fromFork := r.FormValue("fork")
845 sourceBranch := r.FormValue("sourceBranch")
846 patch := r.FormValue("patch")
847
848 if targetBranch == "" {
849 s.pages.Notice(w, "pull", "Target branch is required.")
850 return
851 }
852
853 // Determine PR type based on input parameters
854 roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
855 isPushAllowed := roles.IsPushAllowed()
856 isBranchBased := isPushAllowed && sourceBranch != "" && fromFork == ""
857 isForkBased := fromFork != "" && sourceBranch != ""
858 isPatchBased := patch != "" && !isBranchBased && !isForkBased
859 isStacked := r.FormValue("isStacked") == "on"
860
861 if isPatchBased && !patchutil.IsFormatPatch(patch) {
862 if title == "" {
863 s.pages.Notice(w, "pull", "Title is required for git-diff patches.")
864 return
865 }
866 sanitizer := markup.NewSanitizer()
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 := s.validator.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 := s.validator.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 := s.validator.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 := s.validator.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 := s.validator.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}