From 3db9b3f4e187e4cef6907202dcfbb2041db9449a Mon Sep 17 00:00:00 2001 From: mleku Date: Thu, 4 Jan 2024 11:21:26 +0000 Subject: [PATCH] clearing out variable/package name collisions --- cmd/algia/main.go | 24 ++--- cmd/algia/profile.go | 6 +- cmd/algia/timeline.go | 102 +++++++++---------- cmd/algia/zap.go | 18 ++-- cmd/replicatrd/replicatr/handlecount.go | 8 +- cmd/replicatrd/replicatr/nip4.go | 8 +- cmd/replicatrd/replicatr/policiesfilters.go | 40 ++++---- cmd/replicatrd/replicatr/relay.go | 14 +-- cmd/replicatrd/replicatr/websockethandler.go | 8 +- pkg/eventstore/badger/count.go | 4 +- pkg/eventstore/badger/query.go | 8 +- pkg/eventstore/relay_interface.go | 8 +- pkg/go-nostr/example/example.go | 8 +- pkg/go-nostr/filter/filter.go | 4 +- pkg/go-nostr/filter/filter_test.go | 6 +- pkg/go-nostr/pools/pool.go | 32 +++--- pkg/go-nostr/req/req.go | 4 +- pkg/nostr-sdk/outbox.go | 10 +- pkg/nostr-sdk/relays.go | 20 ++-- pkg/nostr-sdk/system.go | 14 +-- pkg/nostr/auth/response.go | 4 +- pkg/nostr/relay/relay.go | 4 +- pkg/nostr/sdk/outbox.go | 12 +-- pkg/nostr/sdk/relays.go | 20 ++-- pkg/nostr/sdk/system.go | 6 +- pkg/pool/pool.go | 14 +-- pkg/relay/eventstore/badger/query.go | 6 +- pkg/relay/eventstore/relay_interface.go | 8 +- pkg/relay/handlers.go | 8 +- pkg/relay/policies/filters.go | 40 ++++---- pkg/relay/policies/nip04.go | 34 ++++--- pkg/relay/relay.go | 22 ++-- pkg/relay/serve-req.go | 21 ++-- 33 files changed, 276 insertions(+), 269 deletions(-) diff --git a/cmd/algia/main.go b/cmd/algia/main.go index 242c6afe..7427f7fa 100644 --- a/cmd/algia/main.go +++ b/cmd/algia/main.go @@ -147,8 +147,8 @@ func (cfg *Config) GetFollows(profile string) (map[string]Profile, error) { mu.Unlock() m := map[string]struct{}{} - cfg.Do(RelayPerms{Read: true}, func(ctx context.Context, relay *relays.Relay) bool { - evs, err := relay.QuerySync(ctx, filter.Filter{Kinds: []int{event.KindContactList}, Authors: []string{pub}, Limit: 1}) + cfg.Do(RelayPerms{Read: true}, func(ctx context.Context, rl *relays.Relay) bool { + evs, err := rl.QuerySync(ctx, filter.Filter{Kinds: []int{event.KindContactList}, Authors: []string{pub}, Limit: 1}) if err != nil { return true } @@ -191,8 +191,8 @@ func (cfg *Config) GetFollows(profile string) (map[string]Profile, error) { } // get follower's descriptions - cfg.Do(RelayPerms{Read: true}, func(ctx context.Context, relay *relays.Relay) bool { - evs, err := relay.QuerySync(ctx, filter.Filter{ + cfg.Do(RelayPerms{Read: true}, func(ctx context.Context, rl *relays.Relay) bool { + evs, err := rl.QuerySync(ctx, filter.Filter{ Kinds: []int{event.KindProfileMetadata}, Authors: follows[i:end], // Use the updated end index }) @@ -236,14 +236,14 @@ func (cfg *Config) FindRelay(ctx context.Context, r RelayPerms) *relays.Relay { if cfg.verbose { fmt.Printf("trying relay: %s\n", k) } - relay, err := relays.RelayConnect(ctx, k) + rl, err := relays.RelayConnect(ctx, k) if err != nil { if cfg.verbose { fmt.Fprintln(os.Stderr, err.Error()) } continue } - return relay + return rl } return nil } @@ -383,18 +383,18 @@ func (cfg *Config) PrintEvents(evs []*event.T, followsMap map[string]Profile, j, } // Events is -func (cfg *Config) Events(filter filter.Filter) []*event.T { +func (cfg *Config) Events(f filter.Filter) []*event.T { var mu sync.Mutex found := false var m sync.Map - cfg.Do(RelayPerms{Read: true}, func(ctx context.Context, relay *relays.Relay) bool { + cfg.Do(RelayPerms{Read: true}, func(ctx context.Context, rl *relays.Relay) bool { mu.Lock() if found { mu.Unlock() return false } mu.Unlock() - evs, err := relay.QuerySync(ctx, filter) + evs, err := rl.QuerySync(ctx, f) if err != nil { return true } @@ -406,7 +406,7 @@ func (cfg *Config) Events(filter filter.Filter) []*event.T { } } m.LoadOrStore(ev.ID, ev) - if len(filter.IDs) == 1 { + if len(f.IDs) == 1 { mu.Lock() found = true ctx.Done() @@ -677,8 +677,8 @@ func main() { relays := cCtx.String("relays") if strings.TrimSpace(relays) != "" { cfg.Relays = make(map[string]RelayPerms) - for _, relay := range strings.Split(relays, ",") { - cfg.Relays[relay] = RelayPerms{ + for _, rl := range strings.Split(relays, ",") { + cfg.Relays[rl] = RelayPerms{ Read: true, Write: true, } diff --git a/cmd/algia/profile.go b/cmd/algia/profile.go index 25735513..94b31cda 100644 --- a/cmd/algia/profile.go +++ b/cmd/algia/profile.go @@ -21,11 +21,11 @@ func doProfile(cCtx *cli.Context) (e error) { j := cCtx.Bool("json") cfg := cCtx.App.Metadata["config"].(*Config) - relay := cfg.FindRelay(context.Background(), RelayPerms{Read: true}) - if relay == nil { + rl := cfg.FindRelay(context.Background(), RelayPerms{Read: true}) + if rl == nil { return errors.New("cannot connect relays") } - defer relay.Close() + defer rl.Close() var pub string if user == "" { diff --git a/cmd/algia/timeline.go b/cmd/algia/timeline.go index e109858c..e7ece481 100644 --- a/cmd/algia/timeline.go +++ b/cmd/algia/timeline.go @@ -50,12 +50,12 @@ func doDMList(cCtx *cli.Context) (e error) { } // get timeline - filter := filter.Filter{ + f := filter.Filter{ Kinds: []int{event.KindEncryptedDirectMessage}, Authors: []string{npub}, } - evs := cfg.Events(filter) + evs := cfg.Events(f) type entry struct { name string pubkey string @@ -135,14 +135,14 @@ func doDMTimeline(cCtx *cli.Context) (e error) { } // get timeline - filter := filter.Filter{ + f := filter.Filter{ Kinds: []int{event.KindEncryptedDirectMessage}, Authors: []string{npub, pub}, Tags: filter.TagMap{"p": []string{npub, pub}}, Limit: 9999, } - evs := cfg.Events(filter) + evs := cfg.Events(f) cfg.PrintEvents(evs, followsMap, j, extra) return nil } @@ -217,10 +217,10 @@ func doDMPost(cCtx *cli.Context) (e error) { } var success atomic.Int64 - cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, relay *relays.Relay) bool { - err := relay.Publish(ctx, ev) + cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, rl *relays.Relay) bool { + err := rl.Publish(ctx, ev) if err != nil { - fmt.Fprintln(os.Stderr, relay.URL, err) + fmt.Fprintln(os.Stderr, rl.URL, err) } else { success.Add(1) } @@ -324,10 +324,10 @@ func doPost(cCtx *cli.Context) (e error) { } var success atomic.Int64 - cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, relay *relays.Relay) bool { - err := relay.Publish(ctx, ev) + cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, rl *relays.Relay) bool { + err := rl.Publish(ctx, ev) if err != nil { - fmt.Fprintln(os.Stderr, relay.URL, err) + fmt.Fprintln(os.Stderr, rl.URL, err) } else { success.Add(1) } @@ -425,18 +425,18 @@ func doReply(cCtx *cli.Context) (e error) { } var success atomic.Int64 - cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, relay *relays.Relay) bool { + cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, rl *relays.Relay) bool { if !quote { - ev.Tags = ev.Tags.AppendUnique(tags.Tag{"e", id, relay.URL, "reply"}) + ev.Tags = ev.Tags.AppendUnique(tags.Tag{"e", id, rl.URL, "reply"}) } else { - ev.Tags = ev.Tags.AppendUnique(tags.Tag{"e", id, relay.URL, "mention"}) + ev.Tags = ev.Tags.AppendUnique(tags.Tag{"e", id, rl.URL, "mention"}) } if err := ev.Sign(sk); err != nil { return true } - err := relay.Publish(ctx, ev) + err := rl.Publish(ctx, ev) if err != nil { - fmt.Fprintln(os.Stderr, relay.URL, err) + fmt.Fprintln(os.Stderr, rl.URL, err) } else { success.Add(1) } @@ -475,7 +475,7 @@ func doRepost(cCtx *cli.Context) (e error) { return fmt.Errorf("failed to parse event from '%s'", id) } ev.Tags = ev.Tags.AppendUnique(tags.Tag{"e", id}) - filter := filter.Filter{ + f := filter.Filter{ Kinds: []int{event.KindTextNote}, IDs: []string{id}, } @@ -488,9 +488,9 @@ func doRepost(cCtx *cli.Context) (e error) { first.Store(true) var success atomic.Int64 - cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, relay *relays.Relay) bool { + cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, rl *relays.Relay) bool { if first.Load() { - evs, err := relay.QuerySync(ctx, filter) + evs, err := rl.QuerySync(ctx, f) if err != nil { return true } @@ -502,9 +502,9 @@ func doRepost(cCtx *cli.Context) (e error) { return true } } - err := relay.Publish(ctx, ev) + err := rl.Publish(ctx, ev) if err != nil { - fmt.Fprintln(os.Stderr, relay.URL, err) + fmt.Fprintln(os.Stderr, rl.URL, err) } else { success.Add(1) } @@ -543,8 +543,8 @@ func doUnrepost(cCtx *cli.Context) (e error) { } var repostID string var mu sync.Mutex - cfg.Do(RelayPerms{Read: true}, func(ctx context.Context, relay *relays.Relay) bool { - evs, err := relay.QuerySync(ctx, f) + cfg.Do(RelayPerms{Read: true}, func(ctx context.Context, rl *relays.Relay) bool { + evs, err := rl.QuerySync(ctx, f) if err != nil { return true } @@ -565,10 +565,10 @@ func doUnrepost(cCtx *cli.Context) (e error) { } var success atomic.Int64 - cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, relay *relays.Relay) bool { - err := relay.Publish(ctx, ev) + cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, rl *relays.Relay) bool { + err := rl.Publish(ctx, ev) if err != nil { - fmt.Fprintln(os.Stderr, relay.URL, err) + fmt.Fprintln(os.Stderr, rl.URL, err) } else { success.Add(1) } @@ -607,7 +607,7 @@ func doLike(cCtx *cli.Context) (e error) { return fmt.Errorf("failed to parse event from '%s'", id) } ev.Tags = ev.Tags.AppendUnique(tags.Tag{"e", id}) - filter := filter.Filter{ + f := filter.Filter{ Kinds: []int{event.KindTextNote}, IDs: []string{id}, } @@ -631,9 +631,9 @@ func doLike(cCtx *cli.Context) (e error) { first.Store(true) var success atomic.Int64 - cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, relay *relays.Relay) bool { + cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, rl *relays.Relay) bool { if first.Load() { - evs, err := relay.QuerySync(ctx, filter) + evs, err := rl.QuerySync(ctx, f) if err != nil { return true } @@ -646,9 +646,9 @@ func doLike(cCtx *cli.Context) (e error) { } return true } - err := relay.Publish(ctx, ev) + err := rl.Publish(ctx, ev) if err != nil { - fmt.Fprintln(os.Stderr, relay.URL, err) + fmt.Fprintln(os.Stderr, rl.URL, err) } else { success.Add(1) } @@ -687,8 +687,8 @@ func doUnlike(cCtx *cli.Context) (e error) { } var likeID string var mu sync.Mutex - cfg.Do(RelayPerms{Read: true}, func(ctx context.Context, relay *relays.Relay) bool { - evs, err := relay.QuerySync(ctx, f) + cfg.Do(RelayPerms{Read: true}, func(ctx context.Context, rl *relays.Relay) bool { + evs, err := rl.QuerySync(ctx, f) if err != nil { return true } @@ -709,10 +709,10 @@ func doUnlike(cCtx *cli.Context) (e error) { } var success atomic.Int64 - cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, relay *relays.Relay) bool { - err := relay.Publish(ctx, ev) + cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, rl *relays.Relay) bool { + err := rl.Publish(ctx, ev) if err != nil { - fmt.Fprintln(os.Stderr, relay.URL, err) + fmt.Fprintln(os.Stderr, rl.URL, err) } else { success.Add(1) } @@ -758,10 +758,10 @@ func doDelete(cCtx *cli.Context) (e error) { } var success atomic.Int64 - cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, relay *relays.Relay) bool { - err := relay.Publish(ctx, ev) + cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, rl *relays.Relay) bool { + err := rl.Publish(ctx, ev) if err != nil { - fmt.Fprintln(os.Stderr, relay.URL, err) + fmt.Fprintln(os.Stderr, rl.URL, err) } else { success.Add(1) } @@ -793,13 +793,13 @@ func doSearch(cCtx *cli.Context) (e error) { } // get timeline - filter := filter.Filter{ + f := filter.Filter{ Kinds: []int{event.KindTextNote}, Search: strings.Join(cCtx.Args().Slice(), " "), Limit: n, } - evs := cfg.Events(filter) + evs := cfg.Events(f) cfg.PrintEvents(evs, followsMap, j, extra) return nil } @@ -822,11 +822,11 @@ func doStream(cCtx *cli.Context) (e error) { cfg := cCtx.App.Metadata["config"].(*Config) - relay := cfg.FindRelay(context.Background(), RelayPerms{Read: true}) - if relay == nil { + rl := cfg.FindRelay(context.Background(), RelayPerms{Read: true}) + if rl == nil { return errors.New("cannot connect relays") } - defer relay.Close() + defer rl.Close() var sk string if _, s, err := nip19.Decode(cfg.PrivateKey); err == nil { @@ -860,7 +860,7 @@ func doStream(cCtx *cli.Context) (e error) { Since: &since, } - sub, err := relay.Subscribe(context.Background(), filter.Filters{ff}) + sub, err := rl.Subscribe(context.Background(), filter.Filters{ff}) if err != nil { return err } @@ -880,8 +880,8 @@ func doStream(cCtx *cli.Context) (e error) { if err := evr.Sign(sk); err != nil { return err } - cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, relay *relays.Relay) bool { - relay.Publish(ctx, evr) + cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, rl *relays.Relay) bool { + rl.Publish(ctx, evr) return true }) } @@ -910,13 +910,13 @@ func doTimeline(cCtx *cli.Context) (e error) { } // get timeline - filter := filter.Filter{ + f := filter.Filter{ Kinds: []int{event.KindTextNote}, Authors: follows, Limit: n, } - evs := cfg.Events(filter) + evs := cfg.Events(f) cfg.PrintEvents(evs, followsMap, j, extra) return nil } @@ -949,10 +949,10 @@ func postMsg(cCtx *cli.Context, msg string) (e error) { } var success atomic.Int64 - cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, relay *relays.Relay) bool { - err := relay.Publish(ctx, ev) + cfg.Do(RelayPerms{Write: true}, func(ctx context.Context, rl *relays.Relay) bool { + err := rl.Publish(ctx, ev) if err != nil { - fmt.Fprintln(os.Stderr, relay.URL, err) + fmt.Fprintln(os.Stderr, rl.URL, err) } else { success.Add(1) } diff --git a/cmd/algia/zap.go b/cmd/algia/zap.go index 4ed1733b..0d11275a 100644 --- a/cmd/algia/zap.go +++ b/cmd/algia/zap.go @@ -75,11 +75,11 @@ func pay(cfg *Config, invoice string) (e error) { return err } - relay, err := relays.RelayConnect(context.Background(), host) + rl, err := relays.RelayConnect(context.Background(), host) if err != nil { return err } - defer relay.Close() + defer rl.Close() ss, err := nip04.ComputeSharedSecret(wallet, secret) if err != nil { @@ -117,12 +117,12 @@ func pay(cfg *Config, invoice string) (e error) { Kinds: []int{event.KindNWCWalletInfo, event.KindNWCWalletResponse, event.KindNWCWalletRequest}, Limit: 1, }} - sub, err := relay.Subscribe(context.Background(), filters) + sub, err := rl.Subscribe(context.Background(), filters) if err != nil { return err } - err = relay.Publish(context.Background(), ev) + err = rl.Publish(context.Background(), ev) if err != nil { return err } @@ -146,20 +146,20 @@ func pay(cfg *Config, invoice string) (e error) { // ZapInfo is func (cfg *Config) ZapInfo(pub string) (*Lnurlp, error) { - relay := cfg.FindRelay(context.Background(), RelayPerms{Read: true}) - if relay == nil { + rl := cfg.FindRelay(context.Background(), RelayPerms{Read: true}) + if rl == nil { return nil, errors.New("cannot connect relays") } - defer relay.Close() + defer rl.Close() // get set-metadata - filter := filter.Filter{ + f := filter.Filter{ Kinds: []int{event.KindProfileMetadata}, Authors: []string{pub}, Limit: 1, } - evs := cfg.Events(filter) + evs := cfg.Events(f) if len(evs) == 0 { return nil, errors.New("cannot find user") } diff --git a/cmd/replicatrd/replicatr/handlecount.go b/cmd/replicatrd/replicatr/handlecount.go index 16dcfaaf..43c1013b 100644 --- a/cmd/replicatrd/replicatr/handlecount.go +++ b/cmd/replicatrd/replicatr/handlecount.go @@ -1,16 +1,16 @@ package replicatr func (rl *Relay) handleCountRequest(ctx Ctx, ws *WebSocket, - filter *Filter) (subtotal int64) { + f *Filter) (subtotal int64) { // overwrite the filter (for example, to eliminate some kinds or tags that // we know we don't support) for _, ovw := range rl.OverwriteCountFilter { - ovw(ctx, filter) + ovw(ctx, f) } // then check if we'll reject this filter for _, reject := range rl.RejectCountFilter { - if rej, msg := reject(ctx, filter); rej { + if rej, msg := reject(ctx, f); rej { rl.E.Chk(ws.WriteJSON(&NoticeEnvelope{Text: msg})) return 0 } @@ -19,7 +19,7 @@ func (rl *Relay) handleCountRequest(ctx Ctx, ws *WebSocket, var e error var res int64 for _, count := range rl.CountEvents { - if res, e = count(ctx, filter); rl.E.Chk(e) { + if res, e = count(ctx, f); rl.E.Chk(e) { rl.E.Chk(ws.WriteJSON(&NoticeEnvelope{Text: e.Error()})) } subtotal += res diff --git a/cmd/replicatrd/replicatr/nip4.go b/cmd/replicatrd/replicatr/nip4.go index 6c5d5891..1349d826 100644 --- a/cmd/replicatrd/replicatr/nip4.go +++ b/cmd/replicatrd/replicatr/nip4.go @@ -6,15 +6,15 @@ import ( // RejectKind4Snoopers prevents reading NIP-04 messages from people not // involved in the conversation. -func RejectKind4Snoopers(ctx Ctx, filter *Filter) (bool, string) { +func RejectKind4Snoopers(ctx Ctx, f *Filter) (bool, string) { // prevent kind-4 events from being returned to unauthed users, only when // authentication is a thing - if !slices.Contains(filter.Kinds, 4) { + if !slices.Contains(f.Kinds, 4) { return false, "" } ws := GetConnection(ctx) - s := filter.Authors - r, _ := filter.Tags["p"] + s := f.Authors + r, _ := f.Tags["p"] switch { case ws.AuthedPublicKey == "": // not authenticated diff --git a/cmd/replicatrd/replicatr/policiesfilters.go b/cmd/replicatrd/replicatr/policiesfilters.go index a632d811..879a3917 100644 --- a/cmd/replicatrd/replicatr/policiesfilters.go +++ b/cmd/replicatrd/replicatr/policiesfilters.go @@ -7,9 +7,9 @@ import ( ) // NoComplexFilters disallows filters with more than 2 tags. -func NoComplexFilters(ctx Ctx, filter *Filter) (reject bool, msg string) { - items := len(filter.Tags) + len(filter.Kinds) - if items > 4 && len(filter.Tags) > 2 { +func NoComplexFilters(ctx Ctx, f *Filter) (reject bool, msg string) { + items := len(f.Tags) + len(f.Kinds) + if items > 4 && len(f.Tags) > 2 { return true, "too many things to filter for" } return false, "" @@ -17,9 +17,9 @@ func NoComplexFilters(ctx Ctx, filter *Filter) (reject bool, msg string) { // NoEmptyFilters disallows filters that don't have at least a tag, a kind, an // author or an id. -func NoEmptyFilters(ctx Ctx, filter *Filter) (reject bool, msg string) { - c := len(filter.Kinds) + len(filter.IDs) + len(filter.Authors) - for _, tagItems := range filter.Tags { +func NoEmptyFilters(ctx Ctx, f *Filter) (reject bool, msg string) { + c := len(f.Kinds) + len(f.IDs) + len(f.Authors) + for _, tagItems := range f.Tags { c += len(tagItems) } if c == 0 { @@ -30,41 +30,41 @@ func NoEmptyFilters(ctx Ctx, filter *Filter) (reject bool, msg string) { // AntiSyncBots tries to prevent people from syncing kind:1s from this relay to // else by always requiring an author parameter at least. -func AntiSyncBots(ctx Ctx, filter *Filter) (reject bool, msg string) { - return (len(filter.Kinds) == 0 || slices.Contains(filter.Kinds, 1)) && - len(filter.Authors) == 0, "an author must be specified to get their kind:1 notes" +func AntiSyncBots(ctx Ctx, f *Filter) (reject bool, msg string) { + return (len(f.Kinds) == 0 || slices.Contains(f.Kinds, 1)) && + len(f.Authors) == 0, "an author must be specified to get their kind:1 notes" } -func NoSearchQueries(ctx context.Context, filter *Filter) (reject bool, msg string) { - if filter.Search != "" { +func NoSearchQueries(ctx context.Context, f *Filter) (reject bool, msg string) { + if f.Search != "" { return true, "search is not supported" } return false, "" } -func RemoveSearchQueries(ctx Ctx, filter *Filter) { - filter.Search = "" +func RemoveSearchQueries(ctx Ctx, f *Filter) { + f.Search = "" } func RemoveAllButKinds(kinds ...uint16) func(Ctx, *Filter) { - return func(ctx Ctx, filter *Filter) { - if n := len(filter.Kinds); n > 0 { + return func(ctx Ctx, f *Filter) { + if n := len(f.Kinds); n > 0 { newKinds := make([]int, 0, n) for i := 0; i < n; i++ { - if k := filter.Kinds[i]; slices.Contains(kinds, uint16(k)) { + if k := f.Kinds[i]; slices.Contains(kinds, uint16(k)) { newKinds = append(newKinds, k) } } - filter.Kinds = newKinds + f.Kinds = newKinds } } } func RemoveAllButTags(tagNames ...string) func(Ctx, *Filter) { - return func(ctx Ctx, filter *Filter) { - for tagName := range filter.Tags { + return func(ctx Ctx, f *Filter) { + for tagName := range f.Tags { if !slices.Contains(tagNames, tagName) { - delete(filter.Tags, tagName) + delete(f.Tags, tagName) } } } diff --git a/cmd/replicatrd/replicatr/relay.go b/cmd/replicatrd/replicatr/relay.go index 4e149b8c..51dd28ee 100644 --- a/cmd/replicatrd/replicatr/relay.go +++ b/cmd/replicatrd/replicatr/relay.go @@ -23,16 +23,16 @@ const ( // function types used in the relay state type ( RejectEvent func(ctx Ctx, event *Event) (reject bool, msg string) - RejectFilter func(ctx Ctx, filter *Filter) (reject bool, msg string) - OverwriteFilter func(ctx Ctx, filter *Filter) + RejectFilter func(ctx Ctx, f *Filter) (reject bool, msg string) + OverwriteFilter func(ctx Ctx, f *Filter) OverwriteDeletionOutcome func(ctx Ctx, target *Event, del *Event) (accept bool, msg string) - OverwriteResponseEvent func(ctx Ctx, event *Event) - Events func(ctx Ctx, event *Event) error + OverwriteResponseEvent func(ctx Ctx, ev *Event) + Events func(ctx Ctx, ev *Event) error Hook func(ctx Ctx) OverwriteRelayInformation func(ctx Ctx, r *Request, info *Info) *Info - QueryEvents func(ctx Ctx, filter *Filter) (eventC chan *Event, e error) - CountEvents func(ctx Ctx, filter *Filter) (c int64, e error) - OnEventSaved func(ctx Ctx, event *Event) + QueryEvents func(ctx Ctx, f *Filter) (eventC chan *Event, e error) + CountEvents func(ctx Ctx, f *Filter) (c int64, e error) + OnEventSaved func(ctx Ctx, ev *Event) ) type Relay struct { diff --git a/cmd/replicatrd/replicatr/websockethandler.go b/cmd/replicatrd/replicatr/websockethandler.go index 173d649a..2c266d44 100644 --- a/cmd/replicatrd/replicatr/websockethandler.go +++ b/cmd/replicatrd/replicatr/websockethandler.go @@ -124,8 +124,8 @@ func (rl *Relay) websocketProcessMessages(message []byte, ctx Ctx, ws *WebSocket return } var total int64 - for _, filter := range env.Filters { - total += rl.handleCountRequest(ctx, ws, &filter) + for _, f := range env.Filters { + total += rl.handleCountRequest(ctx, ws, &f) } rl.E.Chk(ws.WriteJSON(CountEnvelope{ SubscriptionID: env.SubscriptionID, @@ -139,8 +139,8 @@ func (rl *Relay) websocketProcessMessages(message []byte, ctx Ctx, ws *WebSocket // expose subscription id in the context reqCtx = context.WithValue(reqCtx, subscriptionIdKey, env.SubscriptionID) // handle each filter separately -- dispatching events as they're loaded from databases - for _, filter := range env.Filters { - e = rl.handleFilter(reqCtx, env.SubscriptionID, &eose, ws, &filter) + for _, f := range env.Filters { + e = rl.handleFilter(reqCtx, env.SubscriptionID, &eose, ws, &f) if rl.E.Chk(e) { // fail everything if any filter is rejected reason := e.Error() diff --git a/pkg/eventstore/badger/count.go b/pkg/eventstore/badger/count.go index af456f59..707fc785 100644 --- a/pkg/eventstore/badger/count.go +++ b/pkg/eventstore/badger/count.go @@ -11,10 +11,10 @@ import ( "github.com/dgraph-io/badger/v4" ) -func (b BadgerBackend) CountEvents(ctx context.Context, filter *filter.Filter) (int64, error) { +func (b BadgerBackend) CountEvents(ctx context.Context, f *filter.Filter) (int64, error) { var count int64 = 0 - queries, extraFilter, since, err := prepareQueries(filter) + queries, extraFilter, since, err := prepareQueries(f) if err != nil { return 0, err } diff --git a/pkg/eventstore/badger/query.go b/pkg/eventstore/badger/query.go index ce983c31..b17fad7a 100644 --- a/pkg/eventstore/badger/query.go +++ b/pkg/eventstore/badger/query.go @@ -27,10 +27,10 @@ type queryEvent struct { query int } -func (b BadgerBackend) QueryEvents(ctx context.Context, filter *filter.Filter) (chan *event.T, error) { +func (b BadgerBackend) QueryEvents(ctx context.Context, f *filter.Filter) (chan *event.T, error) { ch := make(chan *event.T) - queries, extraFilter, since, err := prepareQueries(filter) + queries, extraFilter, since, err := prepareQueries(f) if err != nil { return nil, err } @@ -99,8 +99,8 @@ func (b BadgerBackend) QueryEvents(ctx context.Context, filter *filter.Filter) ( // max number of events we'll return limit := b.MaxLimit - if filter.Limit > 0 && filter.Limit < limit { - limit = filter.Limit + if f.Limit > 0 && f.Limit < limit { + limit = f.Limit } // receive results and ensure we only return the most recent ones always diff --git a/pkg/eventstore/relay_interface.go b/pkg/eventstore/relay_interface.go index 1b64fbf4..4b1e7a23 100644 --- a/pkg/eventstore/relay_interface.go +++ b/pkg/eventstore/relay_interface.go @@ -12,7 +12,7 @@ import ( // RelayInterface is a wrapper thing that unifies Store and nostr.Relay under a common API. type RelayInterface interface { Publish(ctx context.Context, evt *event.T) error - QuerySync(ctx context.Context, filter *filter.Filter, opts ...relay.SubscriptionOption) ([]*event.T, error) + QuerySync(ctx context.Context, f *filter.Filter, opts ...relay.SubscriptionOption) ([]*event.T, error) } type RelayWrapper struct { @@ -59,13 +59,13 @@ func (w RelayWrapper) Publish(ctx context.Context, evt *event.T) (e error) { return nil } -func (w RelayWrapper) QuerySync(ctx context.Context, filter *filter.Filter, opts ...relay.SubscriptionOption) ([]*event.T, error) { - ch, err := w.Store.QueryEvents(ctx, filter) +func (w RelayWrapper) QuerySync(ctx context.Context, f *filter.Filter, opts ...relay.SubscriptionOption) ([]*event.T, error) { + ch, err := w.Store.QueryEvents(ctx, f) if err != nil { return nil, fmt.Errorf("failed to query: %w", err) } - n := filter.Limit + n := f.Limit if n == 0 { n = 500 } diff --git a/pkg/go-nostr/example/example.go b/pkg/go-nostr/example/example.go index 9e09f050..feaad3c8 100644 --- a/pkg/go-nostr/example/example.go +++ b/pkg/go-nostr/example/example.go @@ -22,7 +22,7 @@ func main() { // connect to relay url := "wss://nostr.zebedee.cloud" - relay, err := relays.RelayConnect(ctx, url) + rl, err := relays.RelayConnect(ctx, url) if err != nil { panic(err) } @@ -56,7 +56,7 @@ func main() { // create a subscription and submit to relay // results will be returned on the sub.Events channel - sub, _ := relay.Subscribe(ctx, filters) + sub, _ := rl.Subscribe(ctx, filters) // we will append the returned events to this slice evs := make([]event.T, 0) @@ -122,12 +122,12 @@ func main() { ev.Sign(sk) for _, url := range []string{"wss://nostr.zebedee.cloud"} { ctx := context.WithValue(context.Background(), "url", url) - relay, e := relays.RelayConnect(ctx, url) + rl, e := relays.RelayConnect(ctx, url) if e != nil { fmt.Println(e) continue } fmt.Println("posting to: ", url) - relay.Publish(ctx, ev) + rl.Publish(ctx, ev) } } diff --git a/pkg/go-nostr/filter/filter.go b/pkg/go-nostr/filter/filter.go index 89113eba..0dc562e2 100644 --- a/pkg/go-nostr/filter/filter.go +++ b/pkg/go-nostr/filter/filter.go @@ -31,8 +31,8 @@ func (eff Filters) String() string { } func (eff Filters) Match(evt *event.T) bool { - for _, filter := range eff { - if filter.Matches(evt) { + for _, f := range eff { + if f.Matches(evt) { return true } } diff --git a/pkg/go-nostr/filter/filter_test.go b/pkg/go-nostr/filter/filter_test.go index f0a38051..50a20e64 100644 --- a/pkg/go-nostr/filter/filter_test.go +++ b/pkg/go-nostr/filter/filter_test.go @@ -42,13 +42,13 @@ func TestFilterMarshal(t *testing.T) { } func TestFilterMatchingLive(t *testing.T) { - var filter Filter + var f Filter var evt event.T - json.Unmarshal([]byte(`{"kinds":[1],"authors":["a8171781fd9e90ede3ea44ddca5d3abf828fe8eedeb0f3abb0dd3e563562e1fc","1d80e5588de010d137a67c42b03717595f5f510e73e42cfc48f31bae91844d59","ed4ca520e9929dfe9efdadf4011b53d30afd0678a09aa026927e60e7a45d9244"],"since":1677033299}`), &filter) + json.Unmarshal([]byte(`{"kinds":[1],"authors":["a8171781fd9e90ede3ea44ddca5d3abf828fe8eedeb0f3abb0dd3e563562e1fc","1d80e5588de010d137a67c42b03717595f5f510e73e42cfc48f31bae91844d59","ed4ca520e9929dfe9efdadf4011b53d30afd0678a09aa026927e60e7a45d9244"],"since":1677033299}`), &f) json.Unmarshal([]byte(`{"id":"5a127c9c931f392f6afc7fdb74e8be01c34035314735a6b97d2cf360d13cfb94","pubkey":"1d80e5588de010d137a67c42b03717595f5f510e73e42cfc48f31bae91844d59","created_at":1677033299,"kind":1,"tags":[["t","japan"]],"content":"If you like my art,I'd appreciate a coin or two!!\nZap is welcome!! Thanks.\n\n\n#japan #bitcoin #art #bananaart\nhttps://void.cat/d/CgM1bzDgHUCtiNNwfX9ajY.webp","sig":"828497508487ca1e374f6b4f2bba7487bc09fccd5cc0d1baa82846a944f8c5766918abf5878a580f1e6615de91f5b57a32e34c42ee2747c983aaf47dbf2a0255"}`), &evt) - if !filter.Matches(&evt) { + if !f.Matches(&evt) { t.Error("live filter should match") } } diff --git a/pkg/go-nostr/pools/pool.go b/pkg/go-nostr/pools/pool.go index 3e8c856b..a588d258 100644 --- a/pkg/go-nostr/pools/pool.go +++ b/pkg/go-nostr/pools/pool.go @@ -72,21 +72,21 @@ func (pool *SimplePool) EnsureRelay(url string) (*relays.Relay, error) { defer NamedLock(url)() - relay, ok := pool.Relays.Load(nm) - if ok && relay.IsConnected() { + rl, ok := pool.Relays.Load(nm) + if ok && rl.IsConnected() { // already connected, unlock and return - return relay, nil + return rl, nil } else { var err error // we use this ctx here so when the pool dies everything dies ctx, cancel := context.WithTimeout(pool.Context, time.Second*15) defer cancel() - if relay, err = relays.RelayConnect(ctx, nm); err != nil { + if rl, err = relays.RelayConnect(ctx, nm); err != nil { return nil, fmt.Errorf("failed to connect: %w", err) } - pool.Relays.Store(nm, relay) - return relay, nil + pool.Relays.Store(nm, rl) + return rl, nil } } @@ -133,14 +133,14 @@ func (pool *SimplePool) subMany(ctx context.Context, urls []string, filters filt var sub *relays.Subscription - relay, err := pool.EnsureRelay(nm) + rl, err := pool.EnsureRelay(nm) if err != nil { goto reconnect } hasAuthed = false subscribe: - sub, err = relay.Subscribe(ctx, filters) + sub, err = rl.Subscribe(ctx, filters) if err != nil { goto reconnect } @@ -172,7 +172,7 @@ func (pool *SimplePool) subMany(ctx context.Context, urls []string, filters filt } } select { - case events <- IncomingEvent{T: evt, Relay: relay}: + case events <- IncomingEvent{T: evt, Relay: rl}: case <-ctx.Done(): } case <-ticker.C: @@ -187,8 +187,8 @@ func (pool *SimplePool) subMany(ctx context.Context, urls []string, filters filt } case reason := <-sub.ClosedReason: if strings.HasPrefix(reason, "auth-required:") && pool.authHandler != nil && !hasAuthed { - // relay is requesting auth. if we can we will perform auth and try again - if err := relay.Auth(ctx, pool.authHandler); err == nil { + // rl is requesting auth. if we can we will perform auth and try again + if err := rl.Auth(ctx, pool.authHandler); err == nil { hasAuthed = true // so we don't keep doing AUTH again and again goto subscribe } @@ -242,7 +242,7 @@ func (pool *SimplePool) subManyEose(ctx context.Context, urls []string, filters go func(nm string) { defer wg.Done() - relay, err := pool.EnsureRelay(nm) + rl, err := pool.EnsureRelay(nm) if err != nil { return } @@ -250,9 +250,9 @@ func (pool *SimplePool) subManyEose(ctx context.Context, urls []string, filters hasAuthed := false subscribe: - sub, err := relay.Subscribe(ctx, filters) + sub, err := rl.Subscribe(ctx, filters) if sub == nil { - fmt.Printf("error subscribing to %s with %v: %s", relay, filters, err) + fmt.Printf("error subscribing to %s with %v: %s", rl, filters, err) return } @@ -265,7 +265,7 @@ func (pool *SimplePool) subManyEose(ctx context.Context, urls []string, filters case reason := <-sub.ClosedReason: if strings.HasPrefix(reason, "auth-required:") && pool.authHandler != nil && !hasAuthed { // relay is requesting auth. if we can we will perform auth and try again - err := relay.Auth(ctx, pool.authHandler) + err := rl.Auth(ctx, pool.authHandler) if err == nil { hasAuthed = true // so we don't keep doing AUTH again and again goto subscribe @@ -285,7 +285,7 @@ func (pool *SimplePool) subManyEose(ctx context.Context, urls []string, filters } select { - case events <- IncomingEvent{T: evt, Relay: relay}: + case events <- IncomingEvent{T: evt, Relay: rl}: case <-ctx.Done(): return } diff --git a/pkg/go-nostr/req/req.go b/pkg/go-nostr/req/req.go index 536d064f..aeb2e09a 100644 --- a/pkg/go-nostr/req/req.go +++ b/pkg/go-nostr/req/req.go @@ -42,9 +42,9 @@ func (v ReqEnvelope) MarshalJSON() ([]byte, error) { w := jwriter.Writer{} w.RawString(`["REQ",`) w.RawString(`"` + v.SubscriptionID + `"`) - for _, filter := range v.Filters { + for _, f := range v.Filters { w.RawString(`,`) - filter.MarshalEasyJSON(&w) + f.MarshalEasyJSON(&w) } w.RawString(`]`) return w.BuildBytes() diff --git a/pkg/nostr-sdk/outbox.go b/pkg/nostr-sdk/outbox.go index f81593c1..945c3860 100644 --- a/pkg/nostr-sdk/outbox.go +++ b/pkg/nostr-sdk/outbox.go @@ -28,11 +28,11 @@ func (sys *System) ExpandQueriesByAuthorAndRelays( relayURLs := sys.FetchOutboxRelays(ctx, pubkey) c := 0 for _, r := range relayURLs { - relay, err := sys.Pool.EnsureRelay(r) + rl, err := sys.Pool.EnsureRelay(r) if err != nil { continue } - relaysForPubkey[pubkey] = append(relaysForPubkey[pubkey], relay) + relaysForPubkey[pubkey] = append(relaysForPubkey[pubkey], rl) c++ if c == 3 { return @@ -44,11 +44,11 @@ func (sys *System) ExpandQueriesByAuthorAndRelays( filterForRelay := make(map[*relays.Relay]filter.Filter, n) // { [relay]: f } for pubkey, relays := range relaysForPubkey { - for _, relay := range relays { - flt, ok := filterForRelay[relay] + for _, rl := range relays { + flt, ok := filterForRelay[rl] if !ok { flt = f.Clone() - filterForRelay[relay] = flt + filterForRelay[rl] = flt } flt.Authors = append(flt.Authors, pubkey) } diff --git a/pkg/nostr-sdk/relays.go b/pkg/nostr-sdk/relays.go index 8fe02e38..60fbedd2 100644 --- a/pkg/nostr-sdk/relays.go +++ b/pkg/nostr-sdk/relays.go @@ -60,20 +60,20 @@ func ParseRelaysFromKind10002(evt *event.T) []Relay { } u := normalize.URL(u) - relay := Relay{ + rl := Relay{ URL: u, } if len(tag) == 2 { - relay.Inbox = true - relay.Outbox = true + rl.Inbox = true + rl.Outbox = true } else if tag[2] == "write" { - relay.Outbox = true + rl.Outbox = true } else if tag[2] == "read" { - relay.Inbox = true + rl.Inbox = true } - result = append(result, relay) + result = append(result, rl) } } @@ -97,18 +97,18 @@ func ParseRelaysFromKind3(evt *event.T) []Relay { } u := normalize.URL(u) - relay := Relay{ + rl := Relay{ URL: u, } if item.Read { - relay.Inbox = true + rl.Inbox = true } if item.Write { - relay.Outbox = true + rl.Outbox = true } - results = append(results, relay) + results = append(results, rl) i++ } diff --git a/pkg/nostr-sdk/system.go b/pkg/nostr-sdk/system.go index 4f468db3..de731bb1 100644 --- a/pkg/nostr-sdk/system.go +++ b/pkg/nostr-sdk/system.go @@ -45,9 +45,9 @@ func (sys System) FetchRelays(ctx context.Context, pubkey string) []Relay { func (sys System) FetchOutboxRelays(ctx context.Context, pubkey string) []string { relays := sys.FetchRelays(ctx, pubkey) result := make([]string, 0, len(relays)) - for _, relay := range relays { - if relay.Outbox { - result = append(result, relay.URL) + for _, rl := range relays { + if rl.Outbox { + result = append(result, rl.URL) } } return result @@ -108,11 +108,11 @@ func (sys System) FetchUserEvents(ctx context.Context, filt filter.Filter) (map[ results := make(map[string][]*event.T) wg := sync.WaitGroup{} wg.Add(len(filters)) - for relay, ff := range filters { - go func(relay *relays.Relay, f filter.Filter) { + for rl, ff := range filters { + go func(rl *relays.Relay, f filter.Filter) { defer wg.Done() f.Limit = f.Limit * len(f.Authors) // hack - sub, err := relay.Subscribe(ctx, filter.Filters{filt}) + sub, err := rl.Subscribe(ctx, filter.Filters{filt}) if err != nil { return } @@ -124,7 +124,7 @@ func (sys System) FetchUserEvents(ctx context.Context, filt filter.Filter) (map[ return } } - }(relay, ff) + }(rl, ff) } wg.Wait() diff --git a/pkg/nostr/auth/response.go b/pkg/nostr/auth/response.go index 4e893774..0a5d2b92 100644 --- a/pkg/nostr/auth/response.go +++ b/pkg/nostr/auth/response.go @@ -31,12 +31,12 @@ type ResponseEnvelope struct { // // The caller must sign the embedded event before sending it back to // authenticate. -func New(ac *ChallengeEnvelope, relay string) (ae *ResponseEnvelope) { +func New(ac *ChallengeEnvelope, rl string) (ae *ResponseEnvelope) { ae = &ResponseEnvelope{ &event.T{ Kind: kind.ClientAuthentication, Tags: tags.T{ - {"relay", relay}, + {"relay", rl}, {"challenge", ac.Challenge}, }, }, diff --git a/pkg/nostr/relay/relay.go b/pkg/nostr/relay/relay.go index 43f50882..6b4e2030 100644 --- a/pkg/nostr/relay/relay.go +++ b/pkg/nostr/relay/relay.go @@ -497,11 +497,11 @@ func (r *Relay) PrepareSubscription(ctx context.Context, filters filters.T, return } -func (r *Relay) QuerySync(ctx context.Context, filter *filter.T, +func (r *Relay) QuerySync(ctx context.Context, f *filter.T, opts ...SubscriptionOption) (evs []*event.T, e error) { var sub *Subscription - if sub, e = r.Subscribe(ctx, filters.T{filter}, opts...); fails(e) { + if sub, e = r.Subscribe(ctx, filters.T{f}, opts...); fails(e) { return } defer sub.Unsub() diff --git a/pkg/nostr/sdk/outbox.go b/pkg/nostr/sdk/outbox.go index df4c3f93..da0363e7 100644 --- a/pkg/nostr/sdk/outbox.go +++ b/pkg/nostr/sdk/outbox.go @@ -27,11 +27,11 @@ func (s *System) ExpandQueriesByAuthorAndRelays( relayURLs := s.FetchOutboxRelays(ctx, pubkey) c := 0 for _, r := range relayURLs { - var relay *relay.Relay - if relay, e = s.Pool.EnsureRelay(r); log.E.Chk(e) { + var rl *relay.Relay + if rl, e = s.Pool.EnsureRelay(r); log.E.Chk(e) { continue } - relaysForPubkey[pubkey] = append(relaysForPubkey[pubkey], relay) + relaysForPubkey[pubkey] = append(relaysForPubkey[pubkey], rl) c++ if c == 3 { return @@ -42,11 +42,11 @@ func (s *System) ExpandQueriesByAuthorAndRelays( wg.Wait() filters = make(map[*relay.Relay]*filter.T, n) // { [relay]: filter } for pubkey, relays := range relaysForPubkey { - for _, relay := range relays { - flt, ok := filters[relay] + for _, rl := range relays { + flt, ok := filters[rl] if !ok { flt = f.Clone() - filters[relay] = flt + filters[rl] = flt } flt.Authors = append(flt.Authors, pubkey) } diff --git a/pkg/nostr/sdk/relays.go b/pkg/nostr/sdk/relays.go index a7fe0c59..5f52877b 100644 --- a/pkg/nostr/sdk/relays.go +++ b/pkg/nostr/sdk/relays.go @@ -57,18 +57,18 @@ func ParseRelaysFromKind10002(evt *event.T) (r []Relay) { if !IsValidRelayURL(u) { continue } - relay := Relay{ + rl := Relay{ URL: normalize.URL(u), } if len(tag) == 2 { - relay.Inbox = true - relay.Outbox = true + rl.Inbox = true + rl.Outbox = true } else if tag[2] == "write" { - relay.Outbox = true + rl.Outbox = true } else if tag[2] == "read" { - relay.Inbox = true + rl.Inbox = true } - r = append(r, relay) + r = append(r, rl) } } return @@ -90,16 +90,16 @@ func ParseRelaysFromKind3(evt *event.T) (r []Relay) { if !IsValidRelayURL(u) { continue } - relay := Relay{ + rl := Relay{ URL: normalize.URL(u), } if item.Read { - relay.Inbox = true + rl.Inbox = true } if item.Write { - relay.Outbox = true + rl.Outbox = true } - r = append(r, relay) + r = append(r, rl) i++ } return r diff --git a/pkg/nostr/sdk/system.go b/pkg/nostr/sdk/system.go index 27547adb..521066e4 100644 --- a/pkg/nostr/sdk/system.go +++ b/pkg/nostr/sdk/system.go @@ -46,9 +46,9 @@ func (s *System) FetchRelays(ctx context.Context, pubkey string) []Relay { func (s *System) FetchOutboxRelays(ctx context.Context, pubkey string) []string { relays := s.FetchRelays(ctx, pubkey) result := make([]string, 0, len(relays)) - for _, relay := range relays { - if relay.Outbox { - result = append(result, relay.URL) + for _, rl := range relays { + if rl.Outbox { + result = append(result, rl.URL) } } return result diff --git a/pkg/pool/pool.go b/pkg/pool/pool.go index d22c7443..5a431d20 100644 --- a/pkg/pool/pool.go +++ b/pkg/pool/pool.go @@ -96,12 +96,12 @@ func (p *SimplePool) subMany(ctx context.Context, urls []string, filters filters pending.Add(int64(initial)) for _, url := range urls { go func(nm string) { - relay, err := p.EnsureRelay(nm) + rl, err := p.EnsureRelay(nm) if err != nil { return } - sub, _ := relay.Subscribe(ctx, filters) + sub, _ := rl.Subscribe(ctx, filters) if sub == nil { return } @@ -113,7 +113,7 @@ func (p *SimplePool) subMany(ctx context.Context, urls []string, filters filters } if !stop { select { - case events <- IncomingEvent{T: evt, Relay: relay}: + case events <- IncomingEvent{T: evt, Relay: rl}: case <-ctx.Done(): return } @@ -159,14 +159,14 @@ func (p *SimplePool) subManyEose(ctx context.Context, urls []string, filters fil go func(nm string) { defer wg.Done() - relay, err := p.EnsureRelay(nm) + rl, err := p.EnsureRelay(nm) if err != nil { return } - sub, err := relay.Subscribe(ctx, filters) + sub, err := rl.Subscribe(ctx, filters) if sub == nil { - log.E.F("error subscribing to %s with %v: %s", relay, filters, err) + log.E.F("error subscribing to %s with %v: %s", rl, filters, err) return } @@ -187,7 +187,7 @@ func (p *SimplePool) subManyEose(ctx context.Context, urls []string, filters fil } if !stop { select { - case events <- IncomingEvent{T: evt, Relay: relay}: + case events <- IncomingEvent{T: evt, Relay: rl}: case <-ctx.Done(): return } diff --git a/pkg/relay/eventstore/badger/query.go b/pkg/relay/eventstore/badger/query.go index bb803f84..f3b0d3d8 100644 --- a/pkg/relay/eventstore/badger/query.go +++ b/pkg/relay/eventstore/badger/query.go @@ -27,7 +27,7 @@ type queryEvent struct { query int } -func (b *Backend) Q(queries []query, since uint32, extraFilter *filter.T, filter *filter.T, +func (b *Backend) Q(queries []query, since uint32, extraFilter *filter.T, f *filter.T, evChan chan *event.T) { e := b.View(func(txn *badger.Txn) (e error) { @@ -83,8 +83,8 @@ func (b *Backend) Q(queries []query, since uint32, extraFilter *filter.T, filter } // max number of events we'll return limit := b.MaxLimit - if filter.Limit > 0 && filter.Limit < limit { - limit = filter.Limit + if f.Limit > 0 && f.Limit < limit { + limit = f.Limit } // receive results and ensure we only return the most recent ones always emittedEvents := 0 diff --git a/pkg/relay/eventstore/relay_interface.go b/pkg/relay/eventstore/relay_interface.go index 86c8cb03..6f3fc3cc 100644 --- a/pkg/relay/eventstore/relay_interface.go +++ b/pkg/relay/eventstore/relay_interface.go @@ -13,7 +13,7 @@ import ( // RelayInterface is a wrapper thing that unifies Store and nostr.Relay under a common API. type RelayInterface interface { Publish(ctx context.Context, event event.T) error - QuerySync(ctx context.Context, filter *filter.T, opts ...SubscriptionOption) ([]*event.T, error) + QuerySync(ctx context.Context, f *filter.T, opts ...SubscriptionOption) ([]*event.T, error) } // SubscriptionOption is the type of the argument passed for that. @@ -81,14 +81,14 @@ func (w RelayWrapper) Publish(ctx context.Context, evt event.T) (e error) { return nil } -func (w RelayWrapper) QuerySync(ctx context.Context, filter *filter.T, +func (w RelayWrapper) QuerySync(ctx context.Context, f *filter.T, opts ...SubscriptionOption) (evs []*event.T, e error) { var ch chan *event.T - if ch, e = w.Store.QueryEvents(ctx, filter); log.E.Chk(e) { + if ch, e = w.Store.QueryEvents(ctx, f); log.E.Chk(e) { return nil, fmt.Errorf("failed to query: %w", e) } - n := filter.Limit + n := f.Limit if n == 0 { n = 500 } diff --git a/pkg/relay/handlers.go b/pkg/relay/handlers.go index 876b1b58..9a87cd29 100644 --- a/pkg/relay/handlers.go +++ b/pkg/relay/handlers.go @@ -183,8 +183,8 @@ func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) { return } var total int64 - for _, filter := range env.T { - total += rl.handleCountRequest(ctx, ws, filter) + for _, f := range env.T { + total += rl.handleCountRequest(ctx, ws, f) } rl.D.Chk(ws.WriteJSON(countresponse.Envelope{ SubscriptionID: env.SubscriptionID, @@ -200,9 +200,9 @@ func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) { env.SubscriptionID) // handle each filter separately -- dispatching events as // they're loaded from databases - for _, filter := range env.T { + for _, f := range env.T { e = rl.handleRequest(reqCtx, env.SubscriptionID, - &ee, ws, filter) + &ee, ws, f) if e != nil { // fail everything if any filter is rejected reason := e.Error() diff --git a/pkg/relay/policies/filters.go b/pkg/relay/policies/filters.go index 901e3abe..cce0a076 100644 --- a/pkg/relay/policies/filters.go +++ b/pkg/relay/policies/filters.go @@ -10,10 +10,10 @@ import ( ) // NoComplexFilters disallows filters with more than 2 tags. -func NoComplexFilters(ctx context.Context, filter filter.T) (reject bool, msg string) { - items := len(filter.Tags) + len(filter.Kinds) +func NoComplexFilters(ctx context.Context, f filter.T) (reject bool, msg string) { + items := len(f.Tags) + len(f.Kinds) - if items > 4 && len(filter.Tags) > 2 { + if items > 4 && len(f.Tags) > 2 { return true, "too many things to filter for" } @@ -21,9 +21,9 @@ func NoComplexFilters(ctx context.Context, filter filter.T) (reject bool, msg st } // NoEmptyFilters disallows filters that don't have at least a tag, a kind, an author or an id. -func NoEmptyFilters(ctx context.Context, filter filter.T) (reject bool, msg string) { - c := len(filter.Kinds) + len(filter.IDs) + len(filter.Authors) - for _, tagItems := range filter.Tags { +func NoEmptyFilters(ctx context.Context, f filter.T) (reject bool, msg string) { + c := len(f.Kinds) + len(f.IDs) + len(f.Authors) + for _, tagItems := range f.Tags { c += len(tagItems) } if c == 0 { @@ -34,41 +34,41 @@ func NoEmptyFilters(ctx context.Context, filter filter.T) (reject bool, msg stri // AntiSyncBots tries to prevent people from syncing kind:1s from this relay to else by always // requiring an author parameter at least. -func AntiSyncBots(ctx context.Context, filter filter.T) (reject bool, msg string) { - return (len(filter.Kinds) == 0 || slices.Contains(filter.Kinds, 1)) && - len(filter.Authors) == 0, "an author must be specified to get their kind:1 notes" +func AntiSyncBots(ctx context.Context, f filter.T) (reject bool, msg string) { + return (len(f.Kinds) == 0 || slices.Contains(f.Kinds, 1)) && + len(f.Authors) == 0, "an author must be specified to get their kind:1 notes" } -func NoSearchQueries(ctx context.Context, filter filter.T) (reject bool, msg string) { - if filter.Search != "" { +func NoSearchQueries(ctx context.Context, f filter.T) (reject bool, msg string) { + if f.Search != "" { return true, "search is not supported" } return false, "" } -func RemoveSearchQueries(ctx context.Context, filter *filter.T) { - filter.Search = "" +func RemoveSearchQueries(ctx context.Context, f *filter.T) { + f.Search = "" } func RemoveAllButKinds(kinds ...uint16) func(context.Context, *filter.T) { - return func(ctx context.Context, filter *filter.T) { - if n := len(filter.Kinds); n > 0 { + return func(ctx context.Context, f *filter.T) { + if n := len(f.Kinds); n > 0 { newKinds := make(kinds2.T, 0, n) for i := 0; i < n; i++ { - if k := filter.Kinds[i]; slices.Contains(kinds, uint16(k)) { + if k := f.Kinds[i]; slices.Contains(kinds, uint16(k)) { newKinds = append(newKinds, k) } } - filter.Kinds = newKinds + f.Kinds = newKinds } } } func RemoveAllButTags(tagNames ...string) func(context.Context, *filter.T) { - return func(ctx context.Context, filter *filter.T) { - for tagName := range filter.Tags { + return func(ctx context.Context, f *filter.T) { + for tagName := range f.Tags { if !slices.Contains(tagNames, tagName) { - delete(filter.Tags, tagName) + delete(f.Tags, tagName) } } } diff --git a/pkg/relay/policies/nip04.go b/pkg/relay/policies/nip04.go index b67bb365..ad90f63a 100644 --- a/pkg/relay/policies/nip04.go +++ b/pkg/relay/policies/nip04.go @@ -8,31 +8,37 @@ import ( "golang.org/x/exp/slices" ) -// RejectKind04Snoopers prevents reading NIP-04 messages from people not involved in the conversation. -func RejectKind04Snoopers(ctx context.Context, filter filter.T) (bool, string) { +// RejectKind04Snoopers prevents reading NIP-04 messages from people not +// involved in the conversation. +func RejectKind04Snoopers(ctx context.Context, f filter.T) (bool, string) { // prevent kind-4 events from being returned to unauthed users, // only when authentication is a thing - if !slices.Contains(filter.Kinds, 4) { + if !slices.Contains(f.Kinds, 4) { return false, "" } ws := relay.GetConnection(ctx) - senders := filter.Authors - receivers, _ := filter.Tags["p"] + senders := f.Authors + receivers, _ := f.Tags["p"] switch { case ws.AuthedPublicKey == "": // not authenticated - return true, "restricted: this relay does not serve kind-4 to unauthenticated users, does your client implement NIP-42?" - case len(senders) == 1 && len(receivers) < 2 && (senders[0] == ws.AuthedPublicKey): - // allowed filter: ws.authed is sole sender (filter specifies one or all receivers) + return true, "restricted: this relay does not serve kind-4 to" + + " unauthenticated users, does your client implement NIP-42?" + case len(senders) == 1 && len(receivers) < 2 && + (senders[0] == ws.AuthedPublicKey): + // allowed filter: ws.authed is sole sender (filter specifies one or all + // receivers) return false, "" - case len(receivers) == 1 && len(senders) < 2 && (receivers[0] == ws.AuthedPublicKey): - // allowed filter: ws.authed is sole receiver (filter specifies one or all senders) + case len(receivers) == 1 && len(senders) < 2 && + (receivers[0] == ws.AuthedPublicKey): + // allowed filter: ws.authed is sole receiver (filter specifies one or + // all senders) return false, "" default: - // restricted filter: do not return any events, - // even if other elements in filters array were not restricted). - // client should know better. - return true, "restricted: authenticated user does not have authorization for requested filters." + // restricted filter: do not return any events, even if other elements + // in filters array were not restricted). client should know better. + return true, "restricted: authenticated user does not have " + + "authorization for requested filters." } } diff --git a/pkg/relay/relay.go b/pkg/relay/relay.go index b8910636..f684124f 100644 --- a/pkg/relay/relay.go +++ b/pkg/relay/relay.go @@ -44,22 +44,22 @@ func New() *Relay { type Relay struct { ServiceURL string - RejectEvent []func(ctx context.Context, event *event.T) (reject bool, msg string) - RejectFilter []func(ctx context.Context, filter *filter.T) (reject bool, msg string) - RejectCountFilter []func(ctx context.Context, filter *filter.T) (reject bool, msg string) + RejectEvent []func(ctx context.Context, ev *event.T) (reject bool, msg string) + RejectFilter []func(ctx context.Context, f *filter.T) (reject bool, msg string) + RejectCountFilter []func(ctx context.Context, f *filter.T) (reject bool, msg string) OverwriteDeletionOutcome []func(ctx context.Context, target *event.T, deletion *event.T) (acceptDeletion bool, msg string) - OverwriteResponseEvent []func(ctx context.Context, event *event.T) - OverwriteFilter []func(ctx context.Context, filter *filter.T) - OverwriteCountFilter []func(ctx context.Context, filter *filter.T) + OverwriteResponseEvent []func(ctx context.Context, ev *event.T) + OverwriteFilter []func(ctx context.Context, f *filter.T) + OverwriteCountFilter []func(ctx context.Context, f *filter.T) OverwriteRelayInformation []func(ctx context.Context, r *http.Request, info *relayinfo.T) *relayinfo.T - StoreEvent []func(ctx context.Context, event *event.T) error - DeleteEvent []func(ctx context.Context, event *event.T) error - QueryEvents []func(ctx context.Context, filter *filter.T) (chan *event.T, error) - CountEvents []func(ctx context.Context, filter *filter.T) (int64, error) + StoreEvent []func(ctx context.Context, ev *event.T) error + DeleteEvent []func(ctx context.Context, ev *event.T) error + QueryEvents []func(ctx context.Context, f *filter.T) (chan *event.T, error) + CountEvents []func(ctx context.Context, f *filter.T) (int64, error) OnAuth []func(ctx context.Context, pubkey string) OnConnect []func(ctx context.Context) OnDisconnect []func(ctx context.Context) - OnEventSaved []func(ctx context.Context, event *event.T) + OnEventSaved []func(ctx context.Context, ev *event.T) // editing info will affect Info *relayinfo.T diff --git a/pkg/relay/serve-req.go b/pkg/relay/serve-req.go index 9a9cce26..66e9a251 100644 --- a/pkg/relay/serve-req.go +++ b/pkg/relay/serve-req.go @@ -13,15 +13,15 @@ import ( ) func (rl *Relay) handleRequest(ctx context.Context, id subscriptionid.T, - eose *sync.WaitGroup, ws *WebSocket, filter *filter.T) (e error) { + eose *sync.WaitGroup, ws *WebSocket, f *filter.T) (e error) { defer eose.Done() // overwrite the filter (for example, to eliminate some kinds or // that we know we don't support) for _, ovw := range rl.OverwriteFilter { - ovw(ctx, filter) + ovw(ctx, f) } - if filter.Limit < 0 { + if f.Limit < 0 { return errors.New("blocked: filter invalidated") } // then check if we'll reject this filter (we apply this after overwriting @@ -29,7 +29,7 @@ func (rl *Relay) handleRequest(ctx context.Context, id subscriptionid.T, // that we know we don't support, and then if the end result is an empty // filter we can just reject it) for _, reject := range rl.RejectFilter { - if reject, msg := reject(ctx, filter); reject { + if reject, msg := reject(ctx, f); reject { rl.D.Chk(ws.WriteJSON(notice.Envelope{Text: msg})) return errors.New(OK.Message(OK.Blocked, msg)) } @@ -39,7 +39,7 @@ func (rl *Relay) handleRequest(ctx context.Context, id subscriptionid.T, eose.Add(len(rl.QueryEvents)) for _, query := range rl.QueryEvents { var ch chan *event.T - if ch, e = query(ctx, filter); rl.E.Chk(e) { + if ch, e = query(ctx, f); rl.E.Chk(e) { rl.D.Chk(ws.WriteJSON(notice.Envelope{Text: e.Error()})) eose.Done() continue @@ -57,14 +57,15 @@ func (rl *Relay) handleRequest(ctx context.Context, id subscriptionid.T, return nil } -func (rl *Relay) handleCountRequest(ctx context.Context, ws *WebSocket, filter *filter.T) int64 { - // overwrite the filter (for example, to eliminate some kinds or tags that we know we don't support) +func (rl *Relay) handleCountRequest(ctx context.Context, ws *WebSocket, f *filter.T) int64 { + // overwrite the filter (for example, to eliminate some kinds or tags that + // we know we don't support) for _, ovw := range rl.OverwriteCountFilter { - ovw(ctx, filter) + ovw(ctx, f) } // then check if we'll reject this filter for _, reject := range rl.RejectCountFilter { - if rejecting, msg := reject(ctx, filter); rejecting { + if rejecting, msg := reject(ctx, f); rejecting { rl.D.Chk(ws.WriteJSON(notice.Envelope{Text: msg})) return 0 } @@ -74,7 +75,7 @@ func (rl *Relay) handleCountRequest(ctx context.Context, ws *WebSocket, filter * for _, count := range rl.CountEvents { var e error var res int64 - if res, e = count(ctx, filter); rl.E.Chk(e) { + if res, e = count(ctx, f); rl.E.Chk(e) { rl.D.Chk(ws.WriteJSON(notice.Envelope{Text: e.Error()})) } subtotal += res