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