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