p2p/dnsdisc: rate limit resolving before checking cache (#22566)

This makes the rate limit apply regardless of whether the node is
already cached.
This commit is contained in:
Felix Lange 2021-03-24 13:37:20 +01:00 committed by GitHub
parent 15e6c27f8b
commit ab8fd4d005
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

View File

@ -37,9 +37,10 @@ import (
// Client discovers nodes by querying DNS servers. // Client discovers nodes by querying DNS servers.
type Client struct { type Client struct {
cfg Config cfg Config
clock mclock.Clock clock mclock.Clock
entries *lru.Cache entries *lru.Cache
ratelimit *rate.Limiter
} }
// Config holds configuration options for the client. // Config holds configuration options for the client.
@ -97,8 +98,12 @@ func NewClient(cfg Config) *Client {
panic(err) panic(err)
} }
rlimit := rate.NewLimiter(rate.Limit(cfg.RateLimit), 10) rlimit := rate.NewLimiter(rate.Limit(cfg.RateLimit), 10)
cfg.Resolver = &rateLimitResolver{cfg.Resolver, rlimit} return &Client{
return &Client{cfg: cfg, entries: cache, clock: mclock.System{}} cfg: cfg,
entries: cache,
clock: mclock.System{},
ratelimit: rlimit,
}
} }
// SyncTree downloads the entire node tree at the given URL. // SyncTree downloads the entire node tree at the given URL.
@ -157,6 +162,13 @@ func parseAndVerifyRoot(txt string, loc *linkEntry) (rootEntry, error) {
// resolveEntry retrieves an entry from the cache or fetches it from the network // resolveEntry retrieves an entry from the cache or fetches it from the network
// if it isn't cached. // if it isn't cached.
func (c *Client) resolveEntry(ctx context.Context, domain, hash string) (entry, error) { func (c *Client) resolveEntry(ctx context.Context, domain, hash string) (entry, error) {
// The rate limit always applies, even when the result might be cached. This is
// important because it avoids hot-spinning in consumers of node iterators created on
// this client.
if err := c.ratelimit.Wait(ctx); err != nil {
return nil, err
}
cacheKey := truncateHash(hash) cacheKey := truncateHash(hash)
if e, ok := c.entries.Get(cacheKey); ok { if e, ok := c.entries.Get(cacheKey); ok {
return e.(entry), nil return e.(entry), nil
@ -196,19 +208,6 @@ func (c *Client) doResolveEntry(ctx context.Context, domain, hash string) (entry
return nil, nameError{name, errNoEntry} return nil, nameError{name, errNoEntry}
} }
// rateLimitResolver applies a rate limit to a Resolver.
type rateLimitResolver struct {
r Resolver
limiter *rate.Limiter
}
func (r *rateLimitResolver) LookupTXT(ctx context.Context, domain string) ([]string, error) {
if err := r.limiter.Wait(ctx); err != nil {
return nil, err
}
return r.r.LookupTXT(ctx, domain)
}
// randomIterator traverses a set of trees and returns nodes found in them. // randomIterator traverses a set of trees and returns nodes found in them.
type randomIterator struct { type randomIterator struct {
cur *enode.Node cur *enode.Node