hailey.at
+1
server/handle_account.go
+1
server/handle_account.go
+2
server/handle_identity_get_recommended_did_credentials.go
+2
server/handle_identity_get_recommended_did_credentials.go
···
9
10
func (s *Server) handleGetRecommendedDidCredentials(e echo.Context) error {
11
repo := e.Get("repo").(*models.RepoActor)
12
k, err := atcrypto.ParsePrivateBytesK256(repo.SigningKey)
13
if err != nil {
14
s.logger.Error("error parsing key", "error", err)
15
return helpers.ServerError(e, nil)
16
}
17
creds, err := s.plcClient.CreateDidCredentials(k, "", repo.Actor.Handle)
18
if err != nil {
19
s.logger.Error("error crating did credentials", "error", err)
···
9
10
func (s *Server) handleGetRecommendedDidCredentials(e echo.Context) error {
11
repo := e.Get("repo").(*models.RepoActor)
12
+
13
k, err := atcrypto.ParsePrivateBytesK256(repo.SigningKey)
14
if err != nil {
15
s.logger.Error("error parsing key", "error", err)
16
return helpers.ServerError(e, nil)
17
}
18
+
19
creds, err := s.plcClient.CreateDidCredentials(k, "", repo.Actor.Handle)
20
if err != nil {
21
s.logger.Error("error crating did credentials", "error", err)
+8
-7
server/handle_import_repo.go
+8
-7
server/handle_import_repo.go
···
2
3
import (
4
"bytes"
5
-
"context"
6
"io"
7
"slices"
8
"strings"
···
18
)
19
20
func (s *Server) handleRepoImportRepo(e echo.Context) error {
21
urepo := e.Get("repo").(*models.RepoActor)
22
23
b, err := io.ReadAll(e.Request().Body)
···
52
53
slices.Reverse(orderedBlocks)
54
55
-
if err := bs.PutMany(context.TODO(), orderedBlocks); err != nil {
56
s.logger.Error("could not insert blocks", "error", err)
57
return helpers.ServerError(e, nil)
58
}
59
60
-
r, err := repo.OpenRepo(context.TODO(), bs, cs.Header.Roots[0])
61
if err != nil {
62
s.logger.Error("could not open repo", "error", err)
63
return helpers.ServerError(e, nil)
···
67
68
clock := syntax.NewTIDClock(0)
69
70
-
if err := r.ForEach(context.TODO(), "", func(key string, cid cid.Cid) error {
71
pts := strings.Split(key, "/")
72
nsid := pts[0]
73
rkey := pts[1]
74
cidStr := cid.String()
75
-
b, err := bs.Get(context.TODO(), cid)
76
if err != nil {
77
s.logger.Error("record bytes don't exist in blockstore", "error", err)
78
return helpers.ServerError(e, nil)
···
100
101
tx.Commit()
102
103
-
root, rev, err := r.Commit(context.TODO(), urepo.SignFor)
104
if err != nil {
105
s.logger.Error("error committing", "error", err)
106
return helpers.ServerError(e, nil)
107
}
108
109
-
if err := s.UpdateRepo(context.TODO(), urepo.Repo.Did, root, rev); err != nil {
110
s.logger.Error("error updating repo after commit", "error", err)
111
return helpers.ServerError(e, nil)
112
}
···
2
3
import (
4
"bytes"
5
"io"
6
"slices"
7
"strings"
···
17
)
18
19
func (s *Server) handleRepoImportRepo(e echo.Context) error {
20
+
ctx := e.Request().Context()
21
+
22
urepo := e.Get("repo").(*models.RepoActor)
23
24
b, err := io.ReadAll(e.Request().Body)
···
53
54
slices.Reverse(orderedBlocks)
55
56
+
if err := bs.PutMany(ctx, orderedBlocks); err != nil {
57
s.logger.Error("could not insert blocks", "error", err)
58
return helpers.ServerError(e, nil)
59
}
60
61
+
r, err := repo.OpenRepo(ctx, bs, cs.Header.Roots[0])
62
if err != nil {
63
s.logger.Error("could not open repo", "error", err)
64
return helpers.ServerError(e, nil)
···
68
69
clock := syntax.NewTIDClock(0)
70
71
+
if err := r.ForEach(ctx, "", func(key string, cid cid.Cid) error {
72
pts := strings.Split(key, "/")
73
nsid := pts[0]
74
rkey := pts[1]
75
cidStr := cid.String()
76
+
b, err := bs.Get(ctx, cid)
77
if err != nil {
78
s.logger.Error("record bytes don't exist in blockstore", "error", err)
79
return helpers.ServerError(e, nil)
···
101
102
tx.Commit()
103
104
+
root, rev, err := r.Commit(ctx, urepo.SignFor)
105
if err != nil {
106
s.logger.Error("error committing", "error", err)
107
return helpers.ServerError(e, nil)
108
}
109
110
+
if err := s.UpdateRepo(ctx, urepo.Repo.Did, root, rev); err != nil {
111
s.logger.Error("error updating repo after commit", "error", err)
112
return helpers.ServerError(e, nil)
113
}
+3
-1
server/handle_repo_apply_writes.go
+3
-1
server/handle_repo_apply_writes.go
···
26
}
27
28
func (s *Server) handleApplyWrites(e echo.Context) error {
29
repo := e.Get("repo").(*models.RepoActor)
30
31
var req ComAtprotoRepoApplyWritesRequest
···
54
})
55
}
56
57
-
results, err := s.repoman.applyWrites(repo.Repo, ops, req.SwapCommit)
58
if err != nil {
59
s.logger.Error("error applying writes", "error", err)
60
return helpers.ServerError(e, nil)
···
26
}
27
28
func (s *Server) handleApplyWrites(e echo.Context) error {
29
+
ctx := e.Request().Context()
30
+
31
repo := e.Get("repo").(*models.RepoActor)
32
33
var req ComAtprotoRepoApplyWritesRequest
···
56
})
57
}
58
59
+
results, err := s.repoman.applyWrites(ctx, repo.Repo, ops, req.SwapCommit)
60
if err != nil {
61
s.logger.Error("error applying writes", "error", err)
62
return helpers.ServerError(e, nil)
+3
-1
server/handle_repo_create_record.go
+3
-1
server/handle_repo_create_record.go
···
17
}
18
19
func (s *Server) handleCreateRecord(e echo.Context) error {
20
repo := e.Get("repo").(*models.RepoActor)
21
22
var req ComAtprotoRepoCreateRecordRequest
···
40
optype = OpTypeUpdate
41
}
42
43
-
results, err := s.repoman.applyWrites(repo.Repo, []Op{
44
{
45
Type: optype,
46
Collection: req.Collection,
···
17
}
18
19
func (s *Server) handleCreateRecord(e echo.Context) error {
20
+
ctx := e.Request().Context()
21
+
22
repo := e.Get("repo").(*models.RepoActor)
23
24
var req ComAtprotoRepoCreateRecordRequest
···
42
optype = OpTypeUpdate
43
}
44
45
+
results, err := s.repoman.applyWrites(ctx, repo.Repo, []Op{
46
{
47
Type: optype,
48
Collection: req.Collection,
+3
-1
server/handle_repo_delete_record.go
+3
-1
server/handle_repo_delete_record.go
···
15
}
16
17
func (s *Server) handleDeleteRecord(e echo.Context) error {
18
repo := e.Get("repo").(*models.RepoActor)
19
20
var req ComAtprotoRepoDeleteRecordRequest
···
33
return helpers.InputError(e, nil)
34
}
35
36
-
results, err := s.repoman.applyWrites(repo.Repo, []Op{
37
{
38
Type: OpTypeDelete,
39
Collection: req.Collection,
···
15
}
16
17
func (s *Server) handleDeleteRecord(e echo.Context) error {
18
+
ctx := e.Request().Context()
19
+
20
repo := e.Get("repo").(*models.RepoActor)
21
22
var req ComAtprotoRepoDeleteRecordRequest
···
35
return helpers.InputError(e, nil)
36
}
37
38
+
results, err := s.repoman.applyWrites(ctx, repo.Repo, []Op{
39
{
40
Type: OpTypeDelete,
41
Collection: req.Collection,
+3
-1
server/handle_repo_put_record.go
+3
-1
server/handle_repo_put_record.go
···
17
}
18
19
func (s *Server) handlePutRecord(e echo.Context) error {
20
repo := e.Get("repo").(*models.RepoActor)
21
22
var req ComAtprotoRepoPutRecordRequest
···
40
optype = OpTypeUpdate
41
}
42
43
-
results, err := s.repoman.applyWrites(repo.Repo, []Op{
44
{
45
Type: optype,
46
Collection: req.Collection,
···
17
}
18
19
func (s *Server) handlePutRecord(e echo.Context) error {
20
+
ctx := e.Request().Context()
21
+
22
repo := e.Get("repo").(*models.RepoActor)
23
24
var req ComAtprotoRepoPutRecordRequest
···
42
optype = OpTypeUpdate
43
}
44
45
+
results, err := s.repoman.applyWrites(ctx, repo.Repo, []Op{
46
{
47
Type: optype,
48
Collection: req.Collection,
+3
-1
server/handle_sync_get_record.go
+3
-1
server/handle_sync_get_record.go
···
13
)
14
15
func (s *Server) handleSyncGetRecord(e echo.Context) error {
16
did := e.QueryParam("did")
17
collection := e.QueryParam("collection")
18
rkey := e.QueryParam("rkey")
···
23
return helpers.ServerError(e, nil)
24
}
25
26
-
root, blocks, err := s.repoman.getRecordProof(urepo, collection, rkey)
27
if err != nil {
28
return err
29
}
···
13
)
14
15
func (s *Server) handleSyncGetRecord(e echo.Context) error {
16
+
ctx := e.Request().Context()
17
+
18
did := e.QueryParam("did")
19
collection := e.QueryParam("collection")
20
rkey := e.QueryParam("rkey")
···
25
return helpers.ServerError(e, nil)
26
}
27
28
+
root, blocks, err := s.repoman.getRecordProof(ctx, urepo, collection, rkey)
29
if err != nil {
30
return err
31
}
+19
-16
server/repo.go
+19
-16
server/repo.go
···
96
}
97
98
// TODO make use of swap commit
99
-
func (rm *RepoMan) applyWrites(urepo models.Repo, writes []Op, swapCommit *string) ([]ApplyWriteResult, error) {
100
rootcid, err := cid.Cast(urepo.Root)
101
if err != nil {
102
return nil, err
···
104
105
dbs := rm.s.getBlockstore(urepo.Did)
106
bs := recording_blockstore.New(dbs)
107
-
r, err := repo.OpenRepo(context.TODO(), bs, rootcid)
108
109
-
entries := []models.Record{}
110
-
var results []ApplyWriteResult
111
112
for i, op := range writes {
113
if op.Type != OpTypeCreate && op.Rkey == nil {
114
return nil, fmt.Errorf("invalid rkey")
115
} else if op.Type == OpTypeCreate && op.Rkey != nil {
116
-
_, _, err := r.GetRecord(context.TODO(), op.Collection+"/"+*op.Rkey)
117
if err == nil {
118
op.Type = OpTypeUpdate
119
}
···
144
mm["$type"] = op.Collection
145
}
146
147
-
nc, err := r.PutRecord(context.TODO(), op.Collection+"/"+*op.Rkey, &mm)
148
if err != nil {
149
return nil, err
150
}
···
177
Rkey: *op.Rkey,
178
Value: old.Value,
179
})
180
-
err := r.DeleteRecord(context.TODO(), op.Collection+"/"+*op.Rkey)
181
if err != nil {
182
return nil, err
183
}
···
194
return nil, err
195
}
196
mm := MarshalableMap(out)
197
-
nc, err := r.UpdateRecord(context.TODO(), op.Collection+"/"+*op.Rkey, &mm)
198
if err != nil {
199
return nil, err
200
}
···
219
}
220
}
221
222
-
newroot, rev, err := r.Commit(context.TODO(), urepo.SignFor)
223
if err != nil {
224
return nil, err
225
}
···
230
Roots: []cid.Cid{newroot},
231
Version: 1,
232
})
233
234
if _, err := carstore.LdWrite(buf, hb); err != nil {
235
return nil, err
236
}
237
238
-
diffops, err := r.DiffSince(context.TODO(), rootcid)
239
if err != nil {
240
return nil, err
241
}
···
270
})
271
}
272
273
-
blk, err := dbs.Get(context.TODO(), c)
274
if err != nil {
275
return nil, err
276
}
···
316
}
317
}
318
319
-
rm.s.evtman.AddEvent(context.TODO(), &events.XRPCStreamEvent{
320
RepoCommit: &atproto.SyncSubscribeRepos_Commit{
321
Repo: urepo.Did,
322
Blocks: buf.Bytes(),
···
330
},
331
})
332
333
-
if err := rm.s.UpdateRepo(context.TODO(), urepo.Did, newroot, rev); err != nil {
334
return nil, err
335
}
336
···
345
return results, nil
346
}
347
348
-
func (rm *RepoMan) getRecordProof(urepo models.Repo, collection, rkey string) (cid.Cid, []blocks.Block, error) {
349
c, err := cid.Cast(urepo.Root)
350
if err != nil {
351
return cid.Undef, nil, err
···
354
dbs := rm.s.getBlockstore(urepo.Did)
355
bs := recording_blockstore.New(dbs)
356
357
-
r, err := repo.OpenRepo(context.TODO(), bs, c)
358
if err != nil {
359
return cid.Undef, nil, err
360
}
361
362
-
_, _, err = r.GetRecordBytes(context.TODO(), collection+"/"+rkey)
363
if err != nil {
364
return cid.Undef, nil, err
365
}
···
96
}
97
98
// TODO make use of swap commit
99
+
func (rm *RepoMan) applyWrites(ctx context.Context, urepo models.Repo, writes []Op, swapCommit *string) ([]ApplyWriteResult, error) {
100
rootcid, err := cid.Cast(urepo.Root)
101
if err != nil {
102
return nil, err
···
104
105
dbs := rm.s.getBlockstore(urepo.Did)
106
bs := recording_blockstore.New(dbs)
107
+
r, err := repo.OpenRepo(ctx, bs, rootcid)
108
109
+
entries := make([]models.Record, 0, len(writes))
110
+
results := make([]ApplyWriteResult, 0, len(writes))
111
112
for i, op := range writes {
113
if op.Type != OpTypeCreate && op.Rkey == nil {
114
return nil, fmt.Errorf("invalid rkey")
115
} else if op.Type == OpTypeCreate && op.Rkey != nil {
116
+
_, _, err := r.GetRecord(ctx, op.Collection+"/"+*op.Rkey)
117
if err == nil {
118
op.Type = OpTypeUpdate
119
}
···
144
mm["$type"] = op.Collection
145
}
146
147
+
nc, err := r.PutRecord(ctx, op.Collection+"/"+*op.Rkey, &mm)
148
if err != nil {
149
return nil, err
150
}
···
177
Rkey: *op.Rkey,
178
Value: old.Value,
179
})
180
+
err := r.DeleteRecord(ctx, op.Collection+"/"+*op.Rkey)
181
if err != nil {
182
return nil, err
183
}
···
194
return nil, err
195
}
196
mm := MarshalableMap(out)
197
+
nc, err := r.UpdateRecord(ctx, op.Collection+"/"+*op.Rkey, &mm)
198
if err != nil {
199
return nil, err
200
}
···
219
}
220
}
221
222
+
newroot, rev, err := r.Commit(ctx, urepo.SignFor)
223
if err != nil {
224
return nil, err
225
}
···
230
Roots: []cid.Cid{newroot},
231
Version: 1,
232
})
233
+
if err != nil {
234
+
return nil, err
235
+
}
236
237
if _, err := carstore.LdWrite(buf, hb); err != nil {
238
return nil, err
239
}
240
241
+
diffops, err := r.DiffSince(ctx, rootcid)
242
if err != nil {
243
return nil, err
244
}
···
273
})
274
}
275
276
+
blk, err := dbs.Get(ctx, c)
277
if err != nil {
278
return nil, err
279
}
···
319
}
320
}
321
322
+
rm.s.evtman.AddEvent(ctx, &events.XRPCStreamEvent{
323
RepoCommit: &atproto.SyncSubscribeRepos_Commit{
324
Repo: urepo.Did,
325
Blocks: buf.Bytes(),
···
333
},
334
})
335
336
+
if err := rm.s.UpdateRepo(ctx, urepo.Did, newroot, rev); err != nil {
337
return nil, err
338
}
339
···
348
return results, nil
349
}
350
351
+
func (rm *RepoMan) getRecordProof(ctx context.Context, urepo models.Repo, collection, rkey string) (cid.Cid, []blocks.Block, error) {
352
c, err := cid.Cast(urepo.Root)
353
if err != nil {
354
return cid.Undef, nil, err
···
357
dbs := rm.s.getBlockstore(urepo.Did)
358
bs := recording_blockstore.New(dbs)
359
360
+
r, err := repo.OpenRepo(ctx, bs, c)
361
if err != nil {
362
return cid.Undef, nil, err
363
}
364
365
+
_, _, err = r.GetRecordBytes(ctx, collection+"/"+rkey)
366
if err != nil {
367
return cid.Undef, nil, err
368
}