this repo has no description
tangled.org
1package repo
2
3import (
4 "context"
5 "database/sql"
6 "encoding/json"
7 "errors"
8 "fmt"
9 "io"
10 "log"
11 "log/slog"
12 "net/http"
13 "net/url"
14 "path/filepath"
15 "slices"
16 "strconv"
17 "strings"
18 "time"
19
20 comatproto "github.com/bluesky-social/indigo/api/atproto"
21 lexutil "github.com/bluesky-social/indigo/lex/util"
22 "tangled.sh/tangled.sh/core/api/tangled"
23 "tangled.sh/tangled.sh/core/appview/commitverify"
24 "tangled.sh/tangled.sh/core/appview/config"
25 "tangled.sh/tangled.sh/core/appview/db"
26 "tangled.sh/tangled.sh/core/appview/notify"
27 "tangled.sh/tangled.sh/core/appview/oauth"
28 "tangled.sh/tangled.sh/core/appview/pages"
29 "tangled.sh/tangled.sh/core/appview/pages/markup"
30 "tangled.sh/tangled.sh/core/appview/reporesolver"
31 xrpcclient "tangled.sh/tangled.sh/core/appview/xrpcclient"
32 "tangled.sh/tangled.sh/core/eventconsumer"
33 "tangled.sh/tangled.sh/core/idresolver"
34 "tangled.sh/tangled.sh/core/knotclient"
35 "tangled.sh/tangled.sh/core/patchutil"
36 "tangled.sh/tangled.sh/core/rbac"
37 "tangled.sh/tangled.sh/core/tid"
38 "tangled.sh/tangled.sh/core/types"
39 "tangled.sh/tangled.sh/core/xrpc/serviceauth"
40
41 securejoin "github.com/cyphar/filepath-securejoin"
42 "github.com/go-chi/chi/v5"
43 "github.com/go-git/go-git/v5/plumbing"
44
45 "github.com/bluesky-social/indigo/atproto/syntax"
46)
47
48type Repo struct {
49 repoResolver *reporesolver.RepoResolver
50 idResolver *idresolver.Resolver
51 config *config.Config
52 oauth *oauth.OAuth
53 pages *pages.Pages
54 spindlestream *eventconsumer.Consumer
55 db *db.DB
56 enforcer *rbac.Enforcer
57 notifier notify.Notifier
58 logger *slog.Logger
59 serviceAuth *serviceauth.ServiceAuth
60}
61
62func New(
63 oauth *oauth.OAuth,
64 repoResolver *reporesolver.RepoResolver,
65 pages *pages.Pages,
66 spindlestream *eventconsumer.Consumer,
67 idResolver *idresolver.Resolver,
68 db *db.DB,
69 config *config.Config,
70 notifier notify.Notifier,
71 enforcer *rbac.Enforcer,
72 logger *slog.Logger,
73) *Repo {
74 return &Repo{oauth: oauth,
75 repoResolver: repoResolver,
76 pages: pages,
77 idResolver: idResolver,
78 config: config,
79 spindlestream: spindlestream,
80 db: db,
81 notifier: notifier,
82 enforcer: enforcer,
83 logger: logger,
84 }
85}
86
87func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {
88 refParam := chi.URLParam(r, "ref")
89 f, err := rp.repoResolver.Resolve(r)
90 if err != nil {
91 log.Println("failed to get repo and knot", err)
92 return
93 }
94
95 var uri string
96 if rp.config.Core.Dev {
97 uri = "http"
98 } else {
99 uri = "https"
100 }
101 url := fmt.Sprintf("%s://%s/%s/%s/archive/%s.tar.gz", uri, f.Knot, f.OwnerDid(), f.Name, url.PathEscape(refParam))
102
103 http.Redirect(w, r, url, http.StatusFound)
104}
105
106func (rp *Repo) RepoLog(w http.ResponseWriter, r *http.Request) {
107 f, err := rp.repoResolver.Resolve(r)
108 if err != nil {
109 log.Println("failed to fully resolve repo", err)
110 return
111 }
112
113 page := 1
114 if r.URL.Query().Get("page") != "" {
115 page, err = strconv.Atoi(r.URL.Query().Get("page"))
116 if err != nil {
117 page = 1
118 }
119 }
120
121 ref := chi.URLParam(r, "ref")
122
123 us, err := knotclient.NewUnsignedClient(f.Knot, rp.config.Core.Dev)
124 if err != nil {
125 log.Println("failed to create unsigned client", err)
126 return
127 }
128
129 repolog, err := us.Log(f.OwnerDid(), f.Name, ref, page)
130 if err != nil {
131 rp.pages.Error503(w)
132 log.Println("failed to reach knotserver", err)
133 return
134 }
135
136 tagResult, err := us.Tags(f.OwnerDid(), f.Name)
137 if err != nil {
138 rp.pages.Error503(w)
139 log.Println("failed to reach knotserver", err)
140 return
141 }
142
143 tagMap := make(map[string][]string)
144 for _, tag := range tagResult.Tags {
145 hash := tag.Hash
146 if tag.Tag != nil {
147 hash = tag.Tag.Target.String()
148 }
149 tagMap[hash] = append(tagMap[hash], tag.Name)
150 }
151
152 branchResult, err := us.Branches(f.OwnerDid(), f.Name)
153 if err != nil {
154 rp.pages.Error503(w)
155 log.Println("failed to reach knotserver", err)
156 return
157 }
158
159 for _, branch := range branchResult.Branches {
160 hash := branch.Hash
161 tagMap[hash] = append(tagMap[hash], branch.Name)
162 }
163
164 user := rp.oauth.GetUser(r)
165
166 emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(repolog.Commits), true)
167 if err != nil {
168 log.Println("failed to fetch email to did mapping", err)
169 }
170
171 vc, err := commitverify.GetVerifiedObjectCommits(rp.db, emailToDidMap, repolog.Commits)
172 if err != nil {
173 log.Println(err)
174 }
175
176 repoInfo := f.RepoInfo(user)
177
178 var shas []string
179 for _, c := range repolog.Commits {
180 shas = append(shas, c.Hash.String())
181 }
182 pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)
183 if err != nil {
184 log.Println(err)
185 // non-fatal
186 }
187
188 rp.pages.RepoLog(w, pages.RepoLogParams{
189 LoggedInUser: user,
190 TagMap: tagMap,
191 RepoInfo: repoInfo,
192 RepoLogResponse: *repolog,
193 EmailToDidOrHandle: emailToDidOrHandle(rp, emailToDidMap),
194 VerifiedCommits: vc,
195 Pipelines: pipelines,
196 })
197}
198
199func (rp *Repo) RepoDescriptionEdit(w http.ResponseWriter, r *http.Request) {
200 f, err := rp.repoResolver.Resolve(r)
201 if err != nil {
202 log.Println("failed to get repo and knot", err)
203 w.WriteHeader(http.StatusBadRequest)
204 return
205 }
206
207 user := rp.oauth.GetUser(r)
208 rp.pages.EditRepoDescriptionFragment(w, pages.RepoDescriptionParams{
209 RepoInfo: f.RepoInfo(user),
210 })
211}
212
213func (rp *Repo) RepoDescription(w http.ResponseWriter, r *http.Request) {
214 f, err := rp.repoResolver.Resolve(r)
215 if err != nil {
216 log.Println("failed to get repo and knot", err)
217 w.WriteHeader(http.StatusBadRequest)
218 return
219 }
220
221 repoAt := f.RepoAt()
222 rkey := repoAt.RecordKey().String()
223 if rkey == "" {
224 log.Println("invalid aturi for repo", err)
225 w.WriteHeader(http.StatusInternalServerError)
226 return
227 }
228
229 user := rp.oauth.GetUser(r)
230
231 switch r.Method {
232 case http.MethodGet:
233 rp.pages.RepoDescriptionFragment(w, pages.RepoDescriptionParams{
234 RepoInfo: f.RepoInfo(user),
235 })
236 return
237 case http.MethodPut:
238 newDescription := r.FormValue("description")
239 client, err := rp.oauth.AuthorizedClient(r)
240 if err != nil {
241 log.Println("failed to get client")
242 rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")
243 return
244 }
245
246 // optimistic update
247 err = db.UpdateDescription(rp.db, string(repoAt), newDescription)
248 if err != nil {
249 log.Println("failed to perferom update-description query", err)
250 rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")
251 return
252 }
253
254 // this is a bit of a pain because the golang atproto impl does not allow nil SwapRecord field
255 //
256 // SwapRecord is optional and should happen automagically, but given that it does not, we have to perform two requests
257 ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoNSID, user.Did, rkey)
258 if err != nil {
259 // failed to get record
260 rp.pages.Notice(w, "repo-notice", "Failed to update description, no record found on PDS.")
261 return
262 }
263 _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
264 Collection: tangled.RepoNSID,
265 Repo: user.Did,
266 Rkey: rkey,
267 SwapRecord: ex.Cid,
268 Record: &lexutil.LexiconTypeDecoder{
269 Val: &tangled.Repo{
270 Knot: f.Knot,
271 Name: f.Name,
272 Owner: user.Did,
273 CreatedAt: f.Created.Format(time.RFC3339),
274 Description: &newDescription,
275 Spindle: &f.Spindle,
276 },
277 },
278 })
279
280 if err != nil {
281 log.Println("failed to perferom update-description query", err)
282 // failed to get record
283 rp.pages.Notice(w, "repo-notice", "Failed to update description, unable to save to PDS.")
284 return
285 }
286
287 newRepoInfo := f.RepoInfo(user)
288 newRepoInfo.Description = newDescription
289
290 rp.pages.RepoDescriptionFragment(w, pages.RepoDescriptionParams{
291 RepoInfo: newRepoInfo,
292 })
293 return
294 }
295}
296
297func (rp *Repo) RepoCommit(w http.ResponseWriter, r *http.Request) {
298 f, err := rp.repoResolver.Resolve(r)
299 if err != nil {
300 log.Println("failed to fully resolve repo", err)
301 return
302 }
303 ref := chi.URLParam(r, "ref")
304 protocol := "http"
305 if !rp.config.Core.Dev {
306 protocol = "https"
307 }
308
309 var diffOpts types.DiffOpts
310 if d := r.URL.Query().Get("diff"); d == "split" {
311 diffOpts.Split = true
312 }
313
314 if !plumbing.IsHash(ref) {
315 rp.pages.Error404(w)
316 return
317 }
318
319 resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/commit/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref))
320 if err != nil {
321 rp.pages.Error503(w)
322 log.Println("failed to reach knotserver", err)
323 return
324 }
325
326 body, err := io.ReadAll(resp.Body)
327 if err != nil {
328 log.Printf("Error reading response body: %v", err)
329 return
330 }
331
332 var result types.RepoCommitResponse
333 err = json.Unmarshal(body, &result)
334 if err != nil {
335 log.Println("failed to parse response:", err)
336 return
337 }
338
339 emailToDidMap, err := db.GetEmailToDid(rp.db, []string{result.Diff.Commit.Committer.Email, result.Diff.Commit.Author.Email}, true)
340 if err != nil {
341 log.Println("failed to get email to did mapping:", err)
342 }
343
344 vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, []types.NiceDiff{*result.Diff})
345 if err != nil {
346 log.Println(err)
347 }
348
349 user := rp.oauth.GetUser(r)
350 repoInfo := f.RepoInfo(user)
351 pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This})
352 if err != nil {
353 log.Println(err)
354 // non-fatal
355 }
356 var pipeline *db.Pipeline
357 if p, ok := pipelines[result.Diff.Commit.This]; ok {
358 pipeline = &p
359 }
360
361 rp.pages.RepoCommit(w, pages.RepoCommitParams{
362 LoggedInUser: user,
363 RepoInfo: f.RepoInfo(user),
364 RepoCommitResponse: result,
365 EmailToDidOrHandle: emailToDidOrHandle(rp, emailToDidMap),
366 VerifiedCommit: vc,
367 Pipeline: pipeline,
368 DiffOpts: diffOpts,
369 })
370}
371
372func (rp *Repo) RepoTree(w http.ResponseWriter, r *http.Request) {
373 f, err := rp.repoResolver.Resolve(r)
374 if err != nil {
375 log.Println("failed to fully resolve repo", err)
376 return
377 }
378
379 ref := chi.URLParam(r, "ref")
380 treePath := chi.URLParam(r, "*")
381 protocol := "http"
382 if !rp.config.Core.Dev {
383 protocol = "https"
384 }
385
386 // if the tree path has a trailing slash, let's strip it
387 // so we don't 404
388 treePath = strings.TrimSuffix(treePath, "/")
389
390 resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/tree/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, treePath))
391 if err != nil {
392 rp.pages.Error503(w)
393 log.Println("failed to reach knotserver", err)
394 return
395 }
396
397 // uhhh so knotserver returns a 500 if the entry isn't found in
398 // the requested tree path, so let's stick to not-OK here.
399 // we can fix this once we build out the xrpc apis for these operations.
400 if resp.StatusCode != http.StatusOK {
401 rp.pages.Error404(w)
402 return
403 }
404
405 body, err := io.ReadAll(resp.Body)
406 if err != nil {
407 log.Printf("Error reading response body: %v", err)
408 return
409 }
410
411 var result types.RepoTreeResponse
412 err = json.Unmarshal(body, &result)
413 if err != nil {
414 log.Println("failed to parse response:", err)
415 return
416 }
417
418 // redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,
419 // so we can safely redirect to the "parent" (which is the same file).
420 unescapedTreePath, _ := url.PathUnescape(treePath)
421 if len(result.Files) == 0 && result.Parent == unescapedTreePath {
422 http.Redirect(w, r, fmt.Sprintf("/%s/blob/%s/%s", f.OwnerSlashRepo(), ref, result.Parent), http.StatusFound)
423 return
424 }
425
426 user := rp.oauth.GetUser(r)
427
428 var breadcrumbs [][]string
429 breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
430 if treePath != "" {
431 for idx, elem := range strings.Split(treePath, "/") {
432 breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)})
433 }
434 }
435
436 sortFiles(result.Files)
437
438 rp.pages.RepoTree(w, pages.RepoTreeParams{
439 LoggedInUser: user,
440 BreadCrumbs: breadcrumbs,
441 TreePath: treePath,
442 RepoInfo: f.RepoInfo(user),
443 RepoTreeResponse: result,
444 })
445}
446
447func (rp *Repo) RepoTags(w http.ResponseWriter, r *http.Request) {
448 f, err := rp.repoResolver.Resolve(r)
449 if err != nil {
450 log.Println("failed to get repo and knot", err)
451 return
452 }
453
454 us, err := knotclient.NewUnsignedClient(f.Knot, rp.config.Core.Dev)
455 if err != nil {
456 log.Println("failed to create unsigned client", err)
457 return
458 }
459
460 result, err := us.Tags(f.OwnerDid(), f.Name)
461 if err != nil {
462 rp.pages.Error503(w)
463 log.Println("failed to reach knotserver", err)
464 return
465 }
466
467 artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt()))
468 if err != nil {
469 log.Println("failed grab artifacts", err)
470 return
471 }
472
473 // convert artifacts to map for easy UI building
474 artifactMap := make(map[plumbing.Hash][]db.Artifact)
475 for _, a := range artifacts {
476 artifactMap[a.Tag] = append(artifactMap[a.Tag], a)
477 }
478
479 var danglingArtifacts []db.Artifact
480 for _, a := range artifacts {
481 found := false
482 for _, t := range result.Tags {
483 if t.Tag != nil {
484 if t.Tag.Hash == a.Tag {
485 found = true
486 }
487 }
488 }
489
490 if !found {
491 danglingArtifacts = append(danglingArtifacts, a)
492 }
493 }
494
495 user := rp.oauth.GetUser(r)
496 rp.pages.RepoTags(w, pages.RepoTagsParams{
497 LoggedInUser: user,
498 RepoInfo: f.RepoInfo(user),
499 RepoTagsResponse: *result,
500 ArtifactMap: artifactMap,
501 DanglingArtifacts: danglingArtifacts,
502 })
503}
504
505func (rp *Repo) RepoBranches(w http.ResponseWriter, r *http.Request) {
506 f, err := rp.repoResolver.Resolve(r)
507 if err != nil {
508 log.Println("failed to get repo and knot", err)
509 return
510 }
511
512 us, err := knotclient.NewUnsignedClient(f.Knot, rp.config.Core.Dev)
513 if err != nil {
514 log.Println("failed to create unsigned client", err)
515 return
516 }
517
518 result, err := us.Branches(f.OwnerDid(), f.Name)
519 if err != nil {
520 rp.pages.Error503(w)
521 log.Println("failed to reach knotserver", err)
522 return
523 }
524
525 sortBranches(result.Branches)
526
527 user := rp.oauth.GetUser(r)
528 rp.pages.RepoBranches(w, pages.RepoBranchesParams{
529 LoggedInUser: user,
530 RepoInfo: f.RepoInfo(user),
531 RepoBranchesResponse: *result,
532 })
533}
534
535func (rp *Repo) RepoBlob(w http.ResponseWriter, r *http.Request) {
536 f, err := rp.repoResolver.Resolve(r)
537 if err != nil {
538 log.Println("failed to get repo and knot", err)
539 return
540 }
541
542 ref := chi.URLParam(r, "ref")
543 filePath := chi.URLParam(r, "*")
544 protocol := "http"
545 if !rp.config.Core.Dev {
546 protocol = "https"
547 }
548 resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/blob/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath))
549 if err != nil {
550 rp.pages.Error503(w)
551 log.Println("failed to reach knotserver", err)
552 return
553 }
554
555 if resp.StatusCode == http.StatusNotFound {
556 rp.pages.Error404(w)
557 return
558 }
559
560 body, err := io.ReadAll(resp.Body)
561 if err != nil {
562 log.Printf("Error reading response body: %v", err)
563 return
564 }
565
566 var result types.RepoBlobResponse
567 err = json.Unmarshal(body, &result)
568 if err != nil {
569 log.Println("failed to parse response:", err)
570 return
571 }
572
573 var breadcrumbs [][]string
574 breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
575 if filePath != "" {
576 for idx, elem := range strings.Split(filePath, "/") {
577 breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)})
578 }
579 }
580
581 showRendered := false
582 renderToggle := false
583
584 if markup.GetFormat(result.Path) == markup.FormatMarkdown {
585 renderToggle = true
586 showRendered = r.URL.Query().Get("code") != "true"
587 }
588
589 var unsupported bool
590 var isImage bool
591 var isVideo bool
592 var contentSrc string
593
594 if result.IsBinary {
595 ext := strings.ToLower(filepath.Ext(result.Path))
596 switch ext {
597 case ".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp":
598 isImage = true
599 case ".mp4", ".webm", ".ogg", ".mov", ".avi":
600 isVideo = true
601 default:
602 unsupported = true
603 }
604
605 // fetch the actual binary content like in RepoBlobRaw
606
607 blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Name, ref, filePath)
608 contentSrc = blobURL
609 if !rp.config.Core.Dev {
610 contentSrc = markup.GenerateCamoURL(rp.config.Camo.Host, rp.config.Camo.SharedSecret, blobURL)
611 }
612 }
613
614 user := rp.oauth.GetUser(r)
615 rp.pages.RepoBlob(w, pages.RepoBlobParams{
616 LoggedInUser: user,
617 RepoInfo: f.RepoInfo(user),
618 RepoBlobResponse: result,
619 BreadCrumbs: breadcrumbs,
620 ShowRendered: showRendered,
621 RenderToggle: renderToggle,
622 Unsupported: unsupported,
623 IsImage: isImage,
624 IsVideo: isVideo,
625 ContentSrc: contentSrc,
626 })
627}
628
629func (rp *Repo) RepoBlobRaw(w http.ResponseWriter, r *http.Request) {
630 f, err := rp.repoResolver.Resolve(r)
631 if err != nil {
632 log.Println("failed to get repo and knot", err)
633 w.WriteHeader(http.StatusBadRequest)
634 return
635 }
636
637 ref := chi.URLParam(r, "ref")
638 filePath := chi.URLParam(r, "*")
639
640 protocol := "http"
641 if !rp.config.Core.Dev {
642 protocol = "https"
643 }
644
645 blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath)
646
647 req, err := http.NewRequest("GET", blobURL, nil)
648 if err != nil {
649 log.Println("failed to create request", err)
650 return
651 }
652
653 // forward the If-None-Match header
654 if clientETag := r.Header.Get("If-None-Match"); clientETag != "" {
655 req.Header.Set("If-None-Match", clientETag)
656 }
657
658 client := &http.Client{}
659 resp, err := client.Do(req)
660 if err != nil {
661 log.Println("failed to reach knotserver", err)
662 rp.pages.Error503(w)
663 return
664 }
665 defer resp.Body.Close()
666
667 // forward 304 not modified
668 if resp.StatusCode == http.StatusNotModified {
669 w.WriteHeader(http.StatusNotModified)
670 return
671 }
672
673 if resp.StatusCode != http.StatusOK {
674 log.Printf("knotserver returned non-OK status for raw blob %s: %d", blobURL, resp.StatusCode)
675 w.WriteHeader(resp.StatusCode)
676 _, _ = io.Copy(w, resp.Body)
677 return
678 }
679
680 contentType := resp.Header.Get("Content-Type")
681 body, err := io.ReadAll(resp.Body)
682 if err != nil {
683 log.Printf("error reading response body from knotserver: %v", err)
684 w.WriteHeader(http.StatusInternalServerError)
685 return
686 }
687
688 if strings.Contains(contentType, "text/plain") {
689 w.Header().Set("Content-Type", "text/plain; charset=utf-8")
690 w.Write(body)
691 } else if strings.HasPrefix(contentType, "image/") || strings.HasPrefix(contentType, "video/") {
692 w.Header().Set("Content-Type", contentType)
693 w.Write(body)
694 } else {
695 w.WriteHeader(http.StatusUnsupportedMediaType)
696 w.Write([]byte("unsupported content type"))
697 return
698 }
699}
700
701// modify the spindle configured for this repo
702func (rp *Repo) EditSpindle(w http.ResponseWriter, r *http.Request) {
703 user := rp.oauth.GetUser(r)
704 l := rp.logger.With("handler", "EditSpindle")
705 l = l.With("did", user.Did)
706 l = l.With("handle", user.Handle)
707
708 errorId := "operation-error"
709 fail := func(msg string, err error) {
710 l.Error(msg, "err", err)
711 rp.pages.Notice(w, errorId, msg)
712 }
713
714 f, err := rp.repoResolver.Resolve(r)
715 if err != nil {
716 fail("Failed to resolve repo. Try again later", err)
717 return
718 }
719
720 repoAt := f.RepoAt()
721 rkey := repoAt.RecordKey().String()
722 if rkey == "" {
723 fail("Failed to resolve repo. Try again later", err)
724 return
725 }
726
727 newSpindle := r.FormValue("spindle")
728 removingSpindle := newSpindle == "[[none]]" // see pages/templates/repo/settings/pipelines.html for more info on why we use this value
729 client, err := rp.oauth.AuthorizedClient(r)
730 if err != nil {
731 fail("Failed to authorize. Try again later.", err)
732 return
733 }
734
735 if !removingSpindle {
736 // ensure that this is a valid spindle for this user
737 validSpindles, err := rp.enforcer.GetSpindlesForUser(user.Did)
738 if err != nil {
739 fail("Failed to find spindles. Try again later.", err)
740 return
741 }
742
743 if !slices.Contains(validSpindles, newSpindle) {
744 fail("Failed to configure spindle.", fmt.Errorf("%s is not a valid spindle: %q", newSpindle, validSpindles))
745 return
746 }
747 }
748
749 spindlePtr := &newSpindle
750 if removingSpindle {
751 spindlePtr = nil
752 }
753
754 // optimistic update
755 err = db.UpdateSpindle(rp.db, string(repoAt), spindlePtr)
756 if err != nil {
757 fail("Failed to update spindle. Try again later.", err)
758 return
759 }
760
761 ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoNSID, user.Did, rkey)
762 if err != nil {
763 fail("Failed to update spindle, no record found on PDS.", err)
764 return
765 }
766 _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
767 Collection: tangled.RepoNSID,
768 Repo: user.Did,
769 Rkey: rkey,
770 SwapRecord: ex.Cid,
771 Record: &lexutil.LexiconTypeDecoder{
772 Val: &tangled.Repo{
773 Knot: f.Knot,
774 Name: f.Name,
775 Owner: user.Did,
776 CreatedAt: f.Created.Format(time.RFC3339),
777 Description: &f.Description,
778 Spindle: spindlePtr,
779 },
780 },
781 })
782
783 if err != nil {
784 fail("Failed to update spindle, unable to save to PDS.", err)
785 return
786 }
787
788 if !removingSpindle {
789 // add this spindle to spindle stream
790 rp.spindlestream.AddSource(
791 context.Background(),
792 eventconsumer.NewSpindleSource(newSpindle),
793 )
794 }
795
796 rp.pages.HxRefresh(w)
797}
798
799func (rp *Repo) AddCollaborator(w http.ResponseWriter, r *http.Request) {
800 user := rp.oauth.GetUser(r)
801 l := rp.logger.With("handler", "AddCollaborator")
802 l = l.With("did", user.Did)
803 l = l.With("handle", user.Handle)
804
805 f, err := rp.repoResolver.Resolve(r)
806 if err != nil {
807 l.Error("failed to get repo and knot", "err", err)
808 return
809 }
810
811 errorId := "add-collaborator-error"
812 fail := func(msg string, err error) {
813 l.Error(msg, "err", err)
814 rp.pages.Notice(w, errorId, msg)
815 }
816
817 collaborator := r.FormValue("collaborator")
818 if collaborator == "" {
819 fail("Invalid form.", nil)
820 return
821 }
822
823 // remove a single leading `@`, to make @handle work with ResolveIdent
824 collaborator = strings.TrimPrefix(collaborator, "@")
825
826 collaboratorIdent, err := rp.idResolver.ResolveIdent(r.Context(), collaborator)
827 if err != nil {
828 fail(fmt.Sprintf("'%s' is not a valid DID/handle.", collaborator), err)
829 return
830 }
831
832 if collaboratorIdent.DID.String() == user.Did {
833 fail("You seem to be adding yourself as a collaborator.", nil)
834 return
835 }
836 l = l.With("collaborator", collaboratorIdent.Handle)
837 l = l.With("knot", f.Knot)
838
839 // announce this relation into the firehose, store into owners' pds
840 client, err := rp.oauth.AuthorizedClient(r)
841 if err != nil {
842 fail("Failed to write to PDS.", err)
843 return
844 }
845
846 // emit a record
847 currentUser := rp.oauth.GetUser(r)
848 rkey := tid.TID()
849 createdAt := time.Now()
850 resp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
851 Collection: tangled.RepoCollaboratorNSID,
852 Repo: currentUser.Did,
853 Rkey: rkey,
854 Record: &lexutil.LexiconTypeDecoder{
855 Val: &tangled.RepoCollaborator{
856 Subject: collaboratorIdent.DID.String(),
857 Repo: string(f.RepoAt()),
858 CreatedAt: createdAt.Format(time.RFC3339),
859 }},
860 })
861 // invalid record
862 if err != nil {
863 fail("Failed to write record to PDS.", err)
864 return
865 }
866
867 aturi := resp.Uri
868 l = l.With("at-uri", aturi)
869 l.Info("wrote record to PDS")
870
871 tx, err := rp.db.BeginTx(r.Context(), nil)
872 if err != nil {
873 fail("Failed to add collaborator.", err)
874 return
875 }
876
877 rollback := func() {
878 err1 := tx.Rollback()
879 err2 := rp.enforcer.E.LoadPolicy()
880 err3 := rollbackRecord(context.Background(), aturi, client)
881
882 // ignore txn complete errors, this is okay
883 if errors.Is(err1, sql.ErrTxDone) {
884 err1 = nil
885 }
886
887 if errs := errors.Join(err1, err2, err3); errs != nil {
888 l.Error("failed to rollback changes", "errs", errs)
889 return
890 }
891 }
892 defer rollback()
893
894 err = rp.enforcer.AddCollaborator(collaboratorIdent.DID.String(), f.Knot, f.DidSlashRepo())
895 if err != nil {
896 fail("Failed to add collaborator permissions.", err)
897 return
898 }
899
900 err = db.AddCollaborator(rp.db, db.Collaborator{
901 Did: syntax.DID(currentUser.Did),
902 Rkey: rkey,
903 SubjectDid: collaboratorIdent.DID,
904 RepoAt: f.RepoAt(),
905 Created: createdAt,
906 })
907 if err != nil {
908 fail("Failed to add collaborator.", err)
909 return
910 }
911
912 err = tx.Commit()
913 if err != nil {
914 fail("Failed to add collaborator.", err)
915 return
916 }
917
918 err = rp.enforcer.E.SavePolicy()
919 if err != nil {
920 fail("Failed to update collaborator permissions.", err)
921 return
922 }
923
924 // clear aturi to when everything is successful
925 aturi = ""
926
927 rp.pages.HxRefresh(w)
928}
929
930func (rp *Repo) DeleteRepo(w http.ResponseWriter, r *http.Request) {
931 user := rp.oauth.GetUser(r)
932
933 noticeId := "operation-error"
934 f, err := rp.repoResolver.Resolve(r)
935 if err != nil {
936 log.Println("failed to get repo and knot", err)
937 return
938 }
939
940 // remove record from pds
941 xrpcClient, err := rp.oauth.AuthorizedClient(r)
942 if err != nil {
943 log.Println("failed to get authorized client", err)
944 return
945 }
946 _, err = xrpcClient.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{
947 Collection: tangled.RepoNSID,
948 Repo: user.Did,
949 Rkey: f.Rkey,
950 })
951 if err != nil {
952 log.Printf("failed to delete record: %s", err)
953 rp.pages.Notice(w, noticeId, "Failed to delete repository from PDS.")
954 return
955 }
956 log.Println("removed repo record ", f.RepoAt().String())
957
958 client, err := rp.oauth.ServiceClient(
959 r,
960 oauth.WithService(f.Knot),
961 oauth.WithLxm(tangled.RepoDeleteNSID),
962 oauth.WithDev(rp.config.Core.Dev),
963 )
964 if err != nil {
965 log.Println("failed to connect to knot server:", err)
966 return
967 }
968
969 err = tangled.RepoDelete(
970 r.Context(),
971 client,
972 &tangled.RepoDelete_Input{
973 Did: f.OwnerDid(),
974 Name: f.Name,
975 },
976 )
977 if err := xrpcclient.HandleXrpcErr(err); err != nil {
978 rp.pages.Notice(w, noticeId, err.Error())
979 return
980 }
981 log.Println("deleted repo from knot")
982
983 tx, err := rp.db.BeginTx(r.Context(), nil)
984 if err != nil {
985 log.Println("failed to start tx")
986 w.Write(fmt.Append(nil, "failed to add collaborator: ", err))
987 return
988 }
989 defer func() {
990 tx.Rollback()
991 err = rp.enforcer.E.LoadPolicy()
992 if err != nil {
993 log.Println("failed to rollback policies")
994 }
995 }()
996
997 // remove collaborator RBAC
998 repoCollaborators, err := rp.enforcer.E.GetImplicitUsersForResourceByDomain(f.DidSlashRepo(), f.Knot)
999 if err != nil {
1000 rp.pages.Notice(w, noticeId, "Failed to remove collaborators")
1001 return
1002 }
1003 for _, c := range repoCollaborators {
1004 did := c[0]
1005 rp.enforcer.RemoveCollaborator(did, f.Knot, f.DidSlashRepo())
1006 }
1007 log.Println("removed collaborators")
1008
1009 // remove repo RBAC
1010 err = rp.enforcer.RemoveRepo(f.OwnerDid(), f.Knot, f.DidSlashRepo())
1011 if err != nil {
1012 rp.pages.Notice(w, noticeId, "Failed to update RBAC rules")
1013 return
1014 }
1015
1016 // remove repo from db
1017 err = db.RemoveRepo(tx, f.OwnerDid(), f.Name)
1018 if err != nil {
1019 rp.pages.Notice(w, noticeId, "Failed to update appview")
1020 return
1021 }
1022 log.Println("removed repo from db")
1023
1024 err = tx.Commit()
1025 if err != nil {
1026 log.Println("failed to commit changes", err)
1027 http.Error(w, err.Error(), http.StatusInternalServerError)
1028 return
1029 }
1030
1031 err = rp.enforcer.E.SavePolicy()
1032 if err != nil {
1033 log.Println("failed to update ACLs", err)
1034 http.Error(w, err.Error(), http.StatusInternalServerError)
1035 return
1036 }
1037
1038 rp.pages.HxRedirect(w, fmt.Sprintf("/%s", f.OwnerDid()))
1039}
1040
1041func (rp *Repo) SetDefaultBranch(w http.ResponseWriter, r *http.Request) {
1042 f, err := rp.repoResolver.Resolve(r)
1043 if err != nil {
1044 log.Println("failed to get repo and knot", err)
1045 return
1046 }
1047
1048 noticeId := "operation-error"
1049 branch := r.FormValue("branch")
1050 if branch == "" {
1051 http.Error(w, "malformed form", http.StatusBadRequest)
1052 return
1053 }
1054
1055 client, err := rp.oauth.ServiceClient(
1056 r,
1057 oauth.WithService(f.Knot),
1058 oauth.WithLxm(tangled.RepoSetDefaultBranchNSID),
1059 oauth.WithDev(rp.config.Core.Dev),
1060 )
1061 if err != nil {
1062 log.Println("failed to connect to knot server:", err)
1063 rp.pages.Notice(w, noticeId, "Failed to connect to knot server.")
1064 return
1065 }
1066
1067 xe := tangled.RepoSetDefaultBranch(
1068 r.Context(),
1069 client,
1070 &tangled.RepoSetDefaultBranch_Input{
1071 Repo: f.RepoAt().String(),
1072 DefaultBranch: branch,
1073 },
1074 )
1075 if err := xrpcclient.HandleXrpcErr(xe); err != nil {
1076 log.Println("xrpc failed", "err", xe)
1077 rp.pages.Notice(w, noticeId, err.Error())
1078 return
1079 }
1080
1081 rp.pages.HxRefresh(w)
1082}
1083
1084func (rp *Repo) Secrets(w http.ResponseWriter, r *http.Request) {
1085 user := rp.oauth.GetUser(r)
1086 l := rp.logger.With("handler", "Secrets")
1087 l = l.With("handle", user.Handle)
1088 l = l.With("did", user.Did)
1089
1090 f, err := rp.repoResolver.Resolve(r)
1091 if err != nil {
1092 log.Println("failed to get repo and knot", err)
1093 return
1094 }
1095
1096 if f.Spindle == "" {
1097 log.Println("empty spindle cannot add/rm secret", err)
1098 return
1099 }
1100
1101 lxm := tangled.RepoAddSecretNSID
1102 if r.Method == http.MethodDelete {
1103 lxm = tangled.RepoRemoveSecretNSID
1104 }
1105
1106 spindleClient, err := rp.oauth.ServiceClient(
1107 r,
1108 oauth.WithService(f.Spindle),
1109 oauth.WithLxm(lxm),
1110 oauth.WithExp(60),
1111 oauth.WithDev(rp.config.Core.Dev),
1112 )
1113 if err != nil {
1114 log.Println("failed to create spindle client", err)
1115 return
1116 }
1117
1118 key := r.FormValue("key")
1119 if key == "" {
1120 w.WriteHeader(http.StatusBadRequest)
1121 return
1122 }
1123
1124 switch r.Method {
1125 case http.MethodPut:
1126 errorId := "add-secret-error"
1127
1128 value := r.FormValue("value")
1129 if value == "" {
1130 w.WriteHeader(http.StatusBadRequest)
1131 return
1132 }
1133
1134 err = tangled.RepoAddSecret(
1135 r.Context(),
1136 spindleClient,
1137 &tangled.RepoAddSecret_Input{
1138 Repo: f.RepoAt().String(),
1139 Key: key,
1140 Value: value,
1141 },
1142 )
1143 if err != nil {
1144 l.Error("Failed to add secret.", "err", err)
1145 rp.pages.Notice(w, errorId, "Failed to add secret.")
1146 return
1147 }
1148
1149 case http.MethodDelete:
1150 errorId := "operation-error"
1151
1152 err = tangled.RepoRemoveSecret(
1153 r.Context(),
1154 spindleClient,
1155 &tangled.RepoRemoveSecret_Input{
1156 Repo: f.RepoAt().String(),
1157 Key: key,
1158 },
1159 )
1160 if err != nil {
1161 l.Error("Failed to delete secret.", "err", err)
1162 rp.pages.Notice(w, errorId, "Failed to delete secret.")
1163 return
1164 }
1165 }
1166
1167 rp.pages.HxRefresh(w)
1168}
1169
1170type tab = map[string]any
1171
1172var (
1173 // would be great to have ordered maps right about now
1174 settingsTabs []tab = []tab{
1175 {"Name": "general", "Icon": "sliders-horizontal"},
1176 {"Name": "access", "Icon": "users"},
1177 {"Name": "pipelines", "Icon": "layers-2"},
1178 }
1179)
1180
1181func (rp *Repo) RepoSettings(w http.ResponseWriter, r *http.Request) {
1182 tabVal := r.URL.Query().Get("tab")
1183 if tabVal == "" {
1184 tabVal = "general"
1185 }
1186
1187 switch tabVal {
1188 case "general":
1189 rp.generalSettings(w, r)
1190
1191 case "access":
1192 rp.accessSettings(w, r)
1193
1194 case "pipelines":
1195 rp.pipelineSettings(w, r)
1196 }
1197}
1198
1199func (rp *Repo) generalSettings(w http.ResponseWriter, r *http.Request) {
1200 f, err := rp.repoResolver.Resolve(r)
1201 user := rp.oauth.GetUser(r)
1202
1203 us, err := knotclient.NewUnsignedClient(f.Knot, rp.config.Core.Dev)
1204 if err != nil {
1205 log.Println("failed to create unsigned client", err)
1206 return
1207 }
1208
1209 result, err := us.Branches(f.OwnerDid(), f.Name)
1210 if err != nil {
1211 rp.pages.Error503(w)
1212 log.Println("failed to reach knotserver", err)
1213 return
1214 }
1215
1216 rp.pages.RepoGeneralSettings(w, pages.RepoGeneralSettingsParams{
1217 LoggedInUser: user,
1218 RepoInfo: f.RepoInfo(user),
1219 Branches: result.Branches,
1220 Tabs: settingsTabs,
1221 Tab: "general",
1222 })
1223}
1224
1225func (rp *Repo) accessSettings(w http.ResponseWriter, r *http.Request) {
1226 f, err := rp.repoResolver.Resolve(r)
1227 user := rp.oauth.GetUser(r)
1228
1229 repoCollaborators, err := f.Collaborators(r.Context())
1230 if err != nil {
1231 log.Println("failed to get collaborators", err)
1232 }
1233
1234 rp.pages.RepoAccessSettings(w, pages.RepoAccessSettingsParams{
1235 LoggedInUser: user,
1236 RepoInfo: f.RepoInfo(user),
1237 Tabs: settingsTabs,
1238 Tab: "access",
1239 Collaborators: repoCollaborators,
1240 })
1241}
1242
1243func (rp *Repo) pipelineSettings(w http.ResponseWriter, r *http.Request) {
1244 f, err := rp.repoResolver.Resolve(r)
1245 user := rp.oauth.GetUser(r)
1246
1247 // all spindles that the repo owner is a member of
1248 spindles, err := rp.enforcer.GetSpindlesForUser(f.OwnerDid())
1249 if err != nil {
1250 log.Println("failed to fetch spindles", err)
1251 return
1252 }
1253
1254 var secrets []*tangled.RepoListSecrets_Secret
1255 if f.Spindle != "" {
1256 if spindleClient, err := rp.oauth.ServiceClient(
1257 r,
1258 oauth.WithService(f.Spindle),
1259 oauth.WithLxm(tangled.RepoListSecretsNSID),
1260 oauth.WithExp(60),
1261 oauth.WithDev(rp.config.Core.Dev),
1262 ); err != nil {
1263 log.Println("failed to create spindle client", err)
1264 } else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil {
1265 log.Println("failed to fetch secrets", err)
1266 } else {
1267 secrets = resp.Secrets
1268 }
1269 }
1270
1271 slices.SortFunc(secrets, func(a, b *tangled.RepoListSecrets_Secret) int {
1272 return strings.Compare(a.Key, b.Key)
1273 })
1274
1275 var dids []string
1276 for _, s := range secrets {
1277 dids = append(dids, s.CreatedBy)
1278 }
1279 resolvedIdents := rp.idResolver.ResolveIdents(r.Context(), dids)
1280
1281 // convert to a more manageable form
1282 var niceSecret []map[string]any
1283 for id, s := range secrets {
1284 when, _ := time.Parse(time.RFC3339, s.CreatedAt)
1285 niceSecret = append(niceSecret, map[string]any{
1286 "Id": id,
1287 "Key": s.Key,
1288 "CreatedAt": when,
1289 "CreatedBy": resolvedIdents[id].Handle.String(),
1290 })
1291 }
1292
1293 rp.pages.RepoPipelineSettings(w, pages.RepoPipelineSettingsParams{
1294 LoggedInUser: user,
1295 RepoInfo: f.RepoInfo(user),
1296 Tabs: settingsTabs,
1297 Tab: "pipelines",
1298 Spindles: spindles,
1299 CurrentSpindle: f.Spindle,
1300 Secrets: niceSecret,
1301 })
1302}
1303
1304func (rp *Repo) SyncRepoFork(w http.ResponseWriter, r *http.Request) {
1305 ref := chi.URLParam(r, "ref")
1306
1307 user := rp.oauth.GetUser(r)
1308 f, err := rp.repoResolver.Resolve(r)
1309 if err != nil {
1310 log.Printf("failed to resolve source repo: %v", err)
1311 return
1312 }
1313
1314 switch r.Method {
1315 case http.MethodPost:
1316 client, err := rp.oauth.ServiceClient(
1317 r,
1318 oauth.WithService(f.Knot),
1319 oauth.WithLxm(tangled.RepoForkSyncNSID),
1320 oauth.WithDev(rp.config.Core.Dev),
1321 )
1322 if err != nil {
1323 rp.pages.Notice(w, "repo", "Failed to connect to knot server.")
1324 return
1325 }
1326
1327 repoInfo := f.RepoInfo(user)
1328 if repoInfo.Source == nil {
1329 rp.pages.Notice(w, "repo", "This repository is not a fork.")
1330 return
1331 }
1332
1333 err = tangled.RepoForkSync(
1334 r.Context(),
1335 client,
1336 &tangled.RepoForkSync_Input{
1337 Did: user.Did,
1338 Name: f.Name,
1339 Source: repoInfo.Source.RepoAt().String(),
1340 Branch: ref,
1341 },
1342 )
1343 if err := xrpcclient.HandleXrpcErr(err); err != nil {
1344 rp.pages.Notice(w, "repo", err.Error())
1345 return
1346 }
1347
1348 rp.pages.HxRefresh(w)
1349 return
1350 }
1351}
1352
1353func (rp *Repo) ForkRepo(w http.ResponseWriter, r *http.Request) {
1354 user := rp.oauth.GetUser(r)
1355 f, err := rp.repoResolver.Resolve(r)
1356 if err != nil {
1357 log.Printf("failed to resolve source repo: %v", err)
1358 return
1359 }
1360
1361 switch r.Method {
1362 case http.MethodGet:
1363 user := rp.oauth.GetUser(r)
1364 knots, err := rp.enforcer.GetKnotsForUser(user.Did)
1365 if err != nil {
1366 rp.pages.Notice(w, "repo", "Invalid user account.")
1367 return
1368 }
1369
1370 rp.pages.ForkRepo(w, pages.ForkRepoParams{
1371 LoggedInUser: user,
1372 Knots: knots,
1373 RepoInfo: f.RepoInfo(user),
1374 })
1375
1376 case http.MethodPost:
1377 l := rp.logger.With("handler", "ForkRepo")
1378
1379 targetKnot := r.FormValue("knot")
1380 if targetKnot == "" {
1381 rp.pages.Notice(w, "repo", "Invalid form submission—missing knot domain.")
1382 return
1383 }
1384 l = l.With("targetKnot", targetKnot)
1385
1386 ok, err := rp.enforcer.E.Enforce(user.Did, targetKnot, targetKnot, "repo:create")
1387 if err != nil || !ok {
1388 rp.pages.Notice(w, "repo", "You do not have permission to create a repo in this knot.")
1389 return
1390 }
1391
1392 // choose a name for a fork
1393 forkName := f.Name
1394 // this check is *only* to see if the forked repo name already exists
1395 // in the user's account.
1396 existingRepo, err := db.GetRepo(rp.db, user.Did, f.Name)
1397 if err != nil {
1398 if errors.Is(err, sql.ErrNoRows) {
1399 // no existing repo with this name found, we can use the name as is
1400 } else {
1401 log.Println("error fetching existing repo from db", err)
1402 rp.pages.Notice(w, "repo", "Failed to fork this repository. Try again later.")
1403 return
1404 }
1405 } else if existingRepo != nil {
1406 // repo with this name already exists, append random string
1407 forkName = fmt.Sprintf("%s-%s", forkName, randomString(3))
1408 }
1409 l = l.With("forkName", forkName)
1410
1411 uri := "https"
1412 if rp.config.Core.Dev {
1413 uri = "http"
1414 }
1415
1416 forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name)
1417 l = l.With("cloneUrl", forkSourceUrl)
1418
1419 sourceAt := f.RepoAt().String()
1420
1421 // create an atproto record for this fork
1422 rkey := tid.TID()
1423 repo := &db.Repo{
1424 Did: user.Did,
1425 Name: forkName,
1426 Knot: targetKnot,
1427 Rkey: rkey,
1428 Source: sourceAt,
1429 }
1430
1431 xrpcClient, err := rp.oauth.AuthorizedClient(r)
1432 if err != nil {
1433 l.Error("failed to create xrpcclient", "err", err)
1434 rp.pages.Notice(w, "repo", "Failed to fork repository.")
1435 return
1436 }
1437
1438 createdAt := time.Now().Format(time.RFC3339)
1439 atresp, err := xrpcClient.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
1440 Collection: tangled.RepoNSID,
1441 Repo: user.Did,
1442 Rkey: rkey,
1443 Record: &lexutil.LexiconTypeDecoder{
1444 Val: &tangled.Repo{
1445 Knot: repo.Knot,
1446 Name: repo.Name,
1447 CreatedAt: createdAt,
1448 Owner: user.Did,
1449 Source: &sourceAt,
1450 }},
1451 })
1452 if err != nil {
1453 l.Error("failed to write to PDS", "err", err)
1454 rp.pages.Notice(w, "repo", "Failed to announce repository creation.")
1455 return
1456 }
1457
1458 aturi := atresp.Uri
1459 l = l.With("aturi", aturi)
1460 l.Info("wrote to PDS")
1461
1462 tx, err := rp.db.BeginTx(r.Context(), nil)
1463 if err != nil {
1464 l.Info("txn failed", "err", err)
1465 rp.pages.Notice(w, "repo", "Failed to save repository information.")
1466 return
1467 }
1468
1469 // The rollback function reverts a few things on failure:
1470 // - the pending txn
1471 // - the ACLs
1472 // - the atproto record created
1473 rollback := func() {
1474 err1 := tx.Rollback()
1475 err2 := rp.enforcer.E.LoadPolicy()
1476 err3 := rollbackRecord(context.Background(), aturi, xrpcClient)
1477
1478 // ignore txn complete errors, this is okay
1479 if errors.Is(err1, sql.ErrTxDone) {
1480 err1 = nil
1481 }
1482
1483 if errs := errors.Join(err1, err2, err3); errs != nil {
1484 l.Error("failed to rollback changes", "errs", errs)
1485 return
1486 }
1487 }
1488 defer rollback()
1489
1490 client, err := rp.oauth.ServiceClient(
1491 r,
1492 oauth.WithService(targetKnot),
1493 oauth.WithLxm(tangled.RepoCreateNSID),
1494 oauth.WithDev(rp.config.Core.Dev),
1495 )
1496 if err != nil {
1497 l.Error("could not create service client", "err", err)
1498 rp.pages.Notice(w, "repo", "Failed to connect to knot server.")
1499 return
1500 }
1501
1502 err = tangled.RepoCreate(
1503 r.Context(),
1504 client,
1505 &tangled.RepoCreate_Input{
1506 Rkey: rkey,
1507 Source: &forkSourceUrl,
1508 },
1509 )
1510 if err := xrpcclient.HandleXrpcErr(err); err != nil {
1511 rp.pages.Notice(w, "repo", err.Error())
1512 return
1513 }
1514
1515 err = db.AddRepo(tx, repo)
1516 if err != nil {
1517 log.Println(err)
1518 rp.pages.Notice(w, "repo", "Failed to save repository information.")
1519 return
1520 }
1521
1522 // acls
1523 p, _ := securejoin.SecureJoin(user.Did, forkName)
1524 err = rp.enforcer.AddRepo(user.Did, targetKnot, p)
1525 if err != nil {
1526 log.Println(err)
1527 rp.pages.Notice(w, "repo", "Failed to set up repository permissions.")
1528 return
1529 }
1530
1531 err = tx.Commit()
1532 if err != nil {
1533 log.Println("failed to commit changes", err)
1534 http.Error(w, err.Error(), http.StatusInternalServerError)
1535 return
1536 }
1537
1538 err = rp.enforcer.E.SavePolicy()
1539 if err != nil {
1540 log.Println("failed to update ACLs", err)
1541 http.Error(w, err.Error(), http.StatusInternalServerError)
1542 return
1543 }
1544
1545 // reset the ATURI because the transaction completed successfully
1546 aturi = ""
1547
1548 rp.notifier.NewRepo(r.Context(), repo)
1549 rp.pages.HxLocation(w, fmt.Sprintf("/@%s/%s", user.Handle, forkName))
1550 }
1551}
1552
1553// this is used to rollback changes made to the PDS
1554//
1555// it is a no-op if the provided ATURI is empty
1556func rollbackRecord(ctx context.Context, aturi string, xrpcc *xrpcclient.Client) error {
1557 if aturi == "" {
1558 return nil
1559 }
1560
1561 parsed := syntax.ATURI(aturi)
1562
1563 collection := parsed.Collection().String()
1564 repo := parsed.Authority().String()
1565 rkey := parsed.RecordKey().String()
1566
1567 _, err := xrpcc.RepoDeleteRecord(ctx, &comatproto.RepoDeleteRecord_Input{
1568 Collection: collection,
1569 Repo: repo,
1570 Rkey: rkey,
1571 })
1572 return err
1573}
1574
1575func (rp *Repo) RepoCompareNew(w http.ResponseWriter, r *http.Request) {
1576 user := rp.oauth.GetUser(r)
1577 f, err := rp.repoResolver.Resolve(r)
1578 if err != nil {
1579 log.Println("failed to get repo and knot", err)
1580 return
1581 }
1582
1583 us, err := knotclient.NewUnsignedClient(f.Knot, rp.config.Core.Dev)
1584 if err != nil {
1585 log.Printf("failed to create unsigned client for %s", f.Knot)
1586 rp.pages.Error503(w)
1587 return
1588 }
1589
1590 result, err := us.Branches(f.OwnerDid(), f.Name)
1591 if err != nil {
1592 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1593 log.Println("failed to reach knotserver", err)
1594 return
1595 }
1596 branches := result.Branches
1597
1598 sortBranches(branches)
1599
1600 var defaultBranch string
1601 for _, b := range branches {
1602 if b.IsDefault {
1603 defaultBranch = b.Name
1604 }
1605 }
1606
1607 base := defaultBranch
1608 head := defaultBranch
1609
1610 params := r.URL.Query()
1611 queryBase := params.Get("base")
1612 queryHead := params.Get("head")
1613 if queryBase != "" {
1614 base = queryBase
1615 }
1616 if queryHead != "" {
1617 head = queryHead
1618 }
1619
1620 tags, err := us.Tags(f.OwnerDid(), f.Name)
1621 if err != nil {
1622 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1623 log.Println("failed to reach knotserver", err)
1624 return
1625 }
1626
1627 repoinfo := f.RepoInfo(user)
1628
1629 rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{
1630 LoggedInUser: user,
1631 RepoInfo: repoinfo,
1632 Branches: branches,
1633 Tags: tags.Tags,
1634 Base: base,
1635 Head: head,
1636 })
1637}
1638
1639func (rp *Repo) RepoCompare(w http.ResponseWriter, r *http.Request) {
1640 user := rp.oauth.GetUser(r)
1641 f, err := rp.repoResolver.Resolve(r)
1642 if err != nil {
1643 log.Println("failed to get repo and knot", err)
1644 return
1645 }
1646
1647 var diffOpts types.DiffOpts
1648 if d := r.URL.Query().Get("diff"); d == "split" {
1649 diffOpts.Split = true
1650 }
1651
1652 // if user is navigating to one of
1653 // /compare/{base}/{head}
1654 // /compare/{base}...{head}
1655 base := chi.URLParam(r, "base")
1656 head := chi.URLParam(r, "head")
1657 if base == "" && head == "" {
1658 rest := chi.URLParam(r, "*") // master...feature/xyz
1659 parts := strings.SplitN(rest, "...", 2)
1660 if len(parts) == 2 {
1661 base = parts[0]
1662 head = parts[1]
1663 }
1664 }
1665
1666 base, _ = url.PathUnescape(base)
1667 head, _ = url.PathUnescape(head)
1668
1669 if base == "" || head == "" {
1670 log.Printf("invalid comparison")
1671 rp.pages.Error404(w)
1672 return
1673 }
1674
1675 us, err := knotclient.NewUnsignedClient(f.Knot, rp.config.Core.Dev)
1676 if err != nil {
1677 log.Printf("failed to create unsigned client for %s", f.Knot)
1678 rp.pages.Error503(w)
1679 return
1680 }
1681
1682 branches, err := us.Branches(f.OwnerDid(), f.Name)
1683 if err != nil {
1684 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1685 log.Println("failed to reach knotserver", err)
1686 return
1687 }
1688
1689 tags, err := us.Tags(f.OwnerDid(), f.Name)
1690 if err != nil {
1691 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1692 log.Println("failed to reach knotserver", err)
1693 return
1694 }
1695
1696 formatPatch, err := us.Compare(f.OwnerDid(), f.Name, base, head)
1697 if err != nil {
1698 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1699 log.Println("failed to compare", err)
1700 return
1701 }
1702 diff := patchutil.AsNiceDiff(formatPatch.Patch, base)
1703
1704 repoinfo := f.RepoInfo(user)
1705
1706 rp.pages.RepoCompare(w, pages.RepoCompareParams{
1707 LoggedInUser: user,
1708 RepoInfo: repoinfo,
1709 Branches: branches.Branches,
1710 Tags: tags.Tags,
1711 Base: base,
1712 Head: head,
1713 Diff: &diff,
1714 DiffOpts: diffOpts,
1715 })
1716
1717}