alice.pds.demo.boltless.dev
This repository has no description
1package pulls
2
3import (
4 "encoding/json"
5 "fmt"
6 "net/http"
7 "time"
8
9 "tangled.org/core/api/tangled"
10 "tangled.org/core/appview/db"
11 "tangled.org/core/appview/models"
12 "tangled.org/core/appview/oauth"
13 "tangled.org/core/appview/pages"
14 "tangled.org/core/appview/pages/repoinfo"
15 "tangled.org/core/appview/reporesolver"
16 "tangled.org/core/appview/xrpcclient"
17 "tangled.org/core/orm"
18 "tangled.org/core/patchutil"
19 "tangled.org/core/types"
20 "tangled.org/core/xrpc"
21
22 comatproto "github.com/bluesky-social/indigo/api/atproto"
23 "github.com/bluesky-social/indigo/atproto/syntax"
24 lexutil "github.com/bluesky-social/indigo/lex/util"
25)
26
27func (s *Pulls) ResubmitPull(w http.ResponseWriter, r *http.Request) {
28 l := s.logger.With("handler", "ResubmitPull")
29
30 user := s.oauth.GetMultiAccountUser(r)
31 if user != nil {
32 l = l.With("user", user.Did)
33 }
34
35 pull, ok := r.Context().Value("pull").(*models.Pull)
36 if !ok {
37 l.Error("failed to get pull")
38 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
39 return
40 }
41 l = l.With("pull_id", pull.PullId, "pull_owner", pull.OwnerDid)
42
43 switch r.Method {
44 case http.MethodGet:
45 s.pages.PullResubmitFragment(w, pages.PullResubmitParams{
46 RepoInfo: s.repoResolver.GetRepoInfo(r, user),
47 Pull: pull,
48 })
49 return
50 case http.MethodPost:
51 if pull.IsPatchBased() {
52 s.resubmitPatch(w, r)
53 return
54 } else if pull.IsBranchBased() {
55 s.resubmitBranch(w, r)
56 return
57 } else if pull.IsForkBased() {
58 s.resubmitFork(w, r)
59 return
60 }
61 }
62}
63
64func (s *Pulls) resubmitPatch(w http.ResponseWriter, r *http.Request) {
65 l := s.logger.With("handler", "resubmitPatch")
66
67 user := s.oauth.GetMultiAccountUser(r)
68 if user != nil {
69 l = l.With("user", user.Did)
70 }
71
72 pull, ok := r.Context().Value("pull").(*models.Pull)
73 if !ok {
74 l.Error("failed to get pull")
75 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
76 return
77 }
78 l = l.With("pull_id", pull.PullId, "pull_owner", pull.OwnerDid)
79
80 if user == nil || user.Did != pull.OwnerDid {
81 l.Warn("unauthorized user", "actual_user", user.Did, "expected_owner", pull.OwnerDid)
82 w.WriteHeader(http.StatusUnauthorized)
83 return
84 }
85
86 f, err := s.repoResolver.Resolve(r)
87 if err != nil {
88 l.Error("failed to get repo and knot", "err", err)
89 return
90 }
91
92 patch := r.FormValue("patch")
93
94 s.resubmitPullHelper(w, r, f, syntax.DID(user.Did), pull, patch, "", "")
95}
96
97func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {
98 l := s.logger.With("handler", "resubmitBranch")
99
100 user := s.oauth.GetMultiAccountUser(r)
101 if user != nil {
102 l = l.With("user", user.Did)
103 }
104
105 pull, ok := r.Context().Value("pull").(*models.Pull)
106 if !ok {
107 l.Error("failed to get pull")
108 s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.")
109 return
110 }
111 l = l.With("pull_id", pull.PullId, "pull_owner", pull.OwnerDid, "target_branch", pull.TargetBranch)
112
113 if user == nil || user.Did != pull.OwnerDid {
114 l.Warn("unauthorized user", "actual_user", user.Did, "expected_owner", pull.OwnerDid)
115 w.WriteHeader(http.StatusUnauthorized)
116 return
117 }
118
119 f, err := s.repoResolver.Resolve(r)
120 if err != nil {
121 l.Error("failed to get repo and knot", "err", err)
122 return
123 }
124
125 roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.RepoIdentifier())}
126 if !roles.IsPushAllowed() {
127 l.Warn("unauthorized user - no push permission")
128 w.WriteHeader(http.StatusUnauthorized)
129 return
130 }
131
132 xrpcc := s.knotClient(f.Knot)
133
134 xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, f.RepoIdentifier(), pull.TargetBranch, pull.PullSource.Branch)
135 if err != nil {
136 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
137 l.Error("failed to call XRPC repo.compare", "xrpcerr", xrpcerr, "err", err, "source_branch", pull.PullSource.Branch)
138 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
139 return
140 }
141 l.Error("compare request failed", "err", err, "source_branch", pull.PullSource.Branch)
142 s.pages.Notice(w, "resubmit-error", err.Error())
143 return
144 }
145
146 var comparison types.RepoFormatPatchResponse
147 if err := json.Unmarshal(xrpcBytes, &comparison); err != nil {
148 l.Error("failed to decode XRPC compare response", "err", err)
149 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
150 return
151 }
152
153 sourceRev := comparison.Rev2
154 patch := comparison.FormatPatchRaw
155 combined := comparison.CombinedPatchRaw
156
157 s.resubmitPullHelper(w, r, f, syntax.DID(user.Did), pull, patch, combined, sourceRev)
158}
159
160func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {
161 l := s.logger.With("handler", "resubmitFork")
162
163 user := s.oauth.GetMultiAccountUser(r)
164 if user != nil {
165 l = l.With("user", user.Did)
166 }
167
168 pull, ok := r.Context().Value("pull").(*models.Pull)
169 if !ok {
170 l.Error("failed to get pull")
171 s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.")
172 return
173 }
174 l = l.With("pull_id", pull.PullId, "pull_owner", pull.OwnerDid, "target_branch", pull.TargetBranch)
175
176 if user == nil || user.Did != pull.OwnerDid {
177 l.Warn("unauthorized user", "actual_user", user.Did, "expected_owner", pull.OwnerDid)
178 w.WriteHeader(http.StatusUnauthorized)
179 return
180 }
181
182 f, err := s.repoResolver.Resolve(r)
183 if err != nil {
184 l.Error("failed to get repo and knot", "err", err)
185 return
186 }
187
188 forkRepo, err := db.GetRepoByDid(s.db, string(*pull.PullSource.RepoDid))
189 if err != nil {
190 l.Error("failed to get source repo", "err", err, "repo_did", pull.PullSource.RepoDid.String())
191 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
192 return
193 }
194
195 // update the hidden tracking branch to latest
196 client, err := s.oauth.ServiceClient(
197 r,
198 oauth.WithService(forkRepo.Knot),
199 oauth.WithLxm(tangled.RepoHiddenRefNSID),
200 oauth.WithDev(s.config.Core.Dev),
201 )
202 if err != nil {
203 l.Error("failed to connect to knot server", "err", err, "fork_knot", forkRepo.Knot)
204 return
205 }
206
207 resp, err := tangled.RepoHiddenRef(
208 r.Context(),
209 client,
210 &tangled.RepoHiddenRef_Input{
211 ForkRef: pull.PullSource.Branch,
212 RemoteRef: pull.TargetBranch,
213 Repo: forkRepo.RepoAt().String(),
214 },
215 )
216 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
217 s.logger.Error("failed to set hidden ref", "xrpcerr", xrpcerr, "err", err)
218 s.pages.Notice(w, "resubmit-error", xrpcerr.Error())
219 return
220 }
221 if !resp.Success {
222 l.Error("failed to update tracking ref", "err", resp.Error, "fork_ref", pull.PullSource.Branch, "remote_ref", pull.TargetBranch)
223 s.pages.Notice(w, "resubmit-error", "Failed to update tracking ref.")
224 return
225 }
226
227 hiddenRef := fmt.Sprintf("hidden/%s/%s", pull.PullSource.Branch, pull.TargetBranch)
228 // extract patch by performing compare
229 forkXrpcBytes, err := tangled.RepoCompare(r.Context(), s.knotClient(forkRepo.Knot), forkRepo.RepoIdentifier(), hiddenRef, pull.PullSource.Branch)
230 if err != nil {
231 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
232 l.Error("failed to call XRPC repo.compare for fork", "xrpcerr", xrpcerr, "err", err, "hidden_ref", hiddenRef, "source_branch", pull.PullSource.Branch)
233 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
234 return
235 }
236 l.Error("failed to compare branches", "err", err, "hidden_ref", hiddenRef, "source_branch", pull.PullSource.Branch)
237 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
238 return
239 }
240
241 var forkComparison types.RepoFormatPatchResponse
242 if err := json.Unmarshal(forkXrpcBytes, &forkComparison); err != nil {
243 l.Error("failed to decode XRPC compare response for fork", "err", err)
244 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
245 return
246 }
247
248 // Use the fork comparison we already made
249 comparison := forkComparison
250
251 sourceRev := comparison.Rev2
252 patch := comparison.FormatPatchRaw
253 combined := comparison.CombinedPatchRaw
254
255 s.resubmitPullHelper(w, r, f, syntax.DID(user.Did), pull, patch, combined, sourceRev)
256}
257
258func (s *Pulls) resubmitPullHelper(
259 w http.ResponseWriter,
260 r *http.Request,
261 repo *models.Repo,
262 userDid syntax.DID,
263 pull *models.Pull,
264 patch string,
265 combined string,
266 sourceRev string,
267) {
268 l := s.logger.With("handler", "resubmitPullHelper", "user", userDid, "pull_id", pull.PullId, "target_branch", pull.TargetBranch)
269
270 stack := r.Context().Value("stack").(models.Stack)
271 if stack != nil && len(stack) != 1 {
272 l.Info("resubmitting stacked PR", "stack_size", len(stack))
273 s.resubmitStackedPullHelper(w, r, repo, userDid, pull, patch)
274 return
275 }
276
277 if err := s.validator.ValidatePatch(&patch); err != nil {
278 s.pages.Notice(w, "resubmit-error", err.Error())
279 return
280 }
281
282 if patch == pull.LatestPatch() {
283 s.pages.Notice(w, "resubmit-error", "Patch is identical to previous submission.")
284 return
285 }
286
287 // validate sourceRev if branch/fork based
288 if pull.IsBranchBased() || pull.IsForkBased() {
289 if sourceRev == pull.LatestSha() {
290 s.pages.Notice(w, "resubmit-error", "This branch has not changed since the last submission.")
291 return
292 }
293 }
294
295 pullAt := pull.AtUri()
296 newRoundNumber := len(pull.Submissions)
297 newPatch := patch
298 newSourceRev := sourceRev
299 combinedPatch := combined
300
301 client, err := s.oauth.AuthorizedClient(r)
302 if err != nil {
303 l.Error("failed to authorize client", "err", err)
304 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
305 return
306 }
307
308 ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, userDid.String(), pull.Rkey)
309 if err != nil {
310 // failed to get record
311 l.Error("failed to get record from PDS", "err", err, "rkey", pull.Rkey)
312 s.pages.Notice(w, "resubmit-error", "Failed to update pull, no record found on PDS.")
313 return
314 }
315
316 blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip)
317 if err != nil {
318 l.Error("failed to upload patch blob", "err", err)
319 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
320 return
321 }
322 record := pull.AsRecord()
323 record.Rounds = append(record.Rounds, &tangled.RepoPull_Round{
324 CreatedAt: time.Now().Format(time.RFC3339),
325 PatchBlob: blob.Blob,
326 })
327
328 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
329 Collection: tangled.RepoPullNSID,
330 Repo: userDid.String(),
331 Rkey: pull.Rkey,
332 SwapRecord: ex.Cid,
333 Record: &lexutil.LexiconTypeDecoder{
334 Val: &record,
335 },
336 })
337 if err != nil {
338 l.Error("failed to update record on PDS", "err", err, "rkey", pull.Rkey)
339 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
340 return
341 }
342
343 err = db.ResubmitPull(s.db, pullAt, newRoundNumber, newPatch, combinedPatch, newSourceRev, blob.Blob)
344 if err != nil {
345 l.Error("failed to resubmit pull request in database", "err", err, "round_number", newRoundNumber)
346 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
347 return
348 }
349
350 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)
351 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
352}
353
354func (s *Pulls) resubmitStackedPullHelper(
355 w http.ResponseWriter,
356 r *http.Request,
357 repo *models.Repo,
358 userDid syntax.DID,
359 pull *models.Pull,
360 patch string,
361) {
362 l := s.logger.With("handler", "resubmitStackedPullHelper", "user", userDid, "pull_id", pull.PullId, "target_branch", pull.TargetBranch)
363
364 targetBranch := pull.TargetBranch
365
366 origStack, _ := r.Context().Value("stack").(models.Stack)
367
368 formatPatches, err := patchutil.ExtractPatches(patch)
369 if err != nil {
370 l.Error("failed to extract patches", "err", err)
371 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Failed to parse patches.")
372 return
373 }
374
375 // must have atleast 1 patch to begin with
376 if len(formatPatches) == 0 {
377 l.Error("no patches found in the generated format-patch")
378 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request: No patches found in the generated patch.")
379 return
380 }
381
382 client, err := s.oauth.AuthorizedClient(r)
383 if err != nil {
384 l.Error("failed to get authorized client", "err", err)
385 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
386 return
387 }
388
389 // first upload all blobs
390 blobs := make([]*lexutil.LexBlob, len(formatPatches))
391 for i, p := range formatPatches {
392 blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(p.Raw), ApplicationGzip)
393 if err != nil {
394 l.Error("failed to upload patch blob", "err", err, "patch_index", i)
395 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
396 return
397 }
398 l.Info("uploaded blob", "idx", i+1, "total", len(formatPatches))
399 blobs[i] = blob.Blob
400 }
401
402 newStack, err := s.newStack(r.Context(), repo, userDid, targetBranch, pull.PullSource, formatPatches, blobs, nil, nil)
403 if err != nil {
404 l.Error("failed to create resubmitted stack", "err", err)
405 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
406 return
407 }
408
409 // find the diff between the stacks, first, map them by changeId
410 origById := make(map[string]*models.Pull)
411 newById := make(map[string]*models.Pull)
412 for _, p := range origStack {
413 origById[p.LatestSubmission().ChangeId()] = p
414 }
415 for _, p := range newStack {
416 newById[p.LatestSubmission().ChangeId()] = p
417 }
418
419 // commits that got deleted: corresponding pull is closed
420 // commits that got added: new pull is created
421 // commits that got updated: corresponding pull is resubmitted & new round begins
422 additions := make(map[string]*models.Pull)
423 deletions := make(map[string]*models.Pull)
424 updated := make(map[string]struct{})
425
426 // pulls in original stack but not in new one
427 for _, op := range origStack {
428 if _, ok := newById[op.LatestSubmission().ChangeId()]; !ok {
429 deletions[op.LatestSubmission().ChangeId()] = op
430 }
431 }
432
433 // pulls in new stack but not in original one
434 for _, np := range newStack {
435 if _, ok := origById[np.LatestSubmission().ChangeId()]; !ok {
436 additions[np.LatestSubmission().ChangeId()] = np
437 }
438 }
439
440 // NOTE: this loop can be written in any of above blocks,
441 // but is written separately in the interest of simpler code
442 for _, np := range newStack {
443 if op, ok := origById[np.LatestSubmission().ChangeId()]; ok {
444 // pull exists in both stacks
445 updated[op.LatestSubmission().ChangeId()] = struct{}{}
446 }
447 }
448
449 // NOTE: we can go through the newStack and update dependent relations and
450 // rkeys now that we know which ones have been updated
451 // update dependentOn relations for the entire stack
452 var parentAt *syntax.ATURI
453 for _, np := range newStack {
454 if op, ok := origById[np.LatestSubmission().ChangeId()]; ok {
455 // pull exists in both stacks
456 np.Rkey = op.Rkey
457 }
458 np.DependentOn = parentAt
459 x := np.AtUri()
460 parentAt = &x
461 }
462
463 l = l.With("additions", len(additions), "deletions", len(deletions), "updates", len(updated))
464
465 tx, err := s.db.Begin()
466 if err != nil {
467 l.Error("failed to start transaction", "err", err)
468 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
469 return
470 }
471 defer tx.Rollback()
472
473 // pds updates to make
474 var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem
475
476 // deleted pulls are marked as deleted in the DB
477 for _, p := range deletions {
478 // do not do delete already merged PRs
479 if p.State == models.PullMerged {
480 continue
481 }
482
483 err := db.AbandonPulls(tx, orm.FilterEq("repo_did", string(p.RepoDid)), orm.FilterEq("at_uri", p.AtUri()))
484 if err != nil {
485 l.Error("failed to delete pull", "err", err, "pull_id", p.PullId)
486 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
487 return
488 }
489 writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
490 RepoApplyWrites_Delete: &comatproto.RepoApplyWrites_Delete{
491 Collection: tangled.RepoPullNSID,
492 Rkey: p.Rkey,
493 },
494 })
495 }
496
497 // new pulls are created
498 for _, p := range additions {
499 blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(p.LatestPatch()), ApplicationGzip)
500 if err != nil {
501 l.Error("failed to upload patch blob for new pull", "err", err, "change_id", p.LatestSubmission().ChangeId())
502 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
503 return
504 }
505 p.Submissions[0].Blob = *blob.Blob
506
507 if err = db.PutPull(tx, p); err != nil {
508 l.Error("failed to create pull", "err", err, "pull_id", p.PullId, "change_id", p.LatestSubmission().ChangeId())
509 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
510 return
511 }
512
513 record := p.AsRecord()
514 record.Rounds = []*tangled.RepoPull_Round{
515 {
516 CreatedAt: time.Now().Format(time.RFC3339),
517 PatchBlob: blob.Blob,
518 },
519 }
520 writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
521 RepoApplyWrites_Create: &comatproto.RepoApplyWrites_Create{
522 Collection: tangled.RepoPullNSID,
523 Rkey: &p.Rkey,
524 Value: &lexutil.LexiconTypeDecoder{
525 Val: &record,
526 },
527 },
528 })
529 }
530
531 // updated pulls are, well, updated; to start a new round
532 for id := range updated {
533 op, _ := origById[id]
534 np, _ := newById[id]
535
536 // do not update already merged PRs
537 if op.State == models.PullMerged {
538 continue
539 }
540
541 // resubmit the new pull
542 np.Rkey = op.Rkey
543 pullAt := op.AtUri()
544 newRoundNumber := len(op.Submissions)
545 newPatch := np.LatestPatch()
546 combinedPatch := np.LatestSubmission().Combined
547 newSourceRev := np.LatestSha()
548
549 blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(newPatch), ApplicationGzip)
550 if err != nil {
551 l.Error("failed to upload patch blob for update", "err", err, "change_id", id, "pull_id", op.PullId)
552 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
553 return
554 }
555
556 // create new round
557 err = db.ResubmitPull(tx, pullAt, newRoundNumber, newPatch, combinedPatch, newSourceRev, blob.Blob)
558 if err != nil {
559 l.Error("failed to update pull in database", "err", err, "pull_id", op.PullId, "round_number", newRoundNumber)
560 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
561 return
562 }
563
564 // update dependent-on relation
565 if np.DependentOn != nil {
566 err := db.SetDependentOn(tx, *np.DependentOn, orm.FilterEq("at_uri", np.AtUri()))
567 if err != nil {
568 l.Error("failed to update pull in database", "err", err, "pull_id", op.PullId, "round_number", newRoundNumber)
569 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
570 return
571 }
572 }
573
574 record := np.AsRecord()
575 record.Rounds = op.AsRecord().Rounds
576 record.Rounds = append(record.Rounds, &tangled.RepoPull_Round{
577 CreatedAt: time.Now().Format(time.RFC3339),
578 PatchBlob: blob.Blob,
579 })
580 writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
581 RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{
582 Collection: tangled.RepoPullNSID,
583 Rkey: op.Rkey,
584 Value: &lexutil.LexiconTypeDecoder{
585 Val: &record,
586 },
587 },
588 })
589 }
590
591 _, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{
592 Repo: userDid.String(),
593 Writes: writes,
594 })
595 if err != nil {
596 l.Error("failed to apply writes for stacked pull request", "err", err, "writes_count", len(writes))
597 s.pages.Notice(w, "pull", "Failed to create stacked pull request. Try again later.")
598 return
599 }
600
601 err = tx.Commit()
602 if err != nil {
603 l.Error("failed to commit resubmit transaction", "err", err)
604 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
605 return
606 }
607
608 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)
609 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
610}