this repo has no description
rename `atproto/repo` CAR loading function names (#1016)
This only touches code I am developing, so will probably self-merge
+29
-28
+16
-15
atproto/repo/car.go
+16
-15
atproto/repo/car.go
···
11
11
"github.com/bluesky-social/indigo/atproto/syntax"
12
12
13
13
blocks "github.com/ipfs/go-block-format"
14
+
"github.com/ipfs/go-cid"
14
15
"github.com/ipld/go-car"
15
16
)
16
17
17
-
func LoadFromCAR(ctx context.Context, r io.Reader) (*Commit, *Repo, error) {
18
+
var ErrNoRoot = errors.New("CAR file missing root CID")
19
+
var ErrNoCommit = errors.New("no commit")
20
+
21
+
func LoadRepoFromCAR(ctx context.Context, r io.Reader) (*Commit, *Repo, error) {
18
22
19
23
//bs := blockstore.NewBlockstore(datastore.NewMapDatastore())
20
24
bs := NewTinyBlockstore()
···
73
77
return &commit, &repo, nil
74
78
}
75
79
76
-
var ErrNoRoot = errors.New("CAR file missing root CID")
77
-
var ErrNoCommit = errors.New("no commit")
78
-
79
-
// LoadCARCommit is like LoadFromCAR() but filters to only return the commit object.
80
-
// useful for subscribeRepos/firehose `#sync` message
81
-
func LoadCARCommit(ctx context.Context, r io.Reader) (*Commit, error) {
80
+
// LoadCommitFromCAR is like LoadRepoFromCAR() but filters to only return the commit object.
81
+
// Also returns the commit CID.
82
+
func LoadCommitFromCAR(ctx context.Context, r io.Reader) (*Commit, *cid.Cid, error) {
82
83
cr, err := car.NewCarReader(r)
83
84
if err != nil {
84
-
return nil, err
85
+
return nil, nil, err
85
86
}
86
87
if cr.Header.Version != 1 {
87
-
return nil, fmt.Errorf("unsupported CAR file version: %d", cr.Header.Version)
88
+
return nil, nil, fmt.Errorf("unsupported CAR file version: %d", cr.Header.Version)
88
89
}
89
90
if len(cr.Header.Roots) < 1 {
90
-
return nil, ErrNoRoot
91
+
return nil, nil, ErrNoRoot
91
92
}
92
93
commitCID := cr.Header.Roots[0]
93
94
var commitBlock blocks.Block
···
97
98
if err == io.EOF {
98
99
break
99
100
}
100
-
return nil, err
101
+
return nil, nil, err
101
102
}
102
103
103
104
if blk.Cid().Equals(commitCID) {
···
106
107
}
107
108
}
108
109
if commitBlock == nil {
109
-
return nil, ErrNoCommit
110
+
return nil, nil, ErrNoCommit
110
111
}
111
112
var commit Commit
112
113
if err := commit.UnmarshalCBOR(bytes.NewReader(commitBlock.RawData())); err != nil {
113
-
return nil, fmt.Errorf("parsing commit block from CAR file: %w", err)
114
+
return nil, nil, fmt.Errorf("parsing commit block from CAR file: %w", err)
114
115
}
115
116
if err := commit.VerifyStructure(); err != nil {
116
-
return nil, fmt.Errorf("parsing commit block from CAR file: %w", err)
117
+
return nil, nil, fmt.Errorf("parsing commit block from CAR file: %w", err)
117
118
}
118
-
return &commit, nil
119
+
return &commit, &commitCID, nil
119
120
}
+2
-2
atproto/repo/cmd/repo-tool/main.go
+2
-2
atproto/repo/cmd/repo-tool/main.go
···
93
93
}
94
94
defer f.Close()
95
95
96
-
commit, repo, err := repo.LoadFromCAR(ctx, f)
96
+
commit, repo, err := repo.LoadRepoFromCAR(ctx, f)
97
97
if err != nil {
98
98
return err
99
99
}
···
125
125
}
126
126
defer f.Close()
127
127
128
-
commit, _, err := repo.LoadFromCAR(ctx, f)
128
+
commit, _, err := repo.LoadRepoFromCAR(ctx, f)
129
129
if err != nil {
130
130
return err
131
131
}
+2
-2
atproto/repo/sync.go
+2
-2
atproto/repo/sync.go
···
40
40
logger.Warn("event with rebase flag set")
41
41
}
42
42
43
-
commit, repo, err := LoadFromCAR(ctx, bytes.NewReader([]byte(msg.Blocks)))
43
+
commit, repo, err := LoadRepoFromCAR(ctx, bytes.NewReader([]byte(msg.Blocks)))
44
44
if err != nil {
45
45
return nil, err
46
46
}
···
168
168
//
169
169
// TODO: in real implementation, will want to merge this code with `VerifyCommitMessage` above, and have it hanging off some service struct with a configured `identity.Directory`
170
170
func VerifyCommitSignature(ctx context.Context, dir identity.Directory, msg *comatproto.SyncSubscribeRepos_Commit) error {
171
-
commit, _, err := LoadFromCAR(ctx, bytes.NewReader([]byte(msg.Blocks)))
171
+
commit, _, err := LoadRepoFromCAR(ctx, bytes.NewReader([]byte(msg.Blocks)))
172
172
if err != nil {
173
173
return err
174
174
}
+1
-1
atproto/repo/sync_test.go
+1
-1
atproto/repo/sync_test.go
+3
-3
cmd/goat/firehose.go
+3
-3
cmd/goat/firehose.go
···
256
256
}
257
257
258
258
func (gfc *GoatFirehoseConsumer) handleSyncEvent(ctx context.Context, evt *comatproto.SyncSubscribeRepos_Sync) error {
259
-
commit, err := repo.LoadCARCommit(ctx, bytes.NewReader(evt.Blocks))
259
+
commit, _, err := repo.LoadCommitFromCAR(ctx, bytes.NewReader(evt.Blocks))
260
260
if err != nil {
261
261
return err
262
262
}
···
296
296
return err
297
297
}
298
298
299
-
commit, err := repo.LoadCARCommit(ctx, bytes.NewReader(evt.Blocks))
299
+
commit, _, err := repo.LoadCommitFromCAR(ctx, bytes.NewReader(evt.Blocks))
300
300
if err != nil {
301
301
return err
302
302
}
···
409
409
return nil
410
410
}
411
411
412
-
_, rr, err := repo.LoadFromCAR(ctx, bytes.NewReader(evt.Blocks))
412
+
_, rr, err := repo.LoadRepoFromCAR(ctx, bytes.NewReader(evt.Blocks))
413
413
if err != nil {
414
414
logger.Error("failed to read repo from car", "err", err)
415
415
return nil
+3
-3
cmd/goat/repo.go
+3
-3
cmd/goat/repo.go
···
184
184
}
185
185
186
186
// read repository tree in to memory
187
-
_, r, err := repo.LoadFromCAR(ctx, fi)
187
+
_, r, err := repo.LoadRepoFromCAR(ctx, fi)
188
188
if err != nil {
189
189
return fmt.Errorf("failed to parse repo CAR file: %w", err)
190
190
}
···
211
211
}
212
212
213
213
// read repository tree in to memory
214
-
c, _, err := repo.LoadFromCAR(ctx, fi)
214
+
c, _, err := repo.LoadRepoFromCAR(ctx, fi)
215
215
if err != nil {
216
216
return err
217
217
}
···
255
255
return err
256
256
}
257
257
258
-
c, r, err := repo.LoadFromCAR(ctx, fi)
258
+
c, r, err := repo.LoadRepoFromCAR(ctx, fi)
259
259
if err != nil {
260
260
return err
261
261
}
+2
-2
cmd/relay/bgs/validator.go
+2
-2
cmd/relay/bgs/validator.go
···
174
174
hasWarning = true
175
175
}
176
176
177
-
commit, repoFragment, err := atrepo.LoadFromCAR(ctx, bytes.NewReader([]byte(msg.Blocks)))
177
+
commit, repoFragment, err := atrepo.LoadRepoFromCAR(ctx, bytes.NewReader([]byte(msg.Blocks)))
178
178
if err != nil {
179
179
commitVerifyErrors.WithLabelValues(hostname, "car").Inc()
180
180
return nil, err
···
326
326
return nil, err
327
327
}
328
328
329
-
commit, err := atrepo.LoadCARCommit(ctx, bytes.NewReader([]byte(msg.Blocks)))
329
+
commit, _, err := atrepo.LoadCommitFromCAR(ctx, bytes.NewReader([]byte(msg.Blocks)))
330
330
if err != nil {
331
331
commitVerifyErrors.WithLabelValues(hostname, "car").Inc()
332
332
return nil, err