From d76afb6901e7200abc04388133545e37df73286a Mon Sep 17 00:00:00 2001 From: bryan newbold Date: Tue, 20 Feb 2024 22:50:50 -0800 Subject: [PATCH 1/6] engine: switch RecordOp type to hold record CBOR, not unmarshaled 'any' --- automod/engine/action_dedupe_test.go | 6 +++++- automod/engine/circuit_breaker_test.go | 11 +++++++++-- automod/engine/context.go | 7 +++---- automod/engine/engine_test.go | 12 ++++++++++-- automod/engine/ruleset.go | 17 +++++++++-------- 5 files changed, 36 insertions(+), 17 deletions(-) diff --git a/automod/engine/action_dedupe_test.go b/automod/engine/action_dedupe_test.go index 80fc985e..313f0fe0 100644 --- a/automod/engine/action_dedupe_test.go +++ b/automod/engine/action_dedupe_test.go @@ -1,6 +1,7 @@ package engine import ( + "bytes" "context" "testing" @@ -30,6 +31,9 @@ func TestAccountReportDedupe(t *testing.T) { //path := "app.bsky.feed.post/abc123" cid1 := syntax.CID("cid123") p1 := appbsky.FeedPost{Text: "some post blah"} + p1buf := new(bytes.Buffer) + assert.NoError(p1.MarshalCBOR(p1buf)) + p1cbor := p1buf.Bytes() id1 := identity.Identity{ DID: syntax.DID("did:plc:abc111"), Handle: syntax.Handle("handle.example.com"), @@ -42,7 +46,7 @@ func TestAccountReportDedupe(t *testing.T) { Collection: "app.bsky.feed.post", RecordKey: "abc123", CID: &cid1, - Value: &p1, + RecordCBOR: &p1cbor, } for i := 0; i < 5; i++ { assert.NoError(eng.ProcessRecordOp(ctx, op)) diff --git a/automod/engine/circuit_breaker_test.go b/automod/engine/circuit_breaker_test.go index abab64c1..77ab488d 100644 --- a/automod/engine/circuit_breaker_test.go +++ b/automod/engine/circuit_breaker_test.go @@ -1,6 +1,7 @@ package engine import ( + "bytes" "context" "fmt" "testing" @@ -38,6 +39,9 @@ func TestTakedownCircuitBreaker(t *testing.T) { cid1 := syntax.CID("cid123") p1 := appbsky.FeedPost{Text: "some post blah"} + p1buf := new(bytes.Buffer) + assert.NoError(p1.MarshalCBOR(p1buf)) + p1cbor := p1buf.Bytes() // generate double the quote of events; expect to only count the quote worth of actions for i := 0; i < 2*QuotaModTakedownDay; i++ { @@ -52,7 +56,7 @@ func TestTakedownCircuitBreaker(t *testing.T) { Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - Value: &p1, + RecordCBOR: &p1cbor, } assert.NoError(eng.ProcessRecordOp(ctx, op)) } @@ -80,6 +84,9 @@ func TestReportCircuitBreaker(t *testing.T) { cid1 := syntax.CID("cid123") p1 := appbsky.FeedPost{Text: "some post blah"} + p1buf := new(bytes.Buffer) + assert.NoError(p1.MarshalCBOR(p1buf)) + p1cbor := p1buf.Bytes() // generate double the quota of events; expect to only count the quota worth of actions for i := 0; i < 2*QuotaModReportDay; i++ { @@ -94,7 +101,7 @@ func TestReportCircuitBreaker(t *testing.T) { Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - Value: &p1, + RecordCBOR: &p1cbor, } assert.NoError(eng.ProcessRecordOp(ctx, op)) } diff --git a/automod/engine/context.go b/automod/engine/context.go index 6e558b94..8f9f1dea 100644 --- a/automod/engine/context.go +++ b/automod/engine/context.go @@ -52,8 +52,7 @@ type RecordOp struct { Collection syntax.NSID RecordKey syntax.RecordKey CID *syntax.CID - // NOTE: usually a *pointer*, not the value itself - Value any + RecordCBOR *[]byte } // Originally intended for push notifications, but can also work for any inter-account notification. @@ -76,11 +75,11 @@ type NotificationMeta struct { func (op *RecordOp) Validate() error { switch op.Action { case CreateOp, UpdateOp: - if op.Value == nil || op.CID == nil { + if op.RecordCBOR == nil || op.CID == nil { return fmt.Errorf("expected record create/update op to contain both value and CID") } case DeleteOp: - if op.Value != nil || op.CID != nil { + if op.RecordCBOR != nil || op.CID != nil { return fmt.Errorf("expected record delete op to be empty") } default: diff --git a/automod/engine/engine_test.go b/automod/engine/engine_test.go index d0760943..fc792812 100644 --- a/automod/engine/engine_test.go +++ b/automod/engine/engine_test.go @@ -1,6 +1,7 @@ package engine import ( + "bytes" "context" "testing" @@ -24,13 +25,17 @@ func TestEngineBasics(t *testing.T) { p1 := appbsky.FeedPost{ Text: "some post blah", } + p1buf := new(bytes.Buffer) + assert.NoError(p1.MarshalCBOR(p1buf)) + p1cbor := p1buf.Bytes() + op := RecordOp{ Action: CreateOp, DID: id1.DID, Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - Value: &p1, + RecordCBOR: &p1cbor, } assert.NoError(eng.ProcessRecordOp(ctx, op)) @@ -38,6 +43,9 @@ func TestEngineBasics(t *testing.T) { Text: "some post blah", Tags: []string{"one", "slur"}, } - op.Value = &p2 + p2buf := new(bytes.Buffer) + assert.NoError(p2.MarshalCBOR(p2buf)) + p2cbor := p2buf.Bytes() + op.RecordCBOR = &p2cbor assert.NoError(eng.ProcessRecordOp(ctx, op)) } diff --git a/automod/engine/ruleset.go b/automod/engine/ruleset.go index 33528a56..c49014e5 100644 --- a/automod/engine/ruleset.go +++ b/automod/engine/ruleset.go @@ -1,6 +1,7 @@ package engine import ( + "bytes" "fmt" "sync" @@ -31,23 +32,23 @@ func (r *RuleSet) CallRecordRules(c *RecordContext) error { // then any record-type-specific rules switch c.RecordOp.Collection.String() { case "app.bsky.feed.post": - post, ok := c.RecordOp.Value.(*appbsky.FeedPost) - if !ok { - return fmt.Errorf("mismatch between collection (%s) and type", c.RecordOp.Collection) + var post appbsky.FeedPost + if err := post.UnmarshalCBOR(bytes.NewReader(*c.RecordOp.RecordCBOR)); err != nil { + return fmt.Errorf("failed to parse app.bsky.feed.post record: %v", err) } for _, f := range r.PostRules { - err := f(c, post) + err := f(c, &post) if err != nil { c.Logger.Error("post rule execution failed", "err", err) } } case "app.bsky.actor.profile": - profile, ok := c.RecordOp.Value.(*appbsky.ActorProfile) - if !ok { - return fmt.Errorf("mismatch between collection (%s) and type", c.RecordOp.Collection) + var profile appbsky.ActorProfile + if err := profile.UnmarshalCBOR(bytes.NewReader(*c.RecordOp.RecordCBOR)); err != nil { + return fmt.Errorf("failed to parse app.bsky.actor.profile record: %v", err) } for _, f := range r.ProfileRules { - err := f(c, profile) + err := f(c, &profile) if err != nil { c.Logger.Error("profile rule execution failed", "err", err) } -- 2.51.2 From 55f7d0bc6c6ab3857f29a3b1e36ce7c70647c7bc Mon Sep 17 00:00:00 2001 From: bryan newbold Date: Tue, 20 Feb 2024 22:51:20 -0800 Subject: [PATCH 2/6] engine: make blob extraction generic, using atproto/data package --- automod/engine/blobs.go | 85 +++++++++-------------------------------- 1 file changed, 17 insertions(+), 68 deletions(-) diff --git a/automod/engine/blobs.go b/automod/engine/blobs.go index 2155bbb0..7b5ae797 100644 --- a/automod/engine/blobs.go +++ b/automod/engine/blobs.go @@ -7,7 +7,7 @@ import ( "strings" "time" - appbsky "github.com/bluesky-social/indigo/api/bsky" + "github.com/bluesky-social/indigo/atproto/data" lexutil "github.com/bluesky-social/indigo/lex/util" "github.com/carlmjohnson/versioninfo" @@ -15,81 +15,30 @@ import ( // Parses out any blobs from the enclosed record. // -// TODO: currently this function uses schema-specific logic, and won't work with generic lexicon records. A future version could use the indigo/atproto/data package and the raw record CBOR to extract blobs from arbitrary records -// -// NOTE: for consistency with other RecordContext methods, which don't usually return errors, maybe the error-returning version of this function should be a helper function, or definted on RecordOp, and the RecordContext version should return an empty array on error? +// NOTE: for consistency with other RecordContext methods, which don't usually return errors, maybe the error-returning version of this function should be a helper function, or defined on RecordOp, and the RecordContext version should return an empty array on error? func (c *RecordContext) Blobs() ([]lexutil.LexBlob, error) { if c.RecordOp.Action == DeleteOp { return []lexutil.LexBlob{}, nil } - var blobs []lexutil.LexBlob - - switch c.RecordOp.Collection.String() { - case "app.bsky.feed.post": - post, ok := c.RecordOp.Value.(*appbsky.FeedPost) - if !ok { - return nil, fmt.Errorf("mismatch between collection (%s) and type", c.RecordOp.Collection) - } - if post.Embed != nil && post.Embed.EmbedImages != nil { - for _, eii := range post.Embed.EmbedImages.Images { - if eii.Image != nil { - blobs = append(blobs, *eii.Image) - } - } - } - if post.Embed != nil && post.Embed.EmbedExternal != nil { - ext := post.Embed.EmbedExternal.External - if ext != nil && ext.Thumb != nil { - blobs = append(blobs, *ext.Thumb) - } - } - if post.Embed != nil && post.Embed.EmbedRecordWithMedia != nil { - media := post.Embed.EmbedRecordWithMedia.Media - if media != nil && media.EmbedImages != nil { - for _, eii := range media.EmbedImages.Images { - if eii.Image != nil { - blobs = append(blobs, *eii.Image) - } - } - } - if media != nil && media.EmbedExternal != nil { - ext := media.EmbedExternal.External - if ext != nil && ext.Thumb != nil { - blobs = append(blobs, *ext.Thumb) - } - } - } - case "app.bsky.actor.profile": - profile, ok := c.RecordOp.Value.(*appbsky.ActorProfile) - if !ok { - return nil, fmt.Errorf("mismatch between collection (%s) and type", c.RecordOp.Collection) - } - if profile.Avatar != nil { - blobs = append(blobs, *profile.Avatar) - } - if profile.Banner != nil { - blobs = append(blobs, *profile.Banner) - } - case "app.bsky.graph.list": - list, ok := c.RecordOp.Value.(*appbsky.GraphList) - if !ok { - return nil, fmt.Errorf("mismatch between collection (%s) and type", c.RecordOp.Collection) - } - if list.Avatar != nil { - blobs = append(blobs, *list.Avatar) - } - case "app.bsky.feed.generator": - generator, ok := c.RecordOp.Value.(*appbsky.FeedGenerator) - if !ok { - return nil, fmt.Errorf("mismatch between collection (%s) and type", c.RecordOp.Collection) - } - if generator.Avatar != nil { - blobs = append(blobs, *generator.Avatar) + rec, err := data.UnmarshalCBOR(*c.RecordOp.RecordCBOR) + if err != nil { + return nil, fmt.Errorf("parsing generic record CBOR: %v", err) + } + blobs := data.ExtractBlobs(rec) + + // convert from data.Blob to lexutil.LexBlob; plan is to merge these types eventually + var out []lexutil.LexBlob + for _, b := range blobs { + lb := lexutil.LexBlob{ + Ref: lexutil.LexLink(b.Ref), + MimeType: b.MimeType, + Size: b.Size, } + out = append(out, lb) } - return blobs, nil + return out, nil } func (c *RecordContext) fetchBlob(blob lexutil.LexBlob) ([]byte, error) { -- 2.51.2 From cf33be8132cf291d0b42c01625acdda801d35705 Mon Sep 17 00:00:00 2001 From: bryan newbold Date: Tue, 20 Feb 2024 22:51:42 -0800 Subject: [PATCH 3/6] capture: updates for RecordOp CBOR --- automod/capture/fetch.go | 15 +++++++++++++-- automod/capture/testing.go | 8 +++++++- 2 files changed, 20 insertions(+), 3 deletions(-) diff --git a/automod/capture/fetch.go b/automod/capture/fetch.go index 7801f208..17fff408 100644 --- a/automod/capture/fetch.go +++ b/automod/capture/fetch.go @@ -1,6 +1,7 @@ package capture import ( + "bytes" "context" "fmt" @@ -35,13 +36,18 @@ func FetchAndProcessRecord(ctx context.Context, eng *automod.Engine, aturi synta return fmt.Errorf("expected a CID in getRecord response") } recCID := syntax.CID(*out.Cid) + recBuf := new(bytes.Buffer) + if err := out.Value.Val.MarshalCBOR(recBuf); err != nil { + return err + } + recBytes := recBuf.Bytes() op := automod.RecordOp{ Action: automod.CreateOp, DID: ident.DID, Collection: aturi.Collection(), RecordKey: aturi.RecordKey(), CID: &recCID, - Value: out.Value.Val, + RecordCBOR: &recBytes, } return eng.ProcessRecordOp(ctx, op) } @@ -79,13 +85,18 @@ func FetchAndProcessRecent(ctx context.Context, eng *automod.Engine, atid syntax return fmt.Errorf("parsing PDS record response: %v", err) } recCID := syntax.CID(rec.Cid) + recBuf := new(bytes.Buffer) + if err := rec.Value.Val.MarshalCBOR(recBuf); err != nil { + return err + } + recBytes := recBuf.Bytes() op := automod.RecordOp{ Action: automod.CreateOp, DID: ident.DID, Collection: aturi.Collection(), RecordKey: aturi.RecordKey(), CID: &recCID, - Value: rec.Value.Val, + RecordCBOR: &recBytes, } err = eng.ProcessRecordOp(ctx, op) if err != nil { diff --git a/automod/capture/testing.go b/automod/capture/testing.go index 56cd6c28..b8a4e32c 100644 --- a/automod/capture/testing.go +++ b/automod/capture/testing.go @@ -1,6 +1,7 @@ package capture import ( + "bytes" "context" "encoding/json" "io" @@ -55,6 +56,11 @@ func ProcessCaptureRules(eng *automod.Engine, capture AccountCapture) error { return err } recCID := syntax.CID(pr.Cid) + recBuf := new(bytes.Buffer) + if err := pr.Value.Val.MarshalCBOR(recBuf); err != nil { + return err + } + recBytes := recBuf.Bytes() eng.Logger.Debug("processing record", "did", did) op := automod.RecordOp{ Action: automod.CreateOp, @@ -62,7 +68,7 @@ func ProcessCaptureRules(eng *automod.Engine, capture AccountCapture) error { Collection: aturi.Collection(), RecordKey: aturi.RecordKey(), CID: &recCID, - Value: pr.Value.Val, + RecordCBOR: &recBytes, } eng.ProcessRecordOp(ctx, op) } -- 2.51.2 From 3f89cc9493f17a69a2f012c663f5b9f77cf8f497 Mon Sep 17 00:00:00 2001 From: bryan newbold Date: Tue, 20 Feb 2024 22:51:53 -0800 Subject: [PATCH 4/6] rules: updates for RecordOp CBOR --- automod/rules/hashtags_test.go | 11 +++++++++-- automod/rules/keyword.go | 13 +++++++------ automod/rules/keyword_test.go | 11 +++++++++-- automod/rules/misleading_test.go | 11 +++++++++-- 4 files changed, 34 insertions(+), 12 deletions(-) diff --git a/automod/rules/hashtags_test.go b/automod/rules/hashtags_test.go index 4c6e060f..92c9bcd8 100644 --- a/automod/rules/hashtags_test.go +++ b/automod/rules/hashtags_test.go @@ -1,6 +1,7 @@ package rules import ( + "bytes" "context" "testing" @@ -28,13 +29,16 @@ func TestBadHashtagPostRule(t *testing.T) { p1 := appbsky.FeedPost{ Text: "some post blah", } + p1buf := new(bytes.Buffer) + assert.NoError(p1.MarshalCBOR(p1buf)) + p1cbor := p1buf.Bytes() op := engine.RecordOp{ Action: engine.CreateOp, DID: am1.Identity.DID, Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - Value: p1, + RecordCBOR: &p1cbor, } c1 := engine.NewRecordContext(ctx, &eng, am1, op) assert.NoError(BadHashtagsPostRule(&c1, &p1)) @@ -45,7 +49,10 @@ func TestBadHashtagPostRule(t *testing.T) { Text: "some post blah", Tags: []string{"one", "slur"}, } - op.Value = p2 + p2buf := new(bytes.Buffer) + assert.NoError(p2.MarshalCBOR(p2buf)) + p2cbor := p2buf.Bytes() + op.RecordCBOR = &p2cbor c2 := engine.NewRecordContext(ctx, &eng, am1, op) assert.NoError(BadHashtagsPostRule(&c2, &p2)) eff2 := engine.ExtractEffects(&c2.BaseContext) diff --git a/automod/rules/keyword.go b/automod/rules/keyword.go index 4c260750..c013a1af 100644 --- a/automod/rules/keyword.go +++ b/automod/rules/keyword.go @@ -1,6 +1,7 @@ package rules import ( + "bytes" "fmt" "strings" @@ -82,9 +83,9 @@ func BadWordOtherRecordRule(c *automod.RecordContext) error { text := "" switch c.RecordOp.Collection.String() { case "app.bsky.graph.list": - list, ok := c.RecordOp.Value.(*appbsky.GraphList) - if !ok { - return fmt.Errorf("mismatch between collection (%s) and type", c.RecordOp.Collection) + var list appbsky.GraphList + if err := list.UnmarshalCBOR(bytes.NewReader(*c.RecordOp.RecordCBOR)); err != nil { + return fmt.Errorf("failed to parse app.bsky.graph.list record: %v", err) } name += " " + list.Name if list.Description != nil { @@ -94,9 +95,9 @@ func BadWordOtherRecordRule(c *automod.RecordContext) error { text += " " + *list.Purpose } case "app.bsky.feed.generator": - generator, ok := c.RecordOp.Value.(*appbsky.FeedGenerator) - if !ok { - return fmt.Errorf("mismatch between collection (%s) and type", c.RecordOp.Collection) + var generator appbsky.FeedGenerator + if err := generator.UnmarshalCBOR(bytes.NewReader(*c.RecordOp.RecordCBOR)); err != nil { + return fmt.Errorf("failed to parse app.bsky.feed.generator record: %v", err) } name += " " + generator.DisplayName if generator.Description != nil { diff --git a/automod/rules/keyword_test.go b/automod/rules/keyword_test.go index e20943bd..6daf26a2 100644 --- a/automod/rules/keyword_test.go +++ b/automod/rules/keyword_test.go @@ -1,6 +1,7 @@ package rules import ( + "bytes" "context" "testing" @@ -70,13 +71,16 @@ func TestBadWordPostRule(t *testing.T) { p1 := appbsky.FeedPost{ Text: "some post blah", } + p1buf := new(bytes.Buffer) + assert.NoError(p1.MarshalCBOR(p1buf)) + p1cbor := p1buf.Bytes() op := engine.RecordOp{ Action: engine.CreateOp, DID: am1.Identity.DID, Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("fagg0t"), CID: &cid1, - Value: p1, + RecordCBOR: &p1cbor, } c1 := engine.NewRecordContext(ctx, &eng, am1, op) assert.NoError(BadWordRecordKeyRule(&c1)) @@ -87,13 +91,16 @@ func TestBadWordPostRule(t *testing.T) { p2 := appbsky.FeedPost{ Text: "some post hardestr blah", } + p2buf := new(bytes.Buffer) + assert.NoError(p2.MarshalCBOR(p2buf)) + p2cbor := p2buf.Bytes() op2 := engine.RecordOp{ Action: engine.CreateOp, DID: am1.Identity.DID, Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - Value: p1, + RecordCBOR: &p2cbor, } c2 := engine.NewRecordContext(ctx, &eng, am1, op2) assert.NoError(BadWordPostRule(&c2, &p2)) diff --git a/automod/rules/misleading_test.go b/automod/rules/misleading_test.go index 988f0e03..174abb8d 100644 --- a/automod/rules/misleading_test.go +++ b/automod/rules/misleading_test.go @@ -1,6 +1,7 @@ package rules import ( + "bytes" "context" "log/slog" "testing" @@ -44,13 +45,16 @@ func TestMisleadingURLPostRule(t *testing.T) { }, }, } + p1buf := new(bytes.Buffer) + assert.NoError(p1.MarshalCBOR(p1buf)) + p1cbor := p1buf.Bytes() op := engine.RecordOp{ Action: engine.CreateOp, DID: am1.Identity.DID, Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - Value: p1, + RecordCBOR: &p1cbor, } c1 := engine.NewRecordContext(ctx, &eng, am1, op) assert.NoError(MisleadingURLPostRule(&c1, &p1)) @@ -88,13 +92,16 @@ func TestMisleadingMentionPostRule(t *testing.T) { }, }, } + p1buf := new(bytes.Buffer) + assert.NoError(p1.MarshalCBOR(p1buf)) + p1cbor := p1buf.Bytes() op := engine.RecordOp{ Action: engine.CreateOp, DID: am1.Identity.DID, Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - Value: p1, + RecordCBOR: &p1cbor, } c1 := engine.NewRecordContext(ctx, &eng, am1, op) assert.NoError(MisleadingMentionPostRule(&c1, &p1)) -- 2.51.2 From b9357bf2482d542072ad634e2d9f4d3dd72dceac Mon Sep 17 00:00:00 2001 From: bryan newbold Date: Tue, 20 Feb 2024 22:52:13 -0800 Subject: [PATCH 5/6] hepa: tweaks for RecordOp CBOR --- cmd/hepa/consumer.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cmd/hepa/consumer.go b/cmd/hepa/consumer.go index 4d995c5b..c786becb 100644 --- a/cmd/hepa/consumer.go +++ b/cmd/hepa/consumer.go @@ -161,8 +161,8 @@ func (s *Server) HandleRepoCommit(ctx context.Context, evt *comatproto.SyncSubsc ek := repomgr.EventKind(op.Action) switch ek { case repomgr.EvtKindCreateRecord, repomgr.EvtKindUpdateRecord: - // read the record from blocks, and verify CID - rc, rec, err := rr.GetRecord(ctx, op.Path) + // read the record bytes from blocks, and verify CID + rc, recCBOR, err := rr.GetRecordBytes(ctx, op.Path) if err != nil { logger.Error("reading record from event blocks (CAR)", "err", err) break @@ -188,7 +188,7 @@ func (s *Server) HandleRepoCommit(ctx context.Context, evt *comatproto.SyncSubsc Collection: collection, RecordKey: rkey, CID: &recCID, - Value: rec, + RecordCBOR: recCBOR, }) if err != nil { logger.Error("engine failed to process record", "err", err) @@ -201,7 +201,7 @@ func (s *Server) HandleRepoCommit(ctx context.Context, evt *comatproto.SyncSubsc Collection: collection, RecordKey: rkey, CID: nil, - Value: nil, + RecordCBOR: nil, }) if err != nil { logger.Error("engine failed to process record", "err", err) -- 2.51.2 From 8900331d618c5142e28a22d1af26389b97a934de Mon Sep 17 00:00:00 2001 From: bryan newbold Date: Wed, 21 Feb 2024 17:47:27 -0800 Subject: [PATCH 6/6] just []bytes, it's simpler --- automod/capture/fetch.go | 4 ++-- automod/capture/testing.go | 2 +- automod/engine/action_dedupe_test.go | 2 +- automod/engine/blobs.go | 2 +- automod/engine/circuit_breaker_test.go | 4 ++-- automod/engine/context.go | 2 +- automod/engine/engine_test.go | 4 ++-- automod/engine/ruleset.go | 4 ++-- automod/rules/hashtags_test.go | 4 ++-- automod/rules/keyword.go | 4 ++-- automod/rules/keyword_test.go | 4 ++-- automod/rules/misleading_test.go | 4 ++-- cmd/hepa/consumer.go | 2 +- 13 files changed, 21 insertions(+), 21 deletions(-) diff --git a/automod/capture/fetch.go b/automod/capture/fetch.go index 17fff408..9fef6046 100644 --- a/automod/capture/fetch.go +++ b/automod/capture/fetch.go @@ -47,7 +47,7 @@ func FetchAndProcessRecord(ctx context.Context, eng *automod.Engine, aturi synta Collection: aturi.Collection(), RecordKey: aturi.RecordKey(), CID: &recCID, - RecordCBOR: &recBytes, + RecordCBOR: recBytes, } return eng.ProcessRecordOp(ctx, op) } @@ -96,7 +96,7 @@ func FetchAndProcessRecent(ctx context.Context, eng *automod.Engine, atid syntax Collection: aturi.Collection(), RecordKey: aturi.RecordKey(), CID: &recCID, - RecordCBOR: &recBytes, + RecordCBOR: recBytes, } err = eng.ProcessRecordOp(ctx, op) if err != nil { diff --git a/automod/capture/testing.go b/automod/capture/testing.go index b8a4e32c..998aaef4 100644 --- a/automod/capture/testing.go +++ b/automod/capture/testing.go @@ -68,7 +68,7 @@ func ProcessCaptureRules(eng *automod.Engine, capture AccountCapture) error { Collection: aturi.Collection(), RecordKey: aturi.RecordKey(), CID: &recCID, - RecordCBOR: &recBytes, + RecordCBOR: recBytes, } eng.ProcessRecordOp(ctx, op) } diff --git a/automod/engine/action_dedupe_test.go b/automod/engine/action_dedupe_test.go index 313f0fe0..b07a2a43 100644 --- a/automod/engine/action_dedupe_test.go +++ b/automod/engine/action_dedupe_test.go @@ -46,7 +46,7 @@ func TestAccountReportDedupe(t *testing.T) { Collection: "app.bsky.feed.post", RecordKey: "abc123", CID: &cid1, - RecordCBOR: &p1cbor, + RecordCBOR: p1cbor, } for i := 0; i < 5; i++ { assert.NoError(eng.ProcessRecordOp(ctx, op)) diff --git a/automod/engine/blobs.go b/automod/engine/blobs.go index 7b5ae797..fe6f4940 100644 --- a/automod/engine/blobs.go +++ b/automod/engine/blobs.go @@ -22,7 +22,7 @@ func (c *RecordContext) Blobs() ([]lexutil.LexBlob, error) { return []lexutil.LexBlob{}, nil } - rec, err := data.UnmarshalCBOR(*c.RecordOp.RecordCBOR) + rec, err := data.UnmarshalCBOR(c.RecordOp.RecordCBOR) if err != nil { return nil, fmt.Errorf("parsing generic record CBOR: %v", err) } diff --git a/automod/engine/circuit_breaker_test.go b/automod/engine/circuit_breaker_test.go index 77ab488d..43c38393 100644 --- a/automod/engine/circuit_breaker_test.go +++ b/automod/engine/circuit_breaker_test.go @@ -56,7 +56,7 @@ func TestTakedownCircuitBreaker(t *testing.T) { Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - RecordCBOR: &p1cbor, + RecordCBOR: p1cbor, } assert.NoError(eng.ProcessRecordOp(ctx, op)) } @@ -101,7 +101,7 @@ func TestReportCircuitBreaker(t *testing.T) { Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - RecordCBOR: &p1cbor, + RecordCBOR: p1cbor, } assert.NoError(eng.ProcessRecordOp(ctx, op)) } diff --git a/automod/engine/context.go b/automod/engine/context.go index 8f9f1dea..56b5586a 100644 --- a/automod/engine/context.go +++ b/automod/engine/context.go @@ -52,7 +52,7 @@ type RecordOp struct { Collection syntax.NSID RecordKey syntax.RecordKey CID *syntax.CID - RecordCBOR *[]byte + RecordCBOR []byte } // Originally intended for push notifications, but can also work for any inter-account notification. diff --git a/automod/engine/engine_test.go b/automod/engine/engine_test.go index fc792812..0cbf3035 100644 --- a/automod/engine/engine_test.go +++ b/automod/engine/engine_test.go @@ -35,7 +35,7 @@ func TestEngineBasics(t *testing.T) { Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - RecordCBOR: &p1cbor, + RecordCBOR: p1cbor, } assert.NoError(eng.ProcessRecordOp(ctx, op)) @@ -46,6 +46,6 @@ func TestEngineBasics(t *testing.T) { p2buf := new(bytes.Buffer) assert.NoError(p2.MarshalCBOR(p2buf)) p2cbor := p2buf.Bytes() - op.RecordCBOR = &p2cbor + op.RecordCBOR = p2cbor assert.NoError(eng.ProcessRecordOp(ctx, op)) } diff --git a/automod/engine/ruleset.go b/automod/engine/ruleset.go index c49014e5..0c691f4c 100644 --- a/automod/engine/ruleset.go +++ b/automod/engine/ruleset.go @@ -33,7 +33,7 @@ func (r *RuleSet) CallRecordRules(c *RecordContext) error { switch c.RecordOp.Collection.String() { case "app.bsky.feed.post": var post appbsky.FeedPost - if err := post.UnmarshalCBOR(bytes.NewReader(*c.RecordOp.RecordCBOR)); err != nil { + if err := post.UnmarshalCBOR(bytes.NewReader(c.RecordOp.RecordCBOR)); err != nil { return fmt.Errorf("failed to parse app.bsky.feed.post record: %v", err) } for _, f := range r.PostRules { @@ -44,7 +44,7 @@ func (r *RuleSet) CallRecordRules(c *RecordContext) error { } case "app.bsky.actor.profile": var profile appbsky.ActorProfile - if err := profile.UnmarshalCBOR(bytes.NewReader(*c.RecordOp.RecordCBOR)); err != nil { + if err := profile.UnmarshalCBOR(bytes.NewReader(c.RecordOp.RecordCBOR)); err != nil { return fmt.Errorf("failed to parse app.bsky.actor.profile record: %v", err) } for _, f := range r.ProfileRules { diff --git a/automod/rules/hashtags_test.go b/automod/rules/hashtags_test.go index 92c9bcd8..e7c261d4 100644 --- a/automod/rules/hashtags_test.go +++ b/automod/rules/hashtags_test.go @@ -38,7 +38,7 @@ func TestBadHashtagPostRule(t *testing.T) { Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - RecordCBOR: &p1cbor, + RecordCBOR: p1cbor, } c1 := engine.NewRecordContext(ctx, &eng, am1, op) assert.NoError(BadHashtagsPostRule(&c1, &p1)) @@ -52,7 +52,7 @@ func TestBadHashtagPostRule(t *testing.T) { p2buf := new(bytes.Buffer) assert.NoError(p2.MarshalCBOR(p2buf)) p2cbor := p2buf.Bytes() - op.RecordCBOR = &p2cbor + op.RecordCBOR = p2cbor c2 := engine.NewRecordContext(ctx, &eng, am1, op) assert.NoError(BadHashtagsPostRule(&c2, &p2)) eff2 := engine.ExtractEffects(&c2.BaseContext) diff --git a/automod/rules/keyword.go b/automod/rules/keyword.go index c013a1af..b604e42b 100644 --- a/automod/rules/keyword.go +++ b/automod/rules/keyword.go @@ -84,7 +84,7 @@ func BadWordOtherRecordRule(c *automod.RecordContext) error { switch c.RecordOp.Collection.String() { case "app.bsky.graph.list": var list appbsky.GraphList - if err := list.UnmarshalCBOR(bytes.NewReader(*c.RecordOp.RecordCBOR)); err != nil { + if err := list.UnmarshalCBOR(bytes.NewReader(c.RecordOp.RecordCBOR)); err != nil { return fmt.Errorf("failed to parse app.bsky.graph.list record: %v", err) } name += " " + list.Name @@ -96,7 +96,7 @@ func BadWordOtherRecordRule(c *automod.RecordContext) error { } case "app.bsky.feed.generator": var generator appbsky.FeedGenerator - if err := generator.UnmarshalCBOR(bytes.NewReader(*c.RecordOp.RecordCBOR)); err != nil { + if err := generator.UnmarshalCBOR(bytes.NewReader(c.RecordOp.RecordCBOR)); err != nil { return fmt.Errorf("failed to parse app.bsky.feed.generator record: %v", err) } name += " " + generator.DisplayName diff --git a/automod/rules/keyword_test.go b/automod/rules/keyword_test.go index 6daf26a2..465bdbb4 100644 --- a/automod/rules/keyword_test.go +++ b/automod/rules/keyword_test.go @@ -80,7 +80,7 @@ func TestBadWordPostRule(t *testing.T) { Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("fagg0t"), CID: &cid1, - RecordCBOR: &p1cbor, + RecordCBOR: p1cbor, } c1 := engine.NewRecordContext(ctx, &eng, am1, op) assert.NoError(BadWordRecordKeyRule(&c1)) @@ -100,7 +100,7 @@ func TestBadWordPostRule(t *testing.T) { Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - RecordCBOR: &p2cbor, + RecordCBOR: p2cbor, } c2 := engine.NewRecordContext(ctx, &eng, am1, op2) assert.NoError(BadWordPostRule(&c2, &p2)) diff --git a/automod/rules/misleading_test.go b/automod/rules/misleading_test.go index 174abb8d..cf8e814a 100644 --- a/automod/rules/misleading_test.go +++ b/automod/rules/misleading_test.go @@ -54,7 +54,7 @@ func TestMisleadingURLPostRule(t *testing.T) { Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - RecordCBOR: &p1cbor, + RecordCBOR: p1cbor, } c1 := engine.NewRecordContext(ctx, &eng, am1, op) assert.NoError(MisleadingURLPostRule(&c1, &p1)) @@ -101,7 +101,7 @@ func TestMisleadingMentionPostRule(t *testing.T) { Collection: syntax.NSID("app.bsky.feed.post"), RecordKey: syntax.RecordKey("abc123"), CID: &cid1, - RecordCBOR: &p1cbor, + RecordCBOR: p1cbor, } c1 := engine.NewRecordContext(ctx, &eng, am1, op) assert.NoError(MisleadingMentionPostRule(&c1, &p1)) diff --git a/cmd/hepa/consumer.go b/cmd/hepa/consumer.go index c786becb..0fc1c951 100644 --- a/cmd/hepa/consumer.go +++ b/cmd/hepa/consumer.go @@ -188,7 +188,7 @@ func (s *Server) HandleRepoCommit(ctx context.Context, evt *comatproto.SyncSubsc Collection: collection, RecordKey: rkey, CID: &recCID, - RecordCBOR: recCBOR, + RecordCBOR: *recCBOR, }) if err != nil { logger.Error("engine failed to process record", "err", err) -- 2.51.2