serendipty01.dev
+6
-2
appview/issues/issues.go
+6
-2
appview/issues/issues.go
···
101
)
102
if err != nil {
103
l.Error("failed to fetch labels", "err", err)
104
+
rp.pages.Error503(w, pages.ErrorPageParams{
105
+
LoggedInUser: user,
106
+
})
107
return
108
}
109
···
828
)
829
if err != nil {
830
l.Error("failed to fetch labels", "err", err)
831
+
rp.pages.Error503(w, pages.ErrorPageParams{
832
+
LoggedInUser: user,
833
+
})
834
return
835
}
836
+2
-2
appview/pages/pages.go
+2
-2
appview/pages/pages.go
+30
-10
appview/pulls/pulls.go
+30
-10
appview/pulls/pulls.go
···
205
)
206
if err != nil {
207
log.Println("failed to fetch labels", err)
208
-
s.pages.Error503(w)
209
return
210
}
211
···
636
)
637
if err != nil {
638
log.Println("failed to fetch labels", err)
639
-
s.pages.Error503(w)
640
return
641
}
642
···
785
if err != nil {
786
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
787
log.Println("failed to call XRPC repo.branches", xrpcerr)
788
-
s.pages.Error503(w)
789
return
790
}
791
log.Println("failed to fetch branches", err)
···
795
var result types.RepoBranchesResponse
796
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
797
log.Println("failed to decode XRPC response", err)
798
-
s.pages.Error503(w)
799
return
800
}
801
···
1392
if err != nil {
1393
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1394
log.Println("failed to call XRPC repo.branches", xrpcerr)
1395
-
s.pages.Error503(w)
1396
return
1397
}
1398
log.Println("failed to fetch branches", err)
···
1402
var result types.RepoBranchesResponse
1403
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
1404
log.Println("failed to decode XRPC response", err)
1405
-
s.pages.Error503(w)
1406
return
1407
}
1408
···
1484
if err != nil {
1485
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1486
log.Println("failed to call XRPC repo.branches for source", xrpcerr)
1487
-
s.pages.Error503(w)
1488
return
1489
}
1490
log.Println("failed to fetch source branches", err)
···
1495
var sourceBranches types.RepoBranchesResponse
1496
if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil {
1497
log.Println("failed to decode source branches XRPC response", err)
1498
-
s.pages.Error503(w)
1499
return
1500
}
1501
···
1513
if err != nil {
1514
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1515
log.Println("failed to call XRPC repo.branches for target", xrpcerr)
1516
-
s.pages.Error503(w)
1517
return
1518
}
1519
log.Println("failed to fetch target branches", err)
···
1524
var targetBranches types.RepoBranchesResponse
1525
if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil {
1526
log.Println("failed to decode target branches XRPC response", err)
1527
-
s.pages.Error503(w)
1528
return
1529
}
1530
···
205
)
206
if err != nil {
207
log.Println("failed to fetch labels", err)
208
+
s.pages.Error503(w, pages.ErrorPageParams{
209
+
LoggedInUser: user,
210
+
})
211
return
212
}
213
···
638
)
639
if err != nil {
640
log.Println("failed to fetch labels", err)
641
+
s.pages.Error503(w, pages.ErrorPageParams{
642
+
LoggedInUser: user,
643
+
})
644
return
645
}
646
···
789
if err != nil {
790
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
791
log.Println("failed to call XRPC repo.branches", xrpcerr)
792
+
s.pages.Error503(w, pages.ErrorPageParams{
793
+
LoggedInUser: user,
794
+
})
795
return
796
}
797
log.Println("failed to fetch branches", err)
···
801
var result types.RepoBranchesResponse
802
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
803
log.Println("failed to decode XRPC response", err)
804
+
s.pages.Error503(w, pages.ErrorPageParams{
805
+
LoggedInUser: user,
806
+
})
807
return
808
}
809
···
1400
if err != nil {
1401
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1402
log.Println("failed to call XRPC repo.branches", xrpcerr)
1403
+
s.pages.Error503(w, pages.ErrorPageParams{
1404
+
LoggedInUser: user,
1405
+
})
1406
return
1407
}
1408
log.Println("failed to fetch branches", err)
···
1412
var result types.RepoBranchesResponse
1413
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
1414
log.Println("failed to decode XRPC response", err)
1415
+
s.pages.Error503(w, pages.ErrorPageParams{
1416
+
LoggedInUser: user,
1417
+
})
1418
return
1419
}
1420
···
1496
if err != nil {
1497
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1498
log.Println("failed to call XRPC repo.branches for source", xrpcerr)
1499
+
s.pages.Error503(w, pages.ErrorPageParams{
1500
+
LoggedInUser: user,
1501
+
})
1502
return
1503
}
1504
log.Println("failed to fetch source branches", err)
···
1509
var sourceBranches types.RepoBranchesResponse
1510
if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil {
1511
log.Println("failed to decode source branches XRPC response", err)
1512
+
s.pages.Error503(w, pages.ErrorPageParams{
1513
+
LoggedInUser: user,
1514
+
})
1515
return
1516
}
1517
···
1529
if err != nil {
1530
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1531
log.Println("failed to call XRPC repo.branches for target", xrpcerr)
1532
+
s.pages.Error503(w, pages.ErrorPageParams{
1533
+
LoggedInUser: user,
1534
+
})
1535
return
1536
}
1537
log.Println("failed to fetch target branches", err)
···
1542
var targetBranches types.RepoBranchesResponse
1543
if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil {
1544
log.Println("failed to decode target branches XRPC response", err)
1545
+
s.pages.Error503(w, pages.ErrorPageParams{
1546
+
LoggedInUser: user,
1547
+
})
1548
return
1549
}
1550
+3
-1
appview/repo/index.go
+3
-1
appview/repo/index.go
+76
-31
appview/repo/repo.go
+76
-31
appview/repo/repo.go
···
90
91
func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {
92
l := rp.logger.With("handler", "DownloadArchive")
93
94
ref := chi.URLParam(r, "ref")
95
ref, _ = url.PathUnescape(ref)
···
113
archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo)
114
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
115
l.Error("failed to call XRPC repo.archive", "err", xrpcerr)
116
-
rp.pages.Error503(w)
117
return
118
}
119
···
130
131
func (rp *Repo) RepoLog(w http.ResponseWriter, r *http.Request) {
132
l := rp.logger.With("handler", "RepoLog")
133
134
f, err := rp.repoResolver.Resolve(r)
135
if err != nil {
···
169
xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)
170
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
171
l.Error("failed to call XRPC repo.log", "err", xrpcerr)
172
-
rp.pages.Error503(w)
173
return
174
}
175
176
var xrpcResp types.RepoLogResponse
177
if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil {
178
l.Error("failed to decode XRPC response", "err", err)
179
-
rp.pages.Error503(w)
180
return
181
}
182
183
tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
184
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
185
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
186
-
rp.pages.Error503(w)
187
return
188
}
189
···
204
branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
205
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
206
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
207
-
rp.pages.Error503(w)
208
return
209
}
210
···
216
}
217
}
218
}
219
-
220
-
user := rp.oauth.GetUser(r)
221
222
emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true)
223
if err != nil {
···
388
xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)
389
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
390
l.Error("failed to call XRPC repo.diff", "err", xrpcerr)
391
-
rp.pages.Error503(w)
392
return
393
}
394
395
var result types.RepoCommitResponse
396
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
397
l.Error("failed to decode XRPC response", "err", err)
398
-
rp.pages.Error503(w)
399
return
400
}
401
···
433
434
func (rp *Repo) RepoTree(w http.ResponseWriter, r *http.Request) {
435
l := rp.logger.With("handler", "RepoTree")
436
437
f, err := rp.repoResolver.Resolve(r)
438
if err != nil {
···
462
xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)
463
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
464
l.Error("failed to call XRPC repo.tree", "err", xrpcerr)
465
-
rp.pages.Error503(w)
466
return
467
}
468
···
514
return
515
}
516
517
-
user := rp.oauth.GetUser(r)
518
-
519
var breadcrumbs [][]string
520
breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})
521
if treePath != "" {
···
537
538
func (rp *Repo) RepoTags(w http.ResponseWriter, r *http.Request) {
539
l := rp.logger.With("handler", "RepoTags")
540
541
f, err := rp.repoResolver.Resolve(r)
542
if err != nil {
···
557
xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
558
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
559
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
560
-
rp.pages.Error503(w)
561
return
562
}
563
564
var result types.RepoTagsResponse
565
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
566
l.Error("failed to decode XRPC response", "err", err)
567
-
rp.pages.Error503(w)
568
return
569
}
570
···
596
}
597
}
598
599
-
user := rp.oauth.GetUser(r)
600
rp.pages.RepoTags(w, pages.RepoTagsParams{
601
LoggedInUser: user,
602
RepoInfo: f.RepoInfo(user),
···
608
609
func (rp *Repo) RepoBranches(w http.ResponseWriter, r *http.Request) {
610
l := rp.logger.With("handler", "RepoBranches")
611
612
f, err := rp.repoResolver.Resolve(r)
613
if err != nil {
···
628
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
629
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
630
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
631
-
rp.pages.Error503(w)
632
return
633
}
634
635
var result types.RepoBranchesResponse
636
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
637
l.Error("failed to decode XRPC response", "err", err)
638
-
rp.pages.Error503(w)
639
return
640
}
641
642
sortBranches(result.Branches)
643
644
-
user := rp.oauth.GetUser(r)
645
rp.pages.RepoBranches(w, pages.RepoBranchesParams{
646
LoggedInUser: user,
647
RepoInfo: f.RepoInfo(user),
···
700
701
func (rp *Repo) RepoBlob(w http.ResponseWriter, r *http.Request) {
702
l := rp.logger.With("handler", "RepoBlob")
703
704
f, err := rp.repoResolver.Resolve(r)
705
if err != nil {
···
726
resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)
727
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
728
l.Error("failed to call XRPC repo.blob", "err", xrpcerr)
729
-
rp.pages.Error503(w)
730
return
731
}
732
···
798
sizeHint = uint64(len(resp.Content))
799
}
800
801
-
user := rp.oauth.GetUser(r)
802
-
803
// Determine if content is binary (dereference pointer)
804
isBinary := false
805
if resp.IsBinary != nil {
···
826
827
func (rp *Repo) RepoBlobRaw(w http.ResponseWriter, r *http.Request) {
828
l := rp.logger.With("handler", "RepoBlobRaw")
829
830
f, err := rp.repoResolver.Resolve(r)
831
if err != nil {
···
874
resp, err := client.Do(req)
875
if err != nil {
876
l.Error("failed to reach knotserver", "err", err)
877
-
rp.pages.Error503(w)
878
return
879
}
880
defer resp.Body.Close()
···
1965
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
1966
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1967
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
1968
-
rp.pages.Error503(w)
1969
return
1970
}
1971
1972
var result types.RepoBranchesResponse
1973
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
1974
l.Error("failed to decode XRPC response", "err", err)
1975
-
rp.pages.Error503(w)
1976
return
1977
}
1978
1979
defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", models.DefaultLabelDefs()))
1980
if err != nil {
1981
l.Error("failed to fetch labels", "err", err)
1982
-
rp.pages.Error503(w)
1983
return
1984
}
1985
1986
labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))
1987
if err != nil {
1988
l.Error("failed to fetch labels", "err", err)
1989
-
rp.pages.Error503(w)
1990
return
1991
}
1992
// remove default labels from the labels list, if present
···
2420
branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
2421
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
2422
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
2423
-
rp.pages.Error503(w)
2424
return
2425
}
2426
···
2457
tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
2458
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
2459
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
2460
-
rp.pages.Error503(w)
2461
return
2462
}
2463
···
2534
branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
2535
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
2536
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
2537
-
rp.pages.Error503(w)
2538
return
2539
}
2540
···
2548
tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
2549
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
2550
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
2551
-
rp.pages.Error503(w)
2552
return
2553
}
2554
···
2562
compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head)
2563
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
2564
l.Error("failed to call XRPC repo.compare", "err", xrpcerr)
2565
-
rp.pages.Error503(w)
2566
return
2567
}
2568
···
90
91
func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {
92
l := rp.logger.With("handler", "DownloadArchive")
93
+
user := rp.oauth.GetUser(r)
94
95
ref := chi.URLParam(r, "ref")
96
ref, _ = url.PathUnescape(ref)
···
114
archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo)
115
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
116
l.Error("failed to call XRPC repo.archive", "err", xrpcerr)
117
+
rp.pages.Error503(w, pages.ErrorPageParams{
118
+
LoggedInUser: user,
119
+
})
120
return
121
}
122
···
133
134
func (rp *Repo) RepoLog(w http.ResponseWriter, r *http.Request) {
135
l := rp.logger.With("handler", "RepoLog")
136
+
user := rp.oauth.GetUser(r)
137
138
f, err := rp.repoResolver.Resolve(r)
139
if err != nil {
···
173
xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)
174
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
175
l.Error("failed to call XRPC repo.log", "err", xrpcerr)
176
+
rp.pages.Error503(w, pages.ErrorPageParams{
177
+
LoggedInUser: user,
178
+
})
179
return
180
}
181
182
var xrpcResp types.RepoLogResponse
183
if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil {
184
l.Error("failed to decode XRPC response", "err", err)
185
+
rp.pages.Error503(w, pages.ErrorPageParams{
186
+
LoggedInUser: user,
187
+
})
188
return
189
}
190
191
tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
192
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
193
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
194
+
rp.pages.Error503(w, pages.ErrorPageParams{
195
+
LoggedInUser: user,
196
+
})
197
return
198
}
199
···
214
branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
215
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
216
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
217
+
rp.pages.Error503(w, pages.ErrorPageParams{
218
+
LoggedInUser: user,
219
+
})
220
return
221
}
222
···
228
}
229
}
230
}
231
232
emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true)
233
if err != nil {
···
398
xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)
399
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
400
l.Error("failed to call XRPC repo.diff", "err", xrpcerr)
401
+
rp.pages.Error503(w, pages.ErrorPageParams{
402
+
LoggedInUser: user,
403
+
})
404
return
405
}
406
407
var result types.RepoCommitResponse
408
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
409
l.Error("failed to decode XRPC response", "err", err)
410
+
rp.pages.Error503(w, pages.ErrorPageParams{
411
+
LoggedInUser: user,
412
+
})
413
return
414
}
415
···
447
448
func (rp *Repo) RepoTree(w http.ResponseWriter, r *http.Request) {
449
l := rp.logger.With("handler", "RepoTree")
450
+
user := rp.oauth.GetUser(r)
451
452
f, err := rp.repoResolver.Resolve(r)
453
if err != nil {
···
477
xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)
478
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
479
l.Error("failed to call XRPC repo.tree", "err", xrpcerr)
480
+
rp.pages.Error503(w, pages.ErrorPageParams{
481
+
LoggedInUser: user,
482
+
})
483
return
484
}
485
···
531
return
532
}
533
534
var breadcrumbs [][]string
535
breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})
536
if treePath != "" {
···
552
553
func (rp *Repo) RepoTags(w http.ResponseWriter, r *http.Request) {
554
l := rp.logger.With("handler", "RepoTags")
555
+
user := rp.oauth.GetUser(r)
556
557
f, err := rp.repoResolver.Resolve(r)
558
if err != nil {
···
573
xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
574
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
575
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
576
+
rp.pages.Error503(w, pages.ErrorPageParams{
577
+
LoggedInUser: user,
578
+
})
579
return
580
}
581
582
var result types.RepoTagsResponse
583
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
584
l.Error("failed to decode XRPC response", "err", err)
585
+
rp.pages.Error503(w, pages.ErrorPageParams{
586
+
LoggedInUser: user,
587
+
})
588
return
589
}
590
···
616
}
617
}
618
619
rp.pages.RepoTags(w, pages.RepoTagsParams{
620
LoggedInUser: user,
621
RepoInfo: f.RepoInfo(user),
···
627
628
func (rp *Repo) RepoBranches(w http.ResponseWriter, r *http.Request) {
629
l := rp.logger.With("handler", "RepoBranches")
630
+
user := rp.oauth.GetUser(r)
631
632
f, err := rp.repoResolver.Resolve(r)
633
if err != nil {
···
648
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
649
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
650
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
651
+
rp.pages.Error503(w, pages.ErrorPageParams{
652
+
LoggedInUser: user,
653
+
})
654
return
655
}
656
657
var result types.RepoBranchesResponse
658
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
659
l.Error("failed to decode XRPC response", "err", err)
660
+
rp.pages.Error503(w, pages.ErrorPageParams{
661
+
LoggedInUser: user,
662
+
})
663
return
664
}
665
666
sortBranches(result.Branches)
667
668
rp.pages.RepoBranches(w, pages.RepoBranchesParams{
669
LoggedInUser: user,
670
RepoInfo: f.RepoInfo(user),
···
723
724
func (rp *Repo) RepoBlob(w http.ResponseWriter, r *http.Request) {
725
l := rp.logger.With("handler", "RepoBlob")
726
+
user := rp.oauth.GetUser(r)
727
728
f, err := rp.repoResolver.Resolve(r)
729
if err != nil {
···
750
resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)
751
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
752
l.Error("failed to call XRPC repo.blob", "err", xrpcerr)
753
+
rp.pages.Error503(w, pages.ErrorPageParams{
754
+
LoggedInUser: user,
755
+
})
756
return
757
}
758
···
824
sizeHint = uint64(len(resp.Content))
825
}
826
827
// Determine if content is binary (dereference pointer)
828
isBinary := false
829
if resp.IsBinary != nil {
···
850
851
func (rp *Repo) RepoBlobRaw(w http.ResponseWriter, r *http.Request) {
852
l := rp.logger.With("handler", "RepoBlobRaw")
853
+
user := rp.oauth.GetUser(r)
854
855
f, err := rp.repoResolver.Resolve(r)
856
if err != nil {
···
899
resp, err := client.Do(req)
900
if err != nil {
901
l.Error("failed to reach knotserver", "err", err)
902
+
rp.pages.Error503(w, pages.ErrorPageParams{
903
+
LoggedInUser: user,
904
+
})
905
return
906
}
907
defer resp.Body.Close()
···
1992
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
1993
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1994
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
1995
+
rp.pages.Error503(w, pages.ErrorPageParams{
1996
+
LoggedInUser: user,
1997
+
})
1998
return
1999
}
2000
2001
var result types.RepoBranchesResponse
2002
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
2003
l.Error("failed to decode XRPC response", "err", err)
2004
+
rp.pages.Error503(w, pages.ErrorPageParams{
2005
+
LoggedInUser: user,
2006
+
})
2007
return
2008
}
2009
2010
defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", models.DefaultLabelDefs()))
2011
if err != nil {
2012
l.Error("failed to fetch labels", "err", err)
2013
+
rp.pages.Error503(w, pages.ErrorPageParams{
2014
+
LoggedInUser: user,
2015
+
})
2016
return
2017
}
2018
2019
labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))
2020
if err != nil {
2021
l.Error("failed to fetch labels", "err", err)
2022
+
rp.pages.Error503(w, pages.ErrorPageParams{
2023
+
LoggedInUser: user,
2024
+
})
2025
return
2026
}
2027
// remove default labels from the labels list, if present
···
2455
branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
2456
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
2457
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
2458
+
rp.pages.Error503(w, pages.ErrorPageParams{
2459
+
LoggedInUser: user,
2460
+
})
2461
return
2462
}
2463
···
2494
tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
2495
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
2496
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
2497
+
rp.pages.Error503(w, pages.ErrorPageParams{
2498
+
LoggedInUser: user,
2499
+
})
2500
return
2501
}
2502
···
2573
branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
2574
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
2575
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
2576
+
rp.pages.Error503(w, pages.ErrorPageParams{
2577
+
LoggedInUser: user,
2578
+
})
2579
return
2580
}
2581
···
2589
tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
2590
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
2591
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
2592
+
rp.pages.Error503(w, pages.ErrorPageParams{
2593
+
LoggedInUser: user,
2594
+
})
2595
return
2596
}
2597
···
2605
compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head)
2606
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
2607
l.Error("failed to call XRPC repo.compare", "err", xrpcerr)
2608
+
rp.pages.Error503(w, pages.ErrorPageParams{
2609
+
LoggedInUser: user,
2610
+
})
2611
return
2612
}
2613
+6
-2
appview/state/gfi.go
+6
-2
appview/state/gfi.go
···
28
repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel))
29
if err != nil {
30
log.Println("failed to get repo labels", err)
31
-
s.pages.Error503(w)
32
return
33
}
34
···
57
)
58
if err != nil {
59
log.Println("failed to get issues", err)
60
-
s.pages.Error503(w)
61
return
62
}
63
···
28
repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel))
29
if err != nil {
30
log.Println("failed to get repo labels", err)
31
+
s.pages.Error503(w, pages.ErrorPageParams{
32
+
LoggedInUser: user,
33
+
})
34
return
35
}
36
···
59
)
60
if err != nil {
61
log.Println("failed to get issues", err)
62
+
s.pages.Error503(w, pages.ErrorPageParams{
63
+
LoggedInUser: user,
64
+
})
65
return
66
}
67