forked from
tangled.org/core
Monorepo for Tangled
appview: revert use of knotmirror from appview
This reverts commit 35ceae65d94dc95c4095aa9aa56a8282c65c6369.
Manually perserved knotmirror changes.
Signed-off-by: Seongmin Lee <git@boltless.me>
+264
-107
+17
-22
appview/config/config.go
+17
-22
appview/config/config.go
···
46
46
PLCURL string `env:"URL, default=https://plc.directory"`
47
47
}
48
48
49
-
type KnotMirrorConfig struct {
50
-
Url string `env:"URL, default=https://mirror.tangled.network"`
51
-
}
52
-
53
49
type JetstreamConfig struct {
54
50
Endpoint string `env:"ENDPOINT, default=wss://jetstream1.us-east.bsky.network/subscribe"`
55
51
}
···
158
154
}
159
155
160
156
type Config struct {
161
-
Core CoreConfig `env:",prefix=TANGLED_"`
162
-
Jetstream JetstreamConfig `env:",prefix=TANGLED_JETSTREAM_"`
163
-
Knotstream ConsumerConfig `env:",prefix=TANGLED_KNOTSTREAM_"`
164
-
Spindlestream ConsumerConfig `env:",prefix=TANGLED_SPINDLESTREAM_"`
165
-
Resend ResendConfig `env:",prefix=TANGLED_RESEND_"`
166
-
Posthog PosthogConfig `env:",prefix=TANGLED_POSTHOG_"`
167
-
Camo CamoConfig `env:",prefix=TANGLED_CAMO_"`
168
-
Avatar AvatarConfig `env:",prefix=TANGLED_AVATAR_"`
169
-
OAuth OAuthConfig `env:",prefix=TANGLED_OAUTH_"`
170
-
Redis RedisConfig `env:",prefix=TANGLED_REDIS_"`
171
-
Plc PlcConfig `env:",prefix=TANGLED_PLC_"`
172
-
Pds PdsConfig `env:",prefix=TANGLED_PDS_"`
173
-
Cloudflare Cloudflare `env:",prefix=TANGLED_CLOUDFLARE_"`
174
-
Label LabelConfig `env:",prefix=TANGLED_LABEL_"`
175
-
Bluesky BlueskyConfig `env:",prefix=TANGLED_BLUESKY_"`
176
-
Sites SitesConfig `env:",prefix=TANGLED_SITES_"`
177
-
KnotMirror KnotMirrorConfig `env:",prefix=TANGLED_KNOTMIRROR_"`
178
-
Ogre OgreConfig `env:",prefix=TANGLED_OGRE_"`
157
+
Core CoreConfig `env:",prefix=TANGLED_"`
158
+
Jetstream JetstreamConfig `env:",prefix=TANGLED_JETSTREAM_"`
159
+
Knotstream ConsumerConfig `env:",prefix=TANGLED_KNOTSTREAM_"`
160
+
Spindlestream ConsumerConfig `env:",prefix=TANGLED_SPINDLESTREAM_"`
161
+
Resend ResendConfig `env:",prefix=TANGLED_RESEND_"`
162
+
Posthog PosthogConfig `env:",prefix=TANGLED_POSTHOG_"`
163
+
Camo CamoConfig `env:",prefix=TANGLED_CAMO_"`
164
+
Avatar AvatarConfig `env:",prefix=TANGLED_AVATAR_"`
165
+
OAuth OAuthConfig `env:",prefix=TANGLED_OAUTH_"`
166
+
Redis RedisConfig `env:",prefix=TANGLED_REDIS_"`
167
+
Plc PlcConfig `env:",prefix=TANGLED_PLC_"`
168
+
Pds PdsConfig `env:",prefix=TANGLED_PDS_"`
169
+
Cloudflare Cloudflare `env:",prefix=TANGLED_CLOUDFLARE_"`
170
+
Label LabelConfig `env:",prefix=TANGLED_LABEL_"`
171
+
Bluesky BlueskyConfig `env:",prefix=TANGLED_BLUESKY_"`
172
+
Sites SitesConfig `env:",prefix=TANGLED_SITES_"`
173
+
Ogre OgreConfig `env:",prefix=TANGLED_OGRE_"`
179
174
}
180
175
181
176
func LoadConfig(ctx context.Context) (*Config, error) {
+82
-16
appview/pulls/pulls.go
+82
-16
appview/pulls/pulls.go
···
413
413
return nil
414
414
}
415
415
416
-
xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url}
417
-
resp, err := tangled.GitTempGetBranch(r.Context(), xrpcc, branch, repo.RepoAt().String())
416
+
scheme := "http"
417
+
if !s.config.Core.Dev {
418
+
scheme = "https"
419
+
}
420
+
host := fmt.Sprintf("%s://%s", scheme, repo.Knot)
421
+
xrpcc := &indigoxrpc.Client{
422
+
Host: host,
423
+
}
424
+
425
+
resp, err := tangled.RepoBranch(r.Context(), xrpcc, branch, fmt.Sprintf("%s/%s", repo.Did, repo.Name))
418
426
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
419
427
return nil
420
428
}
···
430
438
return pages.Unknown
431
439
}
432
440
433
-
var sourceRepo syntax.ATURI
441
+
var knot, ownerDid, repoName string
442
+
434
443
if pull.PullSource.RepoAt != nil {
435
444
// fork-based pulls
436
-
sourceRepo = *pull.PullSource.RepoAt
445
+
sourceRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())
446
+
if err != nil {
447
+
s.logger.Error("failed to get source repo", "err", err)
448
+
return pages.Unknown
449
+
}
450
+
451
+
knot = sourceRepo.Knot
452
+
ownerDid = sourceRepo.Did
453
+
repoName = sourceRepo.Name
437
454
} else {
438
455
// pulls within the same repo
439
-
sourceRepo = repo.RepoAt()
456
+
knot = repo.Knot
457
+
ownerDid = repo.Did
458
+
repoName = repo.Name
459
+
}
460
+
461
+
scheme := "http"
462
+
if !s.config.Core.Dev {
463
+
scheme = "https"
464
+
}
465
+
host := fmt.Sprintf("%s://%s", scheme, knot)
466
+
xrpcc := &indigoxrpc.Client{
467
+
Host: host,
440
468
}
441
469
442
-
xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url}
443
-
branchResp, err := tangled.GitTempGetBranch(r.Context(), xrpcc, pull.PullSource.Branch, sourceRepo.String())
470
+
didSlashName := fmt.Sprintf("%s/%s", ownerDid, repoName)
471
+
branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, didSlashName)
444
472
if err != nil {
445
473
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
446
474
s.logger.Error("failed to call XRPC repo.branches", "err", xrpcerr)
···
878
906
879
907
switch r.Method {
880
908
case http.MethodGet:
881
-
xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url}
909
+
scheme := "http"
910
+
if !s.config.Core.Dev {
911
+
scheme = "https"
912
+
}
913
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
914
+
xrpcc := &indigoxrpc.Client{
915
+
Host: host,
916
+
}
882
917
883
-
xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
918
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
919
+
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
884
920
if err != nil {
885
921
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
886
922
s.logger.Error("failed to call XRPC repo.branches", "err", xrpcerr)
···
1501
1537
return
1502
1538
}
1503
1539
1504
-
xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url}
1540
+
scheme := "http"
1541
+
if !s.config.Core.Dev {
1542
+
scheme = "https"
1543
+
}
1544
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
1545
+
xrpcc := &indigoxrpc.Client{
1546
+
Host: host,
1547
+
}
1505
1548
1506
-
xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
1549
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
1550
+
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
1507
1551
if err != nil {
1552
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1553
+
s.logger.Error("failed to fetch branches", "err", xrpcerr)
1554
+
s.pages.Error503(w)
1555
+
return
1556
+
}
1508
1557
s.logger.Error("failed to fetch branches", "err", err)
1509
-
s.pages.Error503(w)
1510
1558
return
1511
1559
}
1512
1560
···
1561
1609
return
1562
1610
}
1563
1611
1564
-
xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url}
1565
-
1566
1612
forkVal := r.URL.Query().Get("fork")
1567
1613
repoString := strings.SplitN(forkVal, "/", 2)
1568
1614
forkOwnerDid := repoString[0]
···
1578
1624
return
1579
1625
}
1580
1626
1581
-
sourceXrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, repo.RepoAt().String())
1627
+
sourceScheme := "http"
1628
+
if !s.config.Core.Dev {
1629
+
sourceScheme = "https"
1630
+
}
1631
+
sourceHost := fmt.Sprintf("%s://%s", sourceScheme, repo.Knot)
1632
+
sourceXrpcc := &indigoxrpc.Client{
1633
+
Host: sourceHost,
1634
+
}
1635
+
1636
+
sourceRepo := fmt.Sprintf("%s/%s", forkOwnerDid, repo.Name)
1637
+
sourceXrpcBytes, err := tangled.RepoBranches(r.Context(), sourceXrpcc, "", 0, sourceRepo)
1582
1638
if err != nil {
1583
1639
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1584
1640
s.logger.Error("failed to call XRPC repo.branches for source", "err", xrpcerr)
···
1597
1653
return
1598
1654
}
1599
1655
1600
-
targetXrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
1656
+
targetScheme := "http"
1657
+
if !s.config.Core.Dev {
1658
+
targetScheme = "https"
1659
+
}
1660
+
targetHost := fmt.Sprintf("%s://%s", targetScheme, f.Knot)
1661
+
targetXrpcc := &indigoxrpc.Client{
1662
+
Host: targetHost,
1663
+
}
1664
+
1665
+
targetRepo := fmt.Sprintf("%s/%s", f.Did, f.Name)
1666
+
targetXrpcBytes, err := tangled.RepoBranches(r.Context(), targetXrpcc, "", 0, targetRepo)
1601
1667
if err != nil {
1602
1668
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
1603
1669
s.logger.Error("failed to call XRPC repo.branches for target", "err", xrpcerr)
+19
-9
appview/repo/archive.go
+19
-9
appview/repo/archive.go
···
8
8
"strings"
9
9
10
10
"github.com/go-chi/chi/v5"
11
-
"tangled.org/core/api/tangled"
12
11
)
13
12
14
13
func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {
···
21
20
l.Error("failed to get repo and knot", "err", err)
22
21
return
23
22
}
23
+
scheme := "http"
24
+
if !rp.config.Core.Dev {
25
+
scheme = "https"
26
+
}
27
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
28
+
didSlashRepo := f.DidSlashRepo()
24
29
25
30
// build the xrpc url
31
+
u, err := url.Parse(host)
32
+
if err != nil {
33
+
l.Error("failed to parse host URL", "err", err)
34
+
rp.pages.Error503(w)
35
+
return
36
+
}
37
+
38
+
u.Path = "/xrpc/sh.tangled.repo.archive"
26
39
query := url.Values{}
27
-
query.Set("repo", f.RepoAt().String())
28
-
query.Set("ref", ref)
29
40
query.Set("format", "tar.gz")
30
41
query.Set("prefix", r.URL.Query().Get("prefix"))
31
-
xrpcURL := fmt.Sprintf(
32
-
"%s/xrpc/%s?%s",
33
-
rp.config.KnotMirror.Url,
34
-
tangled.GitTempGetArchiveNSID,
35
-
query.Encode(),
36
-
)
42
+
query.Set("ref", ref)
43
+
query.Set("repo", didSlashRepo)
44
+
u.RawQuery = query.Encode()
45
+
46
+
xrpcURL := u.String()
37
47
38
48
// make the get request
39
49
resp, err := http.Get(xrpcURL)
+10
-2
appview/repo/artifact.go
+10
-2
appview/repo/artifact.go
···
313
313
return nil, err
314
314
}
315
315
316
-
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
316
+
scheme := "http"
317
+
if !rp.config.Core.Dev {
318
+
scheme = "https"
319
+
}
320
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
321
+
xrpcc := &indigoxrpc.Client{
322
+
Host: host,
323
+
}
317
324
318
-
xrpcBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 0, f.RepoAt().String())
325
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
326
+
xrpcBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo)
319
327
if err != nil {
320
328
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
321
329
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
+12
-5
appview/repo/branches.go
+12
-5
appview/repo/branches.go
···
21
21
l.Error("failed to get repo and knot", "err", err)
22
22
return
23
23
}
24
-
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
25
-
26
-
xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
27
-
if err != nil {
28
-
l.Error("failed to call XRPC repo.branches", "err", err)
24
+
scheme := "http"
25
+
if !rp.config.Core.Dev {
26
+
scheme = "https"
27
+
}
28
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
29
+
xrpcc := &indigoxrpc.Client{
30
+
Host: host,
31
+
}
32
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
33
+
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
34
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
35
+
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
29
36
rp.pages.Error503(w)
30
37
return
31
38
}
+11
-3
appview/repo/compare.go
+11
-3
appview/repo/compare.go
···
27
27
return
28
28
}
29
29
30
-
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
30
+
scheme := "http"
31
+
if !rp.config.Core.Dev {
32
+
scheme = "https"
33
+
}
34
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
35
+
xrpcc := &indigoxrpc.Client{
36
+
Host: host,
37
+
}
31
38
32
-
branchBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
39
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
40
+
branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
33
41
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
34
42
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
35
43
rp.pages.Error503(w)
···
66
74
head = queryHead
67
75
}
68
76
69
-
tagBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoAt().String())
77
+
tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
70
78
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
71
79
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
72
80
rp.pages.Error503(w)
+52
-27
appview/repo/index.go
+52
-27
appview/repo/index.go
···
22
22
"tangled.org/core/appview/db"
23
23
"tangled.org/core/appview/models"
24
24
"tangled.org/core/appview/pages"
25
+
"tangled.org/core/appview/xrpcclient"
25
26
"tangled.org/core/orm"
26
27
"tangled.org/core/types"
27
28
···
41
42
return
42
43
}
43
44
45
+
scheme := "http"
46
+
if !rp.config.Core.Dev {
47
+
scheme = "https"
48
+
}
49
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
50
+
xrpcc := &indigoxrpc.Client{
51
+
Host: host,
52
+
}
53
+
44
54
user := rp.oauth.GetMultiAccountUser(r)
45
55
46
56
// Build index response from multiple XRPC calls
47
-
result, err := rp.buildIndexResponse(r.Context(), f, ref)
48
-
if err != nil {
49
-
l.Error("failed to build index response", "err", err)
50
-
rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
51
-
LoggedInUser: user,
52
-
KnotUnreachable: true,
53
-
RepoInfo: rp.repoResolver.GetRepoInfo(r, user),
54
-
})
55
-
return
57
+
result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)
58
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
59
+
if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {
60
+
l.Error("failed to call XRPC repo.index", "err", err)
61
+
rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
62
+
LoggedInUser: user,
63
+
NeedsKnotUpgrade: true,
64
+
RepoInfo: rp.repoResolver.GetRepoInfo(r, user),
65
+
})
66
+
return
67
+
} else {
68
+
l.Error("failed to build index response", "err", err)
69
+
rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
70
+
LoggedInUser: user,
71
+
KnotUnreachable: true,
72
+
RepoInfo: rp.repoResolver.GetRepoInfo(r, user),
73
+
})
74
+
return
75
+
}
56
76
}
57
77
58
78
tagMap := make(map[string][]string)
···
115
135
var languageInfo []types.RepoLanguageDetails
116
136
if !result.IsEmpty {
117
137
// TODO: a bit dirty
118
-
languageInfo, err = rp.getLanguageInfo(r.Context(), l, f, result.Ref, ref == "")
138
+
languageInfo, err = rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "")
119
139
if err != nil {
120
140
l.Warn("failed to compute language percentages", "err", err)
121
141
// non-fatal
···
152
172
ctx context.Context,
153
173
l *slog.Logger,
154
174
repo *models.Repo,
175
+
xrpcc *indigoxrpc.Client,
155
176
currentRef string,
156
177
isDefaultRef bool,
157
178
) ([]types.RepoLanguageDetails, error) {
···
164
185
165
186
if err != nil || langs == nil {
166
187
// non-fatal, fetch langs from ks via XRPC
167
-
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
168
-
ls, err := tangled.GitTempListLanguages(ctx, xrpcc, currentRef, repo.RepoAt().String())
188
+
didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
189
+
ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, didSlashRepo)
169
190
if err != nil {
170
-
return nil, fmt.Errorf("calling knotmirror git.listLanguages: %w", err)
191
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
192
+
l.Error("failed to call XRPC repo.languages", "err", xrpcerr)
193
+
return nil, xrpcerr
194
+
}
195
+
return nil, err
171
196
}
172
197
173
198
if ls == nil || ls.Languages == nil {
···
236
261
}
237
262
238
263
// buildIndexResponse creates a RepoIndexResponse by combining multiple xrpc calls in parallel
239
-
func (rp *Repo) buildIndexResponse(ctx context.Context, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) {
240
-
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
264
+
func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) {
265
+
didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
241
266
242
267
// first get branches to determine the ref if not specified
243
-
branchesBytes, err := tangled.GitTempListBranches(ctx, xrpcc, "", 0, repo.RepoAt().String())
268
+
branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, didSlashRepo)
244
269
if err != nil {
245
-
return nil, fmt.Errorf("calling knotmirror git.listBranches: %w", err)
270
+
return nil, fmt.Errorf("failed to call repoBranches: %w", err)
246
271
}
247
272
248
273
var branchesResp types.RepoBranchesResponse
···
274
299
275
300
var (
276
301
tagsResp types.RepoTagsResponse
277
-
treeResp *tangled.GitTempGetTree_Output
302
+
treeResp *tangled.RepoTree_Output
278
303
logResp types.RepoLogResponse
279
304
readmeContent string
280
305
readmeFileName string
···
282
307
283
308
// tags
284
309
wg.Go(func() {
285
-
tagsBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 0, repo.RepoAt().String())
310
+
tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, didSlashRepo)
286
311
if err != nil {
287
-
errs = errors.Join(errs, fmt.Errorf("failed to call git.ListTags: %w", err))
312
+
errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err))
288
313
return
289
314
}
290
315
291
316
if err := json.Unmarshal(tagsBytes, &tagsResp); err != nil {
292
-
errs = errors.Join(errs, fmt.Errorf("failed to unmarshal git.ListTags: %w", err))
317
+
errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoTags: %w", err))
293
318
}
294
319
})
295
320
296
321
// tree/files
297
322
wg.Go(func() {
298
-
resp, err := tangled.GitTempGetTree(ctx, xrpcc, "", ref, repo.RepoAt().String())
323
+
resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, didSlashRepo)
299
324
if err != nil {
300
-
errs = errors.Join(errs, fmt.Errorf("failed to call git.GetTree: %w", err))
325
+
errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err))
301
326
return
302
327
}
303
328
treeResp = resp
···
305
330
306
331
// commits
307
332
wg.Go(func() {
308
-
logBytes, err := tangled.GitTempListCommits(ctx, xrpcc, "", 50, ref, repo.RepoAt().String())
333
+
logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, didSlashRepo)
309
334
if err != nil {
310
-
errs = errors.Join(errs, fmt.Errorf("failed to call git.ListCommits: %w", err))
335
+
errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err))
311
336
return
312
337
}
313
338
314
339
if err := json.Unmarshal(logBytes, &logResp); err != nil {
315
-
errs = errors.Join(errs, fmt.Errorf("failed to unmarshal git.ListCommits: %w", err))
340
+
errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoLog: %w", err))
316
341
}
317
342
})
318
343
···
354
379
Readme: readmeContent,
355
380
ReadmeFileName: readmeFileName,
356
381
Commits: logResp.Commits,
357
-
Description: "",
382
+
Description: logResp.Description,
358
383
Files: files,
359
384
Branches: branchesResp.Branches,
360
385
Tags: tagsResp.Tags,
+18
-10
appview/repo/log.go
+18
-10
appview/repo/log.go
···
40
40
ref := chi.URLParam(r, "ref")
41
41
ref, _ = url.PathUnescape(ref)
42
42
43
-
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
43
+
scheme := "http"
44
+
if !rp.config.Core.Dev {
45
+
scheme = "https"
46
+
}
47
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
48
+
xrpcc := &indigoxrpc.Client{
49
+
Host: host,
50
+
}
44
51
45
52
limit := int64(60)
46
53
cursor := ""
···
50
57
cursor = strconv.Itoa(offset)
51
58
}
52
59
53
-
xrpcBytes, err := tangled.GitTempListCommits(r.Context(), xrpcc, cursor, limit, ref, f.RepoAt().String())
54
-
if err != nil {
55
-
l.Error("failed to call XRPC repo.log", "err", err)
60
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
61
+
xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)
62
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
63
+
l.Error("failed to call XRPC repo.log", "err", xrpcerr)
56
64
rp.pages.Error503(w)
57
65
return
58
66
}
···
64
72
return
65
73
}
66
74
67
-
tagBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoAt().String())
68
-
if err != nil {
69
-
l.Error("failed to call XRPC repo.tags", "err", err)
75
+
tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
76
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
77
+
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
70
78
rp.pages.Error503(w)
71
79
return
72
80
}
···
85
93
}
86
94
}
87
95
88
-
branchBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
89
-
if err != nil {
90
-
l.Error("failed to call XRPC repo.branches", "err", err)
96
+
branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
97
+
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
98
+
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
91
99
rp.pages.Error503(w)
92
100
return
93
101
}
+10
-2
appview/repo/settings.go
+10
-2
appview/repo/settings.go
···
386
386
f, err := rp.repoResolver.Resolve(r)
387
387
user := rp.oauth.GetMultiAccountUser(r)
388
388
389
-
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
389
+
scheme := "http"
390
+
if !rp.config.Core.Dev {
391
+
scheme = "https"
392
+
}
393
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
394
+
xrpcc := &indigoxrpc.Client{
395
+
Host: host,
396
+
}
390
397
391
-
xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
398
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
399
+
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
392
400
var result types.RepoBranchesResponse
393
401
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
394
402
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
+10
-3
appview/repo/tree.go
+10
-3
appview/repo/tree.go
···
33
33
treePath := chi.URLParam(r, "*")
34
34
treePath, _ = url.PathUnescape(treePath)
35
35
treePath = strings.TrimSuffix(treePath, "/")
36
-
37
-
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
38
-
xrpcResp, err := tangled.GitTempGetTree(r.Context(), xrpcc, treePath, ref, f.RepoAt().String())
36
+
scheme := "http"
37
+
if !rp.config.Core.Dev {
38
+
scheme = "https"
39
+
}
40
+
host := fmt.Sprintf("%s://%s", scheme, f.Knot)
41
+
xrpcc := &indigoxrpc.Client{
42
+
Host: host,
43
+
}
44
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
45
+
xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)
39
46
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
40
47
l.Error("failed to call XRPC repo.tree", "err", xrpcerr)
41
48
rp.pages.Error503(w)