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