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