alice.pds.demo.boltless.dev
This repository has no description
appview,knotserver,spindle: rework jetstream
do not return errors from ingesters, this causes the read loop to be
killed.
Signed-off-by: oppiliappan <me@oppi.li>
author
oppiliappan
committer
Tangled
date
(Aug 16, 2025, 7:44 AM UTC)
commit
c8d76b33
c8d76b339b7c6a30de0d7935853dde8618e62819
parent
bb4ac7ec
bb4ac7ec31cb6f3502b232dade3ae4fbb750e525
+70
-58
+2
-2
appview/ingester.go
+2
-2
appview/ingester.go
+6
-4
jetstream/jetstream.go
+6
-4
jetstream/jetstream.go
···
68
68
type processor func(context.Context, *models.Event) error
69
69
70
70
func (j *JetstreamClient) withDidFilter(processFunc processor) processor {
71
-
// empty filter => all dids allowed
72
-
if len(j.wantedDids) == 0 {
73
-
return processFunc
74
-
}
75
71
// since this closure references j.WantedDids; it should auto-update
76
72
// existing instances of the closure when j.WantedDids is mutated
77
73
return func(ctx context.Context, evt *models.Event) error {
74
+
75
+
// empty filter => all dids allowed
76
+
if len(j.wantedDids) == 0 {
77
+
return processFunc(ctx, evt)
78
+
}
79
+
78
80
if _, ok := j.wantedDids[evt.Did]; ok {
79
81
return processFunc(ctx, evt)
80
82
} else {
+5
-5
knotserver/handler.go
+5
-5
knotserver/handler.go
···
52
52
return nil, fmt.Errorf("failed to setup enforcer: %w", err)
53
53
}
54
54
55
-
err = h.jc.StartJetstream(ctx, h.processMessages)
56
-
if err != nil {
57
-
return nil, fmt.Errorf("failed to start jetstream: %w", err)
58
-
}
59
-
60
55
// Check if the knot knows about any Dids;
61
56
// if it does, it is already initialized and we can repopulate the
62
57
// Jetstream subscriptions.
···
71
66
for _, d := range dids {
72
67
h.jc.AddDid(d)
73
68
}
69
+
}
70
+
71
+
err = h.jc.StartJetstream(ctx, h.processMessages)
72
+
if err != nil {
73
+
return nil, fmt.Errorf("failed to start jetstream: %w", err)
74
74
}
75
75
76
76
r.Get("/", h.Index)
+46
-42
knotserver/ingester.go
+46
-42
knotserver/ingester.go
···
25
25
"tangled.sh/tangled.sh/core/workflow"
26
26
)
27
27
28
-
func (h *Handle) processPublicKey(ctx context.Context, did string, record tangled.PublicKey) error {
28
+
func (h *Handle) processPublicKey(ctx context.Context, event *models.Event) error {
29
29
l := log.FromContext(ctx)
30
+
raw := json.RawMessage(event.Commit.Record)
31
+
did := event.Did
32
+
33
+
var record tangled.PublicKey
34
+
if err := json.Unmarshal(raw, &record); err != nil {
35
+
return fmt.Errorf("failed to unmarshal record: %w", err)
36
+
}
37
+
30
38
pk := db.PublicKey{
31
39
Did: did,
32
40
PublicKey: record,
···
39
47
return nil
40
48
}
41
49
42
-
func (h *Handle) processKnotMember(ctx context.Context, did string, record tangled.KnotMember) error {
50
+
func (h *Handle) processKnotMember(ctx context.Context, event *models.Event) error {
43
51
l := log.FromContext(ctx)
52
+
raw := json.RawMessage(event.Commit.Record)
53
+
did := event.Did
54
+
55
+
var record tangled.KnotMember
56
+
if err := json.Unmarshal(raw, &record); err != nil {
57
+
return fmt.Errorf("failed to unmarshal record: %w", err)
58
+
}
44
59
45
60
if record.Domain != h.c.Server.Hostname {
46
61
l.Error("domain mismatch", "domain", record.Domain, "expected", h.c.Server.Hostname)
···
72
87
return nil
73
88
}
74
89
75
-
func (h *Handle) processPull(ctx context.Context, did string, record tangled.RepoPull) error {
90
+
func (h *Handle) processPull(ctx context.Context, event *models.Event) error {
91
+
raw := json.RawMessage(event.Commit.Record)
92
+
did := event.Did
93
+
94
+
var record tangled.RepoPull
95
+
if err := json.Unmarshal(raw, &record); err != nil {
96
+
return fmt.Errorf("failed to unmarshal record: %w", err)
97
+
}
98
+
76
99
l := log.FromContext(ctx)
77
100
l = l.With("handler", "processPull")
78
101
l = l.With("did", did)
···
200
223
return nil
201
224
}
202
225
203
-
event := db.Event{
226
+
ev := db.Event{
204
227
Rkey: TID(),
205
228
Nsid: tangled.PipelineNSID,
206
229
EventJson: string(eventJson),
207
230
}
208
231
209
-
return h.db.InsertEvent(event, h.n)
232
+
return h.db.InsertEvent(ev, h.n)
210
233
}
211
234
212
235
// duplicated from add collaborator
213
-
func (h *Handle) processCollaborator(ctx context.Context, did string, record tangled.RepoCollaborator) error {
236
+
func (h *Handle) processCollaborator(ctx context.Context, event *models.Event) error {
237
+
raw := json.RawMessage(event.Commit.Record)
238
+
did := event.Did
239
+
240
+
var record tangled.RepoCollaborator
241
+
if err := json.Unmarshal(raw, &record); err != nil {
242
+
return fmt.Errorf("failed to unmarshal record: %w", err)
243
+
}
244
+
214
245
repoAt, err := syntax.ParseATURI(record.Repo)
215
246
if err != nil {
216
247
return err
···
243
274
didSlashRepo, _ := securejoin.SecureJoin(owner.DID.String(), repo.Name)
244
275
245
276
// check perms for this user
246
-
if ok, err := h.e.IsCollaboratorInviteAllowed(owner.DID.String(), rbac.ThisServer, didSlashRepo); !ok || err != nil {
277
+
if ok, err := h.e.IsCollaboratorInviteAllowed(did, rbac.ThisServer, didSlashRepo); !ok || err != nil {
247
278
return fmt.Errorf("insufficient permissions: %w", err)
248
279
}
249
280
···
303
334
}
304
335
305
336
func (h *Handle) processMessages(ctx context.Context, event *models.Event) error {
306
-
did := event.Did
307
337
if event.Kind != models.EventKindCommit {
308
338
return nil
309
339
}
···
317
347
}
318
348
}()
319
349
320
-
raw := json.RawMessage(event.Commit.Record)
321
-
322
350
switch event.Commit.Collection {
323
351
case tangled.PublicKeyNSID:
324
-
var record tangled.PublicKey
325
-
if err := json.Unmarshal(raw, &record); err != nil {
326
-
return fmt.Errorf("failed to unmarshal record: %w", err)
327
-
}
328
-
if err := h.processPublicKey(ctx, did, record); err != nil {
329
-
return fmt.Errorf("failed to process public key: %w", err)
330
-
}
331
-
352
+
err = h.processPublicKey(ctx, event)
332
353
case tangled.KnotMemberNSID:
333
-
var record tangled.KnotMember
334
-
if err := json.Unmarshal(raw, &record); err != nil {
335
-
return fmt.Errorf("failed to unmarshal record: %w", err)
336
-
}
337
-
if err := h.processKnotMember(ctx, did, record); err != nil {
338
-
return fmt.Errorf("failed to process knot member: %w", err)
339
-
}
340
-
354
+
err = h.processKnotMember(ctx, event)
341
355
case tangled.RepoPullNSID:
342
-
var record tangled.RepoPull
343
-
if err := json.Unmarshal(raw, &record); err != nil {
344
-
return fmt.Errorf("failed to unmarshal record: %w", err)
345
-
}
346
-
if err := h.processPull(ctx, did, record); err != nil {
347
-
return fmt.Errorf("failed to process knot member: %w", err)
348
-
}
349
-
356
+
err = h.processPull(ctx, event)
350
357
case tangled.RepoCollaboratorNSID:
351
-
var record tangled.RepoCollaborator
352
-
if err := json.Unmarshal(raw, &record); err != nil {
353
-
return fmt.Errorf("failed to unmarshal record: %w", err)
354
-
}
355
-
if err := h.processCollaborator(ctx, did, record); err != nil {
356
-
return fmt.Errorf("failed to process knot member: %w", err)
357
-
}
358
+
err = h.processCollaborator(ctx, event)
359
+
}
358
360
361
+
if err != nil {
362
+
h.l.Debug("failed to process event", "nsid", event.Commit.Collection, "err", err)
359
363
}
360
364
361
-
return err
365
+
return nil
362
366
}
+3
-1
log/log.go
+3
-1
log/log.go
···
9
9
// NewHandler sets up a new slog.Handler with the service name
10
10
// as an attribute
11
11
func NewHandler(name string) slog.Handler {
12
-
handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{})
12
+
handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
13
+
Level: slog.LevelDebug,
14
+
})
13
15
14
16
var attrs []slog.Attr
15
17
attrs = append(attrs, slog.Attr{Key: "service", Value: slog.StringValue(name)})
+8
-4
spindle/ingester.go
+8
-4
spindle/ingester.go
···
40
40
41
41
switch e.Commit.Collection {
42
42
case tangled.SpindleMemberNSID:
43
-
s.ingestMember(ctx, e)
43
+
err = s.ingestMember(ctx, e)
44
44
case tangled.RepoNSID:
45
-
s.ingestRepo(ctx, e)
45
+
err = s.ingestRepo(ctx, e)
46
46
case tangled.RepoCollaboratorNSID:
47
-
s.ingestCollaborator(ctx, e)
47
+
err = s.ingestCollaborator(ctx, e)
48
48
}
49
49
50
-
return err
50
+
if err != nil {
51
+
s.l.Debug("failed to process message", "nsid", e.Commit.Collection, "err", err)
52
+
}
53
+
54
+
return nil
51
55
}
52
56
}
53
57