Monorepo for Tangled
tangled.org
knotmirror: temp git xrpc to use repodid
Lewis: May this revision serve well! <lewis@tangled.org>
author
Lewis
committer
Tangled
date
(May 14, 2026, 1:42 PM +0300)
commit
22e1f6f9
22e1f6f92f1d94d33ee53265376598201760e0ee
parent
48c11d80
48c11d80016ccfe067c7c8872af8689d2e23d2ae
change-id
pmmzvtxx
pmmzvtxxztqumryvzvynomvtmmwrwrrz
+331
-166
+1
-1
api/tangled/repoblob.go
+1
-1
api/tangled/repoblob.go
···
72
72
// path: Path to the file within the repository
73
73
// raw: Return raw file content instead of JSON response
74
74
// ref: Git reference (branch, tag, or commit SHA)
75
-
// repo: Repository identifier in format 'did:plc:.../repoName'
75
+
// repo: DID of the repository
76
76
func RepoBlob(ctx context.Context, c util.LexClient, path string, raw bool, ref string, repo string) (*RepoBlob_Output, error) {
77
77
var out RepoBlob_Output
78
78
+1
-1
api/tangled/tempanalyzeMerge.go
+1
-1
api/tangled/tempanalyzeMerge.go
···
34
34
//
35
35
// branch: Target branch to merge into
36
36
// patch: Patch or pull request to check for merge conflicts
37
-
// repo: AT-URI of the repository
37
+
// repo: DID of the repository
38
38
func GitTempAnalyzeMerge(ctx context.Context, c util.LexClient, branch string, patch string, repo string) (*GitTempAnalyzeMerge_Output, error) {
39
39
var out GitTempAnalyzeMerge_Output
40
40
+1
-1
api/tangled/tempgetArchive.go
+1
-1
api/tangled/tempgetArchive.go
···
20
20
// format: Archive format
21
21
// prefix: Prefix for files in the archive
22
22
// ref: Git reference (branch, tag, or commit SHA)
23
-
// repo: AT-URI of the repository
23
+
// repo: DID of the repository
24
24
func GitTempGetArchive(ctx context.Context, c util.LexClient, format string, prefix string, ref string, repo string) ([]byte, error) {
25
25
buf := new(bytes.Buffer)
26
26
+1
-1
api/tangled/tempgetBlob.go
+1
-1
api/tangled/tempgetBlob.go
···
19
19
//
20
20
// path: Path within the repository tree
21
21
// ref: Git reference (branch, tag, or commit SHA)
22
-
// repo: AT-URI of the repository
22
+
// repo: DID of the repository
23
23
func GitTempGetBlob(ctx context.Context, c util.LexClient, path string, ref string, repo string) ([]byte, error) {
24
24
buf := new(bytes.Buffer)
25
25
+1
-1
api/tangled/tempgetBranch.go
+1
-1
api/tangled/tempgetBranch.go
···
30
30
// GitTempGetBranch calls the XRPC method "sh.tangled.git.temp.getBranch".
31
31
//
32
32
// name: Branch name to get information for
33
-
// repo: AT-URI of the repository
33
+
// repo: DID of the repository
34
34
func GitTempGetBranch(ctx context.Context, c util.LexClient, name string, repo string) (*GitTempGetBranch_Output, error) {
35
35
var out GitTempGetBranch_Output
36
36
+1
-1
api/tangled/tempgetCommit.go
+1
-1
api/tangled/tempgetCommit.go
···
17
17
// GitTempGetCommit calls the XRPC method "sh.tangled.git.temp.getCommit".
18
18
//
19
19
// ref: reference name to resolve
20
-
// repo: AT-URI of the repository
20
+
// repo: DID of the repository
21
21
func GitTempGetCommit(ctx context.Context, c util.LexClient, ref string, repo string) (*GitTempDefs_Commit, error) {
22
22
var out GitTempDefs_Commit
23
23
+1
-1
api/tangled/tempgetDiff.go
+1
-1
api/tangled/tempgetDiff.go
···
17
17
18
18
// GitTempGetDiff calls the XRPC method "sh.tangled.git.temp.getDiff".
19
19
//
20
-
// repo: AT-URI of the repository
20
+
// repo: DID of the repository
21
21
// rev1: First revision (commit, branch, or tag)
22
22
// rev2: Second revision (commit, branch, or tag)
23
23
func GitTempGetDiff(ctx context.Context, c util.LexClient, repo string, rev1 string, rev2 string) ([]byte, error) {
+1
-1
api/tangled/tempgetEntity.go
+1
-1
api/tangled/tempgetEntity.go
···
18
18
//
19
19
// path: path of the entity
20
20
// ref: Git reference (branch, tag, or commit SHA)
21
-
// repo: AT-URI of the repository
21
+
// repo: DID of the repository
22
22
func GitTempGetEntity(ctx context.Context, c util.LexClient, path string, ref string, repo string) (*GitTempDefs_Blob, error) {
23
23
var out GitTempDefs_Blob
24
24
+1
-1
api/tangled/tempgetHead.go
+1
-1
api/tangled/tempgetHead.go
···
16
16
17
17
// GitTempGetHead calls the XRPC method "sh.tangled.git.temp.getHead".
18
18
//
19
-
// repo: AT-URI of the repository
19
+
// repo: DID of the repository
20
20
func GitTempGetHead(ctx context.Context, c util.LexClient, repo string) (*GitTempDefs_Branch, error) {
21
21
var out GitTempDefs_Branch
22
22
+1
-1
api/tangled/tempgetTag.go
+1
-1
api/tangled/tempgetTag.go
···
17
17
18
18
// GitTempGetTag calls the XRPC method "sh.tangled.git.temp.getTag".
19
19
//
20
-
// repo: AT-URI of the repository
20
+
// repo: DID of the repository
21
21
// tag: Name of tag, such as v1.3.0
22
22
func GitTempGetTag(ctx context.Context, c util.LexClient, repo string, tag string) ([]byte, error) {
23
23
buf := new(bytes.Buffer)
+1
-1
api/tangled/tempgetTree.go
+1
-1
api/tangled/tempgetTree.go
···
72
72
//
73
73
// path: Path within the repository tree
74
74
// ref: Git reference (branch, tag, or commit SHA)
75
-
// repo: AT-URI of the repository
75
+
// repo: DID of the repository
76
76
func GitTempGetTree(ctx context.Context, c util.LexClient, path string, ref string, repo string) (*GitTempGetTree_Output, error) {
77
77
var out GitTempGetTree_Output
78
78
+1
-1
api/tangled/templistBranches.go
+1
-1
api/tangled/templistBranches.go
···
19
19
//
20
20
// cursor: Pagination cursor
21
21
// limit: Maximum number of branches to return
22
-
// repo: AT-URI of the repository
22
+
// repo: DID of the repository
23
23
func GitTempListBranches(ctx context.Context, c util.LexClient, cursor string, limit int64, repo string) ([]byte, error) {
24
24
buf := new(bytes.Buffer)
25
25
+1
-1
api/tangled/templistCommits.go
+1
-1
api/tangled/templistCommits.go
···
20
20
// cursor: Pagination cursor (commit SHA)
21
21
// limit: Maximum number of commits to return
22
22
// ref: Git reference (branch, tag, or commit SHA)
23
-
// repo: AT-URI of the repository
23
+
// repo: DID of the repository
24
24
func GitTempListCommits(ctx context.Context, c util.LexClient, cursor string, limit int64, ref string, repo string) ([]byte, error) {
25
25
buf := new(bytes.Buffer)
26
26
+1
-1
api/tangled/templistLanguages.go
+1
-1
api/tangled/templistLanguages.go
···
44
44
// GitTempListLanguages calls the XRPC method "sh.tangled.git.temp.listLanguages".
45
45
//
46
46
// ref: Git reference (branch, tag, or commit SHA)
47
-
// repo: AT-URI of the repository
47
+
// repo: DID of the repository
48
48
func GitTempListLanguages(ctx context.Context, c util.LexClient, ref string, repo string) (*GitTempListLanguages_Output, error) {
49
49
var out GitTempListLanguages_Output
50
50
+1
-1
api/tangled/templistTags.go
+1
-1
api/tangled/templistTags.go
···
19
19
//
20
20
// cursor: Pagination cursor
21
21
// limit: Maximum number of tags to return
22
-
// repo: AT-URI of the repository
22
+
// repo: DID of the repository
23
23
func GitTempListTags(ctx context.Context, c util.LexClient, cursor string, limit int64, repo string) ([]byte, error) {
24
24
buf := new(bytes.Buffer)
25
25
+1
-1
appview/pulls/compose.go
+1
-1
appview/pulls/compose.go
···
334
334
335
335
func (s *Pulls) listBranches(ctx context.Context, repo *models.Repo) ([]types.Branch, error) {
336
336
xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url}
337
-
xrpcBytes, err := tangled.GitTempListBranches(ctx, xrpcc, "", 0, repo.RepoAt().String())
337
+
xrpcBytes, err := tangled.GitTempListBranches(ctx, xrpcc, "", 0, repo.RepoDid)
338
338
if err != nil {
339
339
return nil, err
340
340
}
+166
appview/pulls/resubmit_check_test.go
+166
appview/pulls/resubmit_check_test.go
···
1
+
package pulls
2
+
3
+
import (
4
+
"context"
5
+
"encoding/json"
6
+
"io"
7
+
"log/slog"
8
+
"net/http"
9
+
"net/http/httptest"
10
+
"testing"
11
+
"time"
12
+
13
+
"github.com/bluesky-social/indigo/atproto/syntax"
14
+
"tangled.org/core/api/tangled"
15
+
"tangled.org/core/appview/config"
16
+
"tangled.org/core/appview/models"
17
+
"tangled.org/core/appview/pages"
18
+
)
19
+
20
+
const (
21
+
resubmitTestOwnerDID = "did:plc:boltless"
22
+
resubmitTestRepoDID = "did:plc:akshay"
23
+
resubmitTestBranch = "feature"
24
+
resubmitTestSourceRev = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
25
+
)
26
+
27
+
func newKnotmirrorStub(t *testing.T, hash string) *httptest.Server {
28
+
t.Helper()
29
+
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
30
+
if r.URL.Path != "/xrpc/"+tangled.GitTempGetBranchNSID {
31
+
t.Errorf("unexpected path %q", r.URL.Path)
32
+
http.Error(w, "wrong path", http.StatusNotFound)
33
+
return
34
+
}
35
+
repoQuery := r.URL.Query().Get("repo")
36
+
if _, err := syntax.ParseDID(repoQuery); err != nil {
37
+
t.Errorf("repo param %q is not a DID: %v", repoQuery, err)
38
+
http.Error(w, "repo must be a DID", http.StatusBadRequest)
39
+
return
40
+
}
41
+
if got := r.URL.Query().Get("name"); got != resubmitTestBranch {
42
+
t.Errorf("name param = %q, want %q", got, resubmitTestBranch)
43
+
}
44
+
w.Header().Set("Content-Type", "application/json")
45
+
_ = json.NewEncoder(w).Encode(tangled.GitTempGetBranch_Output{
46
+
Name: resubmitTestBranch,
47
+
Hash: hash,
48
+
When: time.Now().UTC().Format(time.RFC3339),
49
+
})
50
+
}))
51
+
}
52
+
53
+
func newPullsFromKnotURL(url string) *Pulls {
54
+
return &Pulls{
55
+
logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
56
+
config: &config.Config{
57
+
KnotMirror: config.KnotMirrorConfig{Url: url},
58
+
},
59
+
}
60
+
}
61
+
62
+
func newForkPull(state models.PullState) (*models.Pull, *models.Repo, models.Stack) {
63
+
sourceRepoDid := syntax.DID(resubmitTestRepoDID)
64
+
pull := &models.Pull{
65
+
State: state,
66
+
OwnerDid: resubmitTestOwnerDID,
67
+
TargetBranch: "main",
68
+
Submissions: []*models.PullSubmission{
69
+
{SourceRev: resubmitTestSourceRev},
70
+
},
71
+
PullSource: &models.PullSource{
72
+
Branch: resubmitTestBranch,
73
+
RepoDid: &sourceRepoDid,
74
+
},
75
+
}
76
+
repo := &models.Repo{RepoDid: resubmitTestRepoDID}
77
+
stack := models.Stack{pull}
78
+
return pull, repo, stack
79
+
}
80
+
81
+
func TestResubmitCheck_BranchAdvanced(t *testing.T) {
82
+
srv := newKnotmirrorStub(t, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
83
+
defer srv.Close()
84
+
85
+
s := newPullsFromKnotURL(srv.URL)
86
+
req := httptest.NewRequest(http.MethodGet, "/", nil)
87
+
pull, repo, stack := newForkPull(models.PullOpen)
88
+
89
+
got := s.resubmitCheck(req, repo, pull, stack)
90
+
if got != pages.ShouldResubmit {
91
+
t.Errorf("resubmitCheck() = %v, want ShouldResubmit", got)
92
+
}
93
+
}
94
+
95
+
func TestResubmitCheck_BranchUpToDate(t *testing.T) {
96
+
srv := newKnotmirrorStub(t, resubmitTestSourceRev)
97
+
defer srv.Close()
98
+
99
+
s := newPullsFromKnotURL(srv.URL)
100
+
req := httptest.NewRequest(http.MethodGet, "/", nil)
101
+
pull, repo, stack := newForkPull(models.PullOpen)
102
+
103
+
got := s.resubmitCheck(req, repo, pull, stack)
104
+
if got != pages.ShouldNotResubmit {
105
+
t.Errorf("resubmitCheck() = %v, want ShouldNotResubmit", got)
106
+
}
107
+
}
108
+
109
+
func TestResubmitCheck_MergedReturnsUnknown(t *testing.T) {
110
+
s := newPullsFromKnotURL("http://unused")
111
+
req := httptest.NewRequest(http.MethodGet, "/", nil)
112
+
pull, repo, stack := newForkPull(models.PullMerged)
113
+
114
+
if got := s.resubmitCheck(req, repo, pull, stack); got != pages.Unknown {
115
+
t.Errorf("resubmitCheck() = %v, want Unknown for merged pull", got)
116
+
}
117
+
}
118
+
119
+
func TestResubmitCheck_PatchBasedReturnsUnknown(t *testing.T) {
120
+
s := newPullsFromKnotURL("http://unused")
121
+
req := httptest.NewRequest(http.MethodGet, "/", nil)
122
+
pull, repo, stack := newForkPull(models.PullOpen)
123
+
pull.PullSource = nil
124
+
125
+
if got := s.resubmitCheck(req, repo, pull, stack); got != pages.Unknown {
126
+
t.Errorf("resubmitCheck() = %v, want Unknown for patch-based pull", got)
127
+
}
128
+
}
129
+
130
+
func TestResubmitCheck_KnotUnreachableReturnsUnknown(t *testing.T) {
131
+
s := newPullsFromKnotURL("http://127.0.0.1:1")
132
+
ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
133
+
defer cancel()
134
+
req := httptest.NewRequest(http.MethodGet, "/", nil).WithContext(ctx)
135
+
pull, repo, stack := newForkPull(models.PullOpen)
136
+
137
+
if got := s.resubmitCheck(req, repo, pull, stack); got != pages.Unknown {
138
+
t.Errorf("resubmitCheck() = %v, want Unknown when knot unreachable", got)
139
+
}
140
+
}
141
+
142
+
func TestResubmitCheck_NonForkUsesRepoDid(t *testing.T) {
143
+
const targetRepoDID = "did:plc:scallop"
144
+
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
145
+
if got := r.URL.Query().Get("repo"); got != targetRepoDID {
146
+
t.Errorf("repo param = %q, want %q for non-fork pull", got, targetRepoDID)
147
+
}
148
+
w.Header().Set("Content-Type", "application/json")
149
+
_ = json.NewEncoder(w).Encode(tangled.GitTempGetBranch_Output{
150
+
Name: resubmitTestBranch,
151
+
Hash: resubmitTestSourceRev,
152
+
When: time.Now().UTC().Format(time.RFC3339),
153
+
})
154
+
}))
155
+
defer srv.Close()
156
+
157
+
s := newPullsFromKnotURL(srv.URL)
158
+
req := httptest.NewRequest(http.MethodGet, "/", nil)
159
+
pull, _, stack := newForkPull(models.PullOpen)
160
+
pull.PullSource.RepoDid = nil
161
+
repo := &models.Repo{RepoDid: targetRepoDID}
162
+
163
+
if got := s.resubmitCheck(req, repo, pull, stack); got != pages.ShouldNotResubmit {
164
+
t.Errorf("resubmitCheck() = %v, want ShouldNotResubmit", got)
165
+
}
166
+
}
+1
-1
appview/pulls/single.go
+1
-1
appview/pulls/single.go
···
350
350
}
351
351
352
352
xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror.Url}
353
-
resp, err := tangled.GitTempGetBranch(r.Context(), xrpcc, branch, repo.RepoAt().String())
353
+
resp, err := tangled.GitTempGetBranch(r.Context(), xrpcc, branch, repo.RepoDid)
354
354
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
355
355
s.logger.Error("failed to get branch", "xrpcerr", xrpcerr, "err", err)
356
356
return nil
+1
-1
appview/repo/archive.go
+1
-1
appview/repo/archive.go
+1
-1
appview/repo/artifact.go
+1
-1
appview/repo/artifact.go
···
310
310
311
311
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
312
312
313
-
xrpcBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 0, f.RepoAt().String())
313
+
xrpcBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 0, f.RepoDid)
314
314
if err != nil {
315
315
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
316
316
l.Error("failed to call XRPC repo.tags", "xrpcerr", xrpcerr, "err", err)
+2
-2
appview/repo/blob.go
+2
-2
appview/repo/blob.go
···
52
52
filePath, _ = url.PathUnescape(filePath)
53
53
54
54
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
55
-
resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, f.RepoAt().String())
55
+
resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, f.RepoDid)
56
56
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
57
57
l.Error("failed to call XRPC repo.blob", "xrpcerr", xrpcerr, "err", err)
58
58
rp.pages.Error503(w)
···
272
272
273
273
func generateBlobURL(config *config.Config, repo *models.Repo, ref, filePath string) string {
274
274
query := url.Values{}
275
-
query.Set("repo", string(repo.RepoAt()))
275
+
query.Set("repo", repo.RepoDid)
276
276
query.Set("ref", ref)
277
277
query.Set("path", filePath)
278
278
query.Set("raw", "true")
+1
-1
appview/repo/branches.go
+1
-1
appview/repo/branches.go
···
23
23
}
24
24
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
25
25
26
-
xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
26
+
xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoDid)
27
27
if err != nil {
28
28
l.Error("failed to call XRPC repo.branches", "err", err)
29
29
rp.pages.Error503(w)
+2
-2
appview/repo/compare.go
+2
-2
appview/repo/compare.go
···
32
32
33
33
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
34
34
35
-
branchBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
35
+
branchBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoDid)
36
36
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
37
37
l.Error("failed to call XRPC repo.branches", "xrpcerr", xrpcerr, "err", err)
38
38
rp.pages.Error503(w)
···
69
69
head = queryHead
70
70
}
71
71
72
-
tagBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoAt().String())
72
+
tagBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoDid)
73
73
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
74
74
l.Error("failed to call XRPC repo.tags", "xrpcerr", xrpcerr, "err", err)
75
75
rp.pages.Error503(w)
+2
-2
appview/repo/feed.go
+2
-2
appview/repo/feed.go
···
209
209
func (rp *Repo) createCommitItems(ctx context.Context, repo *models.Repo, ownerSlashRepo string) ([]*feeds.Item, error) {
210
210
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
211
211
212
-
xrpcBytes, err := tangled.GitTempListCommits(ctx, xrpcc, "", 100, "", repo.RepoAt().String())
212
+
xrpcBytes, err := tangled.GitTempListCommits(ctx, xrpcc, "", 100, "", repo.RepoDid)
213
213
if err != nil {
214
214
return nil, fmt.Errorf("failed to call XRPC repo.log: %w", err)
215
215
}
···
248
248
func (rp *Repo) createTagItems(ctx context.Context, repo *models.Repo, ownerSlashRepo string) ([]*feeds.Item, error) {
249
249
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
250
250
251
-
tagBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 100, repo.RepoAt().String())
251
+
tagBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 100, repo.RepoDid)
252
252
if err != nil {
253
253
return nil, fmt.Errorf("failed to call XRPC repo.tags: %w", err)
254
254
}
+5
-5
appview/repo/index.go
+5
-5
appview/repo/index.go
···
171
171
Host: rp.config.KnotMirror.Url,
172
172
Client: http.DefaultClient,
173
173
}
174
-
ls, err := tangled.GitTempListLanguages(ctx, xrpcc, currentRef, repo.RepoAt().String())
174
+
ls, err := tangled.GitTempListLanguages(ctx, xrpcc, currentRef, repo.RepoDid)
175
175
if err != nil {
176
176
return nil, fmt.Errorf("calling knotmirror git.listLanguages: %w", err)
177
177
}
···
254
254
func (rp *Repo) buildIndexResponse(ctx context.Context, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) {
255
255
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
256
256
257
-
branchesBytes, err := tangled.GitTempListBranches(ctx, xrpcc, "", 0, repo.RepoAt().String())
257
+
branchesBytes, err := tangled.GitTempListBranches(ctx, xrpcc, "", 0, repo.RepoDid)
258
258
if err != nil {
259
259
return nil, fmt.Errorf("calling knotmirror git.listBranches: %w", err)
260
260
}
···
296
296
297
297
// tags
298
298
wg.Go(func() {
299
-
tagsBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 0, repo.RepoAt().String())
299
+
tagsBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 0, repo.RepoDid)
300
300
if err != nil {
301
301
errs = errors.Join(errs, fmt.Errorf("failed to call git.ListTags: %w", err))
302
302
return
···
309
309
310
310
// tree/files
311
311
wg.Go(func() {
312
-
resp, err := tangled.GitTempGetTree(ctx, xrpcc, "", ref, repo.RepoAt().String())
312
+
resp, err := tangled.GitTempGetTree(ctx, xrpcc, "", ref, repo.RepoDid)
313
313
if err != nil {
314
314
errs = errors.Join(errs, fmt.Errorf("failed to call git.GetTree: %w", err))
315
315
return
···
319
319
320
320
// commits
321
321
wg.Go(func() {
322
-
logBytes, err := tangled.GitTempListCommits(ctx, xrpcc, "", 50, ref, repo.RepoAt().String())
322
+
logBytes, err := tangled.GitTempListCommits(ctx, xrpcc, "", 50, ref, repo.RepoDid)
323
323
if err != nil {
324
324
errs = errors.Join(errs, fmt.Errorf("failed to call git.ListCommits: %w", err))
325
325
return
+3
-3
appview/repo/log.go
+3
-3
appview/repo/log.go
···
111
111
cursor = strconv.Itoa(offset)
112
112
}
113
113
114
-
xrpcBytes, err := tangled.GitTempListCommits(r.Context(), xrpcc, cursor, limit, ref, f.RepoAt().String())
114
+
xrpcBytes, err := tangled.GitTempListCommits(r.Context(), xrpcc, cursor, limit, ref, f.RepoDid)
115
115
if err != nil {
116
116
l.Error("failed to call XRPC repo.log", "err", err)
117
117
rp.pages.Error503(w)
···
125
125
return
126
126
}
127
127
128
-
tagBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoAt().String())
128
+
tagBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoDid)
129
129
if err != nil {
130
130
l.Error("failed to call XRPC repo.tags", "err", err)
131
131
rp.pages.Error503(w)
···
146
146
}
147
147
}
148
148
149
-
branchBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
149
+
branchBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoDid)
150
150
if err != nil {
151
151
l.Error("failed to call XRPC repo.branches", "err", err)
152
152
rp.pages.Error503(w)
+1
-1
appview/repo/settings.go
+1
-1
appview/repo/settings.go
···
381
381
382
382
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
383
383
384
-
xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
384
+
xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoDid)
385
385
var result types.RepoBranchesResponse
386
386
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
387
387
l.Error("failed to call XRPC git.listBranches", "xrpcerr", xrpcerr, "err", err)
+1
-1
appview/repo/tree.go
+1
-1
appview/repo/tree.go
···
35
35
treePath = strings.TrimSuffix(treePath, "/")
36
36
37
37
xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror.Url}
38
-
xrpcResp, err := tangled.GitTempGetTree(r.Context(), xrpcc, treePath, ref, f.RepoAt().String())
38
+
xrpcResp, err := tangled.GitTempGetTree(r.Context(), xrpcc, treePath, ref, f.RepoDid)
39
39
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
40
40
l.Error("failed to call XRPC repo.tree", "xrpcerr", xrpcerr, "err", err)
41
41
rp.pages.Error503(w)
+9
knotmirror/git.go
+9
knotmirror/git.go
···
25
25
Fetch(ctx context.Context, repo *models.Repo) error
26
26
// Sync mirrors the repository. It will clone the repository if repository doesn't exist.
27
27
Sync(ctx context.Context, repo *models.Repo) error
28
+
Delete(repo *models.Repo) error
28
29
}
29
30
30
31
type CliGitMirrorManager struct {
···
114
115
}
115
116
}
116
117
return nil
118
+
}
119
+
120
+
func (c *CliGitMirrorManager) Delete(repo *models.Repo) error {
121
+
return os.RemoveAll(c.makeRepoPath(repo))
117
122
}
118
123
119
124
var (
···
249
254
}
250
255
}
251
256
return nil
257
+
}
258
+
259
+
func (c *GoGitMirrorManager) Delete(repo *models.Repo) error {
260
+
return os.RemoveAll(c.makeRepoPath(repo))
252
261
}
253
262
254
263
func makeRepoRemoteUrl(knot, repoIdentifier string, knotUseSSL bool) (string, error) {
+10
knotmirror/tapclient.go
+10
knotmirror/tapclient.go
···
133
133
}
134
134
135
135
case tapc.RecordDeleteAction:
136
+
aturi := syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", evt.Did, tangled.RepoNSID, evt.Rkey))
137
+
repo, err := db.GetRepoByAtUri(ctx, t.db, aturi)
138
+
if err != nil {
139
+
return fmt.Errorf("looking up repo before delete: %w", err)
140
+
}
141
+
if repo != nil {
142
+
if err := t.gitm.Delete(repo); err != nil {
143
+
return fmt.Errorf("removing mirror dir: %w", err)
144
+
}
145
+
}
136
146
if err := db.DeleteRepo(ctx, t.db, evt.Did, evt.Rkey); err != nil {
137
147
return fmt.Errorf("deleting repo from db: %w", err)
138
148
}
+3
-3
knotmirror/xrpc/git_get_archive.go
+3
-3
knotmirror/xrpc/git_get_archive.go
···
23
23
prefix = r.URL.Query().Get("prefix")
24
24
)
25
25
26
-
repo, err := syntax.ParseATURI(repoQuery)
27
-
if err != nil || repo.RecordKey() == "" {
26
+
repo, err := syntax.ParseDID(repoQuery)
27
+
if err != nil {
28
28
writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
29
29
return
30
30
}
···
61
61
}
62
62
63
63
repoName, err := func() (string, error) {
64
-
r, err := db.GetRepoByAtUri(ctx, x.db, repo)
64
+
r, err := db.GetRepoByRepoDid(ctx, x.db, repo)
65
65
if err != nil {
66
66
return "", err
67
67
}
+4
-4
knotmirror/xrpc/git_get_blob.go
+4
-4
knotmirror/xrpc/git_get_blob.go
···
24
24
path = r.URL.Query().Get("path")
25
25
)
26
26
27
-
repo, err := syntax.ParseATURI(repoQuery)
28
-
if err != nil || repo.RecordKey() == "" {
27
+
repo, err := syntax.ParseDID(repoQuery)
28
+
if err != nil {
29
29
writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
30
30
return
31
31
}
···
111
111
w.Write(contents)
112
112
}
113
113
114
-
func (x *Xrpc) getFile(ctx context.Context, repo syntax.ATURI, ref, path string) (*object.File, error) {
114
+
func (x *Xrpc) getFile(ctx context.Context, repo syntax.DID, ref, path string) (*object.File, error) {
115
115
repoPath, err := x.makeRepoPath(ctx, repo)
116
116
if err != nil {
117
-
return nil, fmt.Errorf("resolving repo at-uri: %w", err)
117
+
return nil, fmt.Errorf("resolving repo did: %w", err)
118
118
}
119
119
120
120
gr, err := git.Open(repoPath, ref)
+4
-4
knotmirror/xrpc/git_get_branch.go
+4
-4
knotmirror/xrpc/git_get_branch.go
···
21
21
nameQuery = r.URL.Query().Get("name")
22
22
)
23
23
24
-
repo, err := syntax.ParseATURI(repoQuery)
25
-
if err != nil || repo.RecordKey() == "" {
24
+
repo, err := syntax.ParseDID(repoQuery)
25
+
if err != nil {
26
26
writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
27
27
return
28
28
}
···
45
45
writeJson(w, http.StatusOK, out)
46
46
}
47
47
48
-
func (x *Xrpc) getBranch(ctx context.Context, repo syntax.ATURI, branchName string) (*tangled.GitTempGetBranch_Output, error) {
48
+
func (x *Xrpc) getBranch(ctx context.Context, repo syntax.DID, branchName string) (*tangled.GitTempGetBranch_Output, error) {
49
49
repoPath, err := x.makeRepoPath(ctx, repo)
50
50
if err != nil {
51
-
return nil, fmt.Errorf("failed to resolve repo at-uri: %w", err)
51
+
return nil, fmt.Errorf("failed to resolve repo did: %w", err)
52
52
}
53
53
54
54
gr, err := git.PlainOpen(repoPath)
+4
-4
knotmirror/xrpc/git_get_tag.go
+4
-4
knotmirror/xrpc/git_get_tag.go
···
19
19
tagName = r.URL.Query().Get("tag")
20
20
)
21
21
22
-
repo, err := syntax.ParseATURI(repoQuery)
23
-
if err != nil || repo.RecordKey() == "" {
22
+
repo, err := syntax.ParseDID(repoQuery)
23
+
if err != nil {
24
24
writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
25
25
return
26
26
}
···
42
42
writeJson(w, http.StatusOK, out)
43
43
}
44
44
45
-
func (x *Xrpc) getTag(ctx context.Context, repo syntax.ATURI, tagName string) (*types.RepoTagResponse, error) {
45
+
func (x *Xrpc) getTag(ctx context.Context, repo syntax.DID, tagName string) (*types.RepoTagResponse, error) {
46
46
repoPath, err := x.makeRepoPath(ctx, repo)
47
47
if err != nil {
48
-
return nil, fmt.Errorf("failed to resolve repo at-uri: %w", err)
48
+
return nil, fmt.Errorf("failed to resolve repo did: %w", err)
49
49
}
50
50
51
51
gr, err := git.PlainOpen(repoPath)
+4
-4
knotmirror/xrpc/git_get_tree.go
+4
-4
knotmirror/xrpc/git_get_tree.go
···
26
26
l := x.logger.With("method", "git.getTree", "repo", repoQuery, "ref", ref)
27
27
l.Debug("request")
28
28
29
-
repo, err := syntax.ParseATURI(repoQuery)
30
-
if err != nil || repo.RecordKey() == "" {
29
+
repo, err := syntax.ParseDID(repoQuery)
30
+
if err != nil {
31
31
writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
32
32
return
33
33
}
···
47
47
writeJson(w, http.StatusOK, out)
48
48
}
49
49
50
-
func (x *Xrpc) getTree(ctx context.Context, repo syntax.ATURI, ref, path string) (*tangled.GitTempGetTree_Output, error) {
50
+
func (x *Xrpc) getTree(ctx context.Context, repo syntax.DID, ref, path string) (*tangled.GitTempGetTree_Output, error) {
51
51
repoPath, err := x.makeRepoPath(ctx, repo)
52
52
if err != nil {
53
-
return nil, fmt.Errorf("failed to resolve repo at-uri: %w", err)
53
+
return nil, fmt.Errorf("failed to resolve repo did: %w", err)
54
54
}
55
55
56
56
gr, err := git.Open(repoPath, ref)
+10
-16
knotmirror/xrpc/git_list_branches.go
+10
-16
knotmirror/xrpc/git_list_branches.go
···
4
4
"context"
5
5
"fmt"
6
6
"net/http"
7
+
"os"
7
8
"path/filepath"
8
9
"strconv"
9
10
10
11
"github.com/bluesky-social/indigo/atproto/atclient"
11
12
"github.com/bluesky-social/indigo/atproto/syntax"
12
-
"tangled.org/core/knotmirror/db"
13
13
"tangled.org/core/knotserver/git"
14
14
"tangled.org/core/types"
15
15
)
···
21
21
cursorQuery = r.URL.Query().Get("cursor")
22
22
)
23
23
24
-
repo, err := syntax.ParseATURI(repoQuery)
25
-
if err != nil || repo.RecordKey() == "" {
24
+
repo, err := syntax.ParseDID(repoQuery)
25
+
if err != nil {
26
26
writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
27
27
return
28
28
}
···
57
57
writeJson(w, http.StatusOK, out)
58
58
}
59
59
60
-
func (x *Xrpc) listBranches(ctx context.Context, repo syntax.ATURI, limit int, cursor int64) (*types.RepoBranchesResponse, error) {
60
+
func (x *Xrpc) listBranches(ctx context.Context, repo syntax.DID, limit int, cursor int64) (*types.RepoBranchesResponse, error) {
61
61
repoPath, err := x.makeRepoPath(ctx, repo)
62
62
if err != nil {
63
-
return nil, fmt.Errorf("resolving repo at-uri: %w", err)
63
+
return nil, fmt.Errorf("resolving repo did: %w", err)
64
64
}
65
65
66
66
gr, err := git.PlainOpen(repoPath)
···
82
82
}, nil
83
83
}
84
84
85
-
func (x *Xrpc) makeRepoPath(ctx context.Context, repo syntax.ATURI) (string, error) {
86
-
r, err := db.GetRepoByAtUri(ctx, x.db, repo)
87
-
if err != nil {
88
-
return "", fmt.Errorf("looking up repo: %w", err)
85
+
func (x *Xrpc) makeRepoPath(ctx context.Context, repoDid syntax.DID) (string, error) {
86
+
path := filepath.Join(x.cfg.GitRepoBasePath, repoDid.String())
87
+
if _, err := os.Stat(path); err != nil {
88
+
return "", fmt.Errorf("repo %s not mirrored locally: %w", repoDid, err)
89
89
}
90
-
if r == nil {
91
-
return "", fmt.Errorf("repo not found: %s", repo)
92
-
}
93
-
if r.RepoDid == "" {
94
-
return "", fmt.Errorf("repo missing repo_did: %s", repo)
95
-
}
96
-
return filepath.Join(x.cfg.GitRepoBasePath, r.RepoDid.String()), nil
90
+
return path, nil
97
91
}
+4
-4
knotmirror/xrpc/git_list_commits.go
+4
-4
knotmirror/xrpc/git_list_commits.go
···
20
20
cursorQuery = r.URL.Query().Get("cursor")
21
21
)
22
22
23
-
repo, err := syntax.ParseATURI(repoQuery)
24
-
if err != nil || repo.RecordKey() == "" {
23
+
repo, err := syntax.ParseDID(repoQuery)
24
+
if err != nil {
25
25
writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
26
26
return
27
27
}
···
56
56
writeJson(w, http.StatusOK, out)
57
57
}
58
58
59
-
func (x *Xrpc) listCommits(ctx context.Context, repo syntax.ATURI, ref string, limit int, cursor int64) (*types.RepoLogResponse, error) {
59
+
func (x *Xrpc) listCommits(ctx context.Context, repo syntax.DID, ref string, limit int, cursor int64) (*types.RepoLogResponse, error) {
60
60
repoPath, err := x.makeRepoPath(ctx, repo)
61
61
if err != nil {
62
-
return nil, fmt.Errorf("resolving repo at-uri: %w", err)
62
+
return nil, fmt.Errorf("resolving repo did: %w", err)
63
63
}
64
64
65
65
gr, err := git.Open(repoPath, ref)
+5
-5
knotmirror/xrpc/git_list_languages.go
+5
-5
knotmirror/xrpc/git_list_languages.go
···
28
28
l := x.logger.With("method", "git.listLanguages", "repo", repoQuery, "ref", ref)
29
29
l.Debug("request")
30
30
31
-
repo, err := syntax.ParseATURI(repoQuery)
32
-
if err != nil || repo.RecordKey() == "" {
33
-
l.Error("invalid repo at-uri", "err", err)
31
+
repo, err := syntax.ParseDID(repoQuery)
32
+
if err != nil {
33
+
l.Error("invalid repo did", "err", err)
34
34
writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
35
35
return
36
36
}
···
64
64
writeJson(w, http.StatusOK, out)
65
65
}
66
66
67
-
func (x *Xrpc) listLanguages(ctx context.Context, repo syntax.ATURI, ref string) (*tangled.GitTempListLanguages_Output, error) {
67
+
func (x *Xrpc) listLanguages(ctx context.Context, repo syntax.DID, ref string) (*tangled.GitTempListLanguages_Output, error) {
68
68
repoPath, err := x.makeRepoPath(ctx, repo)
69
69
if err != nil {
70
-
return nil, fmt.Errorf("resolving repo at-uri: %w", err)
70
+
return nil, fmt.Errorf("resolving repo did: %w", err)
71
71
}
72
72
73
73
gr, err := git.Open(repoPath, ref)
+31
-46
knotmirror/xrpc/proxy.go
+31
-46
knotmirror/xrpc/proxy.go
···
9
9
"net/url"
10
10
"strings"
11
11
12
-
"github.com/bluesky-social/indigo/api/atproto"
13
12
"github.com/bluesky-social/indigo/atproto/syntax"
14
13
indigoxrpc "github.com/bluesky-social/indigo/xrpc"
15
14
"tangled.org/core/api/tangled"
···
70
69
return strings.TrimRight(u.String(), "/"), nil
71
70
}
72
71
73
-
func (x *Xrpc) resolveKnot(ctx context.Context, repoAt syntax.ATURI) (*knotInfo, error) {
74
-
repo, err := db.GetRepoByAtUri(ctx, x.db, repoAt)
75
-
if err == nil && repo != nil {
72
+
func (x *Xrpc) resolveKnot(ctx context.Context, repoDid syntax.DID) (*knotInfo, error) {
73
+
if repo, err := db.GetRepoByRepoDid(ctx, x.db, repoDid); err == nil && repo != nil {
76
74
knotURL := repo.KnotDomain
77
75
if !strings.Contains(repo.KnotDomain, "://") {
78
76
if host, _ := db.GetHost(ctx, x.db, repo.KnotDomain); host != nil {
···
93
91
return &knotInfo{baseURL: knotURL, repoIdentifier: repo.RepoIdentifier()}, nil
94
92
}
95
93
96
-
owner, err := x.resolver.ResolveIdent(ctx, repoAt.Authority().String())
94
+
ident, err := x.resolver.ResolveIdent(ctx, repoDid.String())
97
95
if err != nil {
98
-
return nil, fmt.Errorf("resolving repo owner: %w", err)
96
+
return nil, fmt.Errorf("resolving repoDid %s: %w", repoDid, err)
99
97
}
100
-
101
-
xrpcc := indigoxrpc.Client{Host: owner.PDSEndpoint()}
102
-
out, err := atproto.RepoGetRecord(ctx, &xrpcc, "", tangled.RepoNSID, repoAt.Authority().String(), repoAt.RecordKey().String())
98
+
knotURL, err := validateKnotURL(ident.GetServiceEndpoint("atproto_pds"))
103
99
if err != nil {
104
-
return nil, fmt.Errorf("fetching repo record from PDS: %w", err)
100
+
return nil, fmt.Errorf("repoDid %s: %w", repoDid, err)
105
101
}
106
102
107
-
record := out.Value.Val.(*tangled.Repo)
108
-
if record.RepoDid == nil || *record.RepoDid == "" {
109
-
return nil, fmt.Errorf("repo record has no repo_did")
103
+
xrpcc := &indigoxrpc.Client{Host: knotURL, Client: x.httpClient}
104
+
out, err := tangled.RepoDescribeRepo(ctx, xrpcc, repoDid.String())
105
+
if err != nil {
106
+
x.logger.Warn("describeRepo failed; serving without metadata upsert", "knot", knotURL, "repo", repoDid, "err", err)
107
+
return &knotInfo{baseURL: knotURL, repoIdentifier: repoDid.String()}, nil
110
108
}
111
-
knotURL := record.Knot
112
-
if !strings.Contains(record.Knot, "://") {
113
-
if host, _ := db.GetHost(ctx, x.db, record.Knot); host != nil {
114
-
knotURL = host.URL()
115
-
} else {
116
-
x.logger.Warn("repo is from unknown knot")
117
-
if x.cfg.KnotUseSSL {
118
-
knotURL = "https://" + knotURL
119
-
} else {
120
-
knotURL = "http://" + knotURL
121
-
}
122
-
}
109
+
if out.RepoDid != repoDid.String() {
110
+
return nil, fmt.Errorf("knot %s returned mismatched repoDid: got %q, want %q", knotURL, out.RepoDid, repoDid)
111
+
}
112
+
ownerDid, err := syntax.ParseDID(out.OwnerDid)
113
+
if err != nil {
114
+
return nil, fmt.Errorf("describeRepo on %s returned invalid ownerDid %q: %w", knotURL, out.OwnerDid, err)
115
+
}
116
+
rkey, err := syntax.ParseRecordKey(out.Rkey)
117
+
if err != nil {
118
+
return nil, fmt.Errorf("describeRepo on %s returned invalid rkey %q: %w", knotURL, out.Rkey, err)
123
119
}
124
120
125
-
rkey := repoAt.RecordKey().String()
126
-
repoDid := syntax.DID(*record.RepoDid)
127
121
go func() {
128
-
bgCtx := context.Background()
129
122
pending := &models.Repo{
130
-
Did: owner.DID,
131
-
Rkey: repoAt.RecordKey(),
132
-
Cid: (*syntax.CID)(out.Cid),
133
-
Name: rkey,
123
+
Did: ownerDid,
124
+
Rkey: rkey,
125
+
Name: string(rkey),
134
126
KnotDomain: knotURL,
135
127
RepoDid: repoDid,
136
128
State: models.RepoStatePending,
137
129
}
138
-
if upsertErr := db.UpsertRepo(bgCtx, x.db, pending); upsertErr != nil {
139
-
x.logger.Error("failed to upsert repo after proxy resolution", "err", upsertErr)
130
+
if err := db.UpsertRepo(context.Background(), x.db, pending); err != nil {
131
+
x.logger.Error("failed to upsert repo after directory resolution", "err", err)
140
132
}
141
133
}()
142
134
143
-
knotURL, err = validateKnotURL(knotURL)
144
-
if err != nil {
145
-
return nil, err
146
-
}
147
-
return &knotInfo{
148
-
baseURL: knotURL,
149
-
repoIdentifier: repoDid.String(),
150
-
}, nil
135
+
return &knotInfo{baseURL: knotURL, repoIdentifier: repoDid.String()}, nil
151
136
}
152
137
153
-
func (x *Xrpc) proxyToKnot(w http.ResponseWriter, r *http.Request, repoAt syntax.ATURI) bool {
138
+
func (x *Xrpc) proxyToKnot(w http.ResponseWriter, r *http.Request, repoDid syntax.DID) bool {
154
139
mirrorNSID := strings.TrimPrefix(r.URL.Path, "/xrpc/")
155
140
knotNSID, ok := mirrorToKnotNSID[mirrorNSID]
156
141
if !ok {
157
142
return false
158
143
}
159
144
160
-
knot, err := x.resolveKnot(r.Context(), repoAt)
145
+
knot, err := x.resolveKnot(r.Context(), repoDid)
161
146
if err != nil {
162
-
x.logger.Warn("proxy: failed to resolve knot", "repo", repoAt, "err", err)
147
+
x.logger.Warn("proxy: failed to resolve knot", "repo", repoDid, "err", err)
163
148
return false
164
149
}
165
150
···
197
182
x.logger.Warn("proxy: response copy interrupted", "target", target, "err", err)
198
183
}
199
184
200
-
x.logger.Info("proxy: served from knot", "repo", repoAt, "knot", knot.baseURL, "status", resp.StatusCode)
185
+
x.logger.Info("proxy: served from knot", "repo", repoDid, "knot", knot.baseURL, "status", resp.StatusCode)
201
186
return true
202
187
}
+4
-4
knotmirror/xrpc/repo_blob.go
+4
-4
knotmirror/xrpc/repo_blob.go
···
24
24
path = r.URL.Query().Get("path")
25
25
)
26
26
27
-
repo, err := syntax.ParseATURI(repoQuery)
28
-
if err != nil || repo.RecordKey() == "" {
27
+
repo, err := syntax.ParseDID(repoQuery)
28
+
if err != nil {
29
29
writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
30
30
return
31
31
}
···
155
155
writeJson(w, http.StatusOK, response)
156
156
}
157
157
158
-
func (x *Xrpc) getRepo(ctx context.Context, repo syntax.ATURI, ref string) (*git.GitRepo, error) {
158
+
func (x *Xrpc) getRepo(ctx context.Context, repo syntax.DID, ref string) (*git.GitRepo, error) {
159
159
repoPath, err := x.makeRepoPath(ctx, repo)
160
160
if err != nil {
161
-
return nil, fmt.Errorf("resolving repo at-uri: %w", err)
161
+
return nil, fmt.Errorf("resolving repo did: %w", err)
162
162
}
163
163
164
164
gr, err := git.Open(repoPath, ref)
+2
-2
lexicons/git/temp/analyzeMerge.json
+2
-2
lexicons/git/temp/analyzeMerge.json
+2
-2
lexicons/git/temp/getArchive.json
+2
-2
lexicons/git/temp/getArchive.json
+2
-2
lexicons/git/temp/getBlob.json
+2
-2
lexicons/git/temp/getBlob.json
+2
-2
lexicons/git/temp/getBranch.json
+2
-2
lexicons/git/temp/getBranch.json
+2
-2
lexicons/git/temp/getCommit.json
+2
-2
lexicons/git/temp/getCommit.json
+2
-2
lexicons/git/temp/getDiff.json
+2
-2
lexicons/git/temp/getDiff.json
+2
-2
lexicons/git/temp/getEntity.json
+2
-2
lexicons/git/temp/getEntity.json
+2
-2
lexicons/git/temp/getHead.json
+2
-2
lexicons/git/temp/getHead.json
+2
-2
lexicons/git/temp/getTag.json
+2
-2
lexicons/git/temp/getTag.json
+2
-2
lexicons/git/temp/getTree.json
+2
-2
lexicons/git/temp/getTree.json
+2
-2
lexicons/git/temp/listBranches.json
+2
-2
lexicons/git/temp/listBranches.json
+2
-2
lexicons/git/temp/listCommits.json
+2
-2
lexicons/git/temp/listCommits.json
+2
-2
lexicons/git/temp/listLanguages.json
+2
-2
lexicons/git/temp/listLanguages.json
+2
-2
lexicons/git/temp/listTags.json
+2
-2
lexicons/git/temp/listTags.json