mirror of https://github.com/ethereum/go-ethereum
p2p, p2p/discover: add signed ENR generation (#17753)
This PR adds enode.LocalNode and integrates it into the p2p subsystem. This new object is the keeper of the local node record. For now, a new version of the record is produced every time the client restarts. We'll make it smarter to avoid that in the future. There are a couple of other changes in this commit: discovery now waits for all of its goroutines at shutdown and the p2p server now closes the node database after discovery has shut down. This fixes a leveldb crash in tests. p2p server startup is faster because it doesn't need to wait for the external IP query anymore.pull/17856/merge
Felix Lange
6 years ago
committed by
GitHub
parent
dcae0d348b
commit
6f607de5d5
@ -0,0 +1,246 @@ |
||||
// Copyright 2018 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package enode |
||||
|
||||
import ( |
||||
"crypto/ecdsa" |
||||
"fmt" |
||||
"net" |
||||
"reflect" |
||||
"strconv" |
||||
"sync" |
||||
"sync/atomic" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/log" |
||||
"github.com/ethereum/go-ethereum/p2p/enr" |
||||
"github.com/ethereum/go-ethereum/p2p/netutil" |
||||
) |
||||
|
||||
const ( |
||||
// IP tracker configuration
|
||||
iptrackMinStatements = 10 |
||||
iptrackWindow = 5 * time.Minute |
||||
iptrackContactWindow = 10 * time.Minute |
||||
) |
||||
|
||||
// LocalNode produces the signed node record of a local node, i.e. a node run in the
|
||||
// current process. Setting ENR entries via the Set method updates the record. A new version
|
||||
// of the record is signed on demand when the Node method is called.
|
||||
type LocalNode struct { |
||||
cur atomic.Value // holds a non-nil node pointer while the record is up-to-date.
|
||||
id ID |
||||
key *ecdsa.PrivateKey |
||||
db *DB |
||||
|
||||
// everything below is protected by a lock
|
||||
mu sync.Mutex |
||||
seq uint64 |
||||
entries map[string]enr.Entry |
||||
udpTrack *netutil.IPTracker // predicts external UDP endpoint
|
||||
staticIP net.IP |
||||
fallbackIP net.IP |
||||
fallbackUDP int |
||||
} |
||||
|
||||
// NewLocalNode creates a local node.
|
||||
func NewLocalNode(db *DB, key *ecdsa.PrivateKey) *LocalNode { |
||||
ln := &LocalNode{ |
||||
id: PubkeyToIDV4(&key.PublicKey), |
||||
db: db, |
||||
key: key, |
||||
udpTrack: netutil.NewIPTracker(iptrackWindow, iptrackContactWindow, iptrackMinStatements), |
||||
entries: make(map[string]enr.Entry), |
||||
} |
||||
ln.seq = db.localSeq(ln.id) |
||||
ln.invalidate() |
||||
return ln |
||||
} |
||||
|
||||
// Database returns the node database associated with the local node.
|
||||
func (ln *LocalNode) Database() *DB { |
||||
return ln.db |
||||
} |
||||
|
||||
// Node returns the current version of the local node record.
|
||||
func (ln *LocalNode) Node() *Node { |
||||
n := ln.cur.Load().(*Node) |
||||
if n != nil { |
||||
return n |
||||
} |
||||
// Record was invalidated, sign a new copy.
|
||||
ln.mu.Lock() |
||||
defer ln.mu.Unlock() |
||||
ln.sign() |
||||
return ln.cur.Load().(*Node) |
||||
} |
||||
|
||||
// ID returns the local node ID.
|
||||
func (ln *LocalNode) ID() ID { |
||||
return ln.id |
||||
} |
||||
|
||||
// Set puts the given entry into the local record, overwriting
|
||||
// any existing value.
|
||||
func (ln *LocalNode) Set(e enr.Entry) { |
||||
ln.mu.Lock() |
||||
defer ln.mu.Unlock() |
||||
|
||||
ln.set(e) |
||||
} |
||||
|
||||
func (ln *LocalNode) set(e enr.Entry) { |
||||
val, exists := ln.entries[e.ENRKey()] |
||||
if !exists || !reflect.DeepEqual(val, e) { |
||||
ln.entries[e.ENRKey()] = e |
||||
ln.invalidate() |
||||
} |
||||
} |
||||
|
||||
// Delete removes the given entry from the local record.
|
||||
func (ln *LocalNode) Delete(e enr.Entry) { |
||||
ln.mu.Lock() |
||||
defer ln.mu.Unlock() |
||||
|
||||
ln.delete(e) |
||||
} |
||||
|
||||
func (ln *LocalNode) delete(e enr.Entry) { |
||||
_, exists := ln.entries[e.ENRKey()] |
||||
if exists { |
||||
delete(ln.entries, e.ENRKey()) |
||||
ln.invalidate() |
||||
} |
||||
} |
||||
|
||||
// SetStaticIP sets the local IP to the given one unconditionally.
|
||||
// This disables endpoint prediction.
|
||||
func (ln *LocalNode) SetStaticIP(ip net.IP) { |
||||
ln.mu.Lock() |
||||
defer ln.mu.Unlock() |
||||
|
||||
ln.staticIP = ip |
||||
ln.updateEndpoints() |
||||
} |
||||
|
||||
// SetFallbackIP sets the last-resort IP address. This address is used
|
||||
// if no endpoint prediction can be made and no static IP is set.
|
||||
func (ln *LocalNode) SetFallbackIP(ip net.IP) { |
||||
ln.mu.Lock() |
||||
defer ln.mu.Unlock() |
||||
|
||||
ln.fallbackIP = ip |
||||
ln.updateEndpoints() |
||||
} |
||||
|
||||
// SetFallbackUDP sets the last-resort UDP port. This port is used
|
||||
// if no endpoint prediction can be made.
|
||||
func (ln *LocalNode) SetFallbackUDP(port int) { |
||||
ln.mu.Lock() |
||||
defer ln.mu.Unlock() |
||||
|
||||
ln.fallbackUDP = port |
||||
ln.updateEndpoints() |
||||
} |
||||
|
||||
// UDPEndpointStatement should be called whenever a statement about the local node's
|
||||
// UDP endpoint is received. It feeds the local endpoint predictor.
|
||||
func (ln *LocalNode) UDPEndpointStatement(fromaddr, endpoint *net.UDPAddr) { |
||||
ln.mu.Lock() |
||||
defer ln.mu.Unlock() |
||||
|
||||
ln.udpTrack.AddStatement(fromaddr.String(), endpoint.String()) |
||||
ln.updateEndpoints() |
||||
} |
||||
|
||||
// UDPContact should be called whenever the local node has announced itself to another node
|
||||
// via UDP. It feeds the local endpoint predictor.
|
||||
func (ln *LocalNode) UDPContact(toaddr *net.UDPAddr) { |
||||
ln.mu.Lock() |
||||
defer ln.mu.Unlock() |
||||
|
||||
ln.udpTrack.AddContact(toaddr.String()) |
||||
ln.updateEndpoints() |
||||
} |
||||
|
||||
func (ln *LocalNode) updateEndpoints() { |
||||
// Determine the endpoints.
|
||||
newIP := ln.fallbackIP |
||||
newUDP := ln.fallbackUDP |
||||
if ln.staticIP != nil { |
||||
newIP = ln.staticIP |
||||
} else if ip, port := predictAddr(ln.udpTrack); ip != nil { |
||||
newIP = ip |
||||
newUDP = port |
||||
} |
||||
|
||||
// Update the record.
|
||||
if newIP != nil && !newIP.IsUnspecified() { |
||||
ln.set(enr.IP(newIP)) |
||||
if newUDP != 0 { |
||||
ln.set(enr.UDP(newUDP)) |
||||
} else { |
||||
ln.delete(enr.UDP(0)) |
||||
} |
||||
} else { |
||||
ln.delete(enr.IP{}) |
||||
} |
||||
} |
||||
|
||||
// predictAddr wraps IPTracker.PredictEndpoint, converting from its string-based
|
||||
// endpoint representation to IP and port types.
|
||||
func predictAddr(t *netutil.IPTracker) (net.IP, int) { |
||||
ep := t.PredictEndpoint() |
||||
if ep == "" { |
||||
return nil, 0 |
||||
} |
||||
ipString, portString, _ := net.SplitHostPort(ep) |
||||
ip := net.ParseIP(ipString) |
||||
port, _ := strconv.Atoi(portString) |
||||
return ip, port |
||||
} |
||||
|
||||
func (ln *LocalNode) invalidate() { |
||||
ln.cur.Store((*Node)(nil)) |
||||
} |
||||
|
||||
func (ln *LocalNode) sign() { |
||||
if n := ln.cur.Load().(*Node); n != nil { |
||||
return // no changes
|
||||
} |
||||
|
||||
var r enr.Record |
||||
for _, e := range ln.entries { |
||||
r.Set(e) |
||||
} |
||||
ln.bumpSeq() |
||||
r.SetSeq(ln.seq) |
||||
if err := SignV4(&r, ln.key); err != nil { |
||||
panic(fmt.Errorf("enode: can't sign record: %v", err)) |
||||
} |
||||
n, err := New(ValidSchemes, &r) |
||||
if err != nil { |
||||
panic(fmt.Errorf("enode: can't verify local record: %v", err)) |
||||
} |
||||
ln.cur.Store(n) |
||||
log.Info("New local node record", "seq", ln.seq, "id", n.ID(), "ip", n.IP(), "udp", n.UDP(), "tcp", n.TCP()) |
||||
} |
||||
|
||||
func (ln *LocalNode) bumpSeq() { |
||||
ln.seq++ |
||||
ln.db.storeLocalSeq(ln.id, ln.seq) |
||||
} |
||||
@ -0,0 +1,76 @@ |
||||
// Copyright 2018 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package enode |
||||
|
||||
import ( |
||||
"testing" |
||||
|
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
"github.com/ethereum/go-ethereum/p2p/enr" |
||||
) |
||||
|
||||
func newLocalNodeForTesting() (*LocalNode, *DB) { |
||||
db, _ := OpenDB("") |
||||
key, _ := crypto.GenerateKey() |
||||
return NewLocalNode(db, key), db |
||||
} |
||||
|
||||
func TestLocalNode(t *testing.T) { |
||||
ln, db := newLocalNodeForTesting() |
||||
defer db.Close() |
||||
|
||||
if ln.Node().ID() != ln.ID() { |
||||
t.Fatal("inconsistent ID") |
||||
} |
||||
|
||||
ln.Set(enr.WithEntry("x", uint(3))) |
||||
var x uint |
||||
if err := ln.Node().Load(enr.WithEntry("x", &x)); err != nil { |
||||
t.Fatal("can't load entry 'x':", err) |
||||
} else if x != 3 { |
||||
t.Fatal("wrong value for entry 'x':", x) |
||||
} |
||||
} |
||||
|
||||
func TestLocalNodeSeqPersist(t *testing.T) { |
||||
ln, db := newLocalNodeForTesting() |
||||
defer db.Close() |
||||
|
||||
if s := ln.Node().Seq(); s != 1 { |
||||
t.Fatalf("wrong initial seq %d, want 1", s) |
||||
} |
||||
ln.Set(enr.WithEntry("x", uint(1))) |
||||
if s := ln.Node().Seq(); s != 2 { |
||||
t.Fatalf("wrong seq %d after set, want 2", s) |
||||
} |
||||
|
||||
// Create a new instance, it should reload the sequence number.
|
||||
// The number increases just after that because a new record is
|
||||
// created without the "x" entry.
|
||||
ln2 := NewLocalNode(db, ln.key) |
||||
if s := ln2.Node().Seq(); s != 3 { |
||||
t.Fatalf("wrong seq %d on new instance, want 3", s) |
||||
} |
||||
|
||||
// Create a new instance with a different node key on the same database.
|
||||
// This should reset the sequence number.
|
||||
key, _ := crypto.GenerateKey() |
||||
ln3 := NewLocalNode(db, key) |
||||
if s := ln3.Node().Seq(); s != 1 { |
||||
t.Fatalf("wrong seq %d on instance with changed key, want 1", s) |
||||
} |
||||
} |
||||
@ -0,0 +1,130 @@ |
||||
// Copyright 2018 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package netutil |
||||
|
||||
import ( |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/common/mclock" |
||||
) |
||||
|
||||
// IPTracker predicts the external endpoint, i.e. IP address and port, of the local host
|
||||
// based on statements made by other hosts.
|
||||
type IPTracker struct { |
||||
window time.Duration |
||||
contactWindow time.Duration |
||||
minStatements int |
||||
clock mclock.Clock |
||||
statements map[string]ipStatement |
||||
contact map[string]mclock.AbsTime |
||||
lastStatementGC mclock.AbsTime |
||||
lastContactGC mclock.AbsTime |
||||
} |
||||
|
||||
type ipStatement struct { |
||||
endpoint string |
||||
time mclock.AbsTime |
||||
} |
||||
|
||||
// NewIPTracker creates an IP tracker.
|
||||
//
|
||||
// The window parameters configure the amount of past network events which are kept. The
|
||||
// minStatements parameter enforces a minimum number of statements which must be recorded
|
||||
// before any prediction is made. Higher values for these parameters decrease 'flapping' of
|
||||
// predictions as network conditions change. Window duration values should typically be in
|
||||
// the range of minutes.
|
||||
func NewIPTracker(window, contactWindow time.Duration, minStatements int) *IPTracker { |
||||
return &IPTracker{ |
||||
window: window, |
||||
contactWindow: contactWindow, |
||||
statements: make(map[string]ipStatement), |
||||
minStatements: minStatements, |
||||
contact: make(map[string]mclock.AbsTime), |
||||
clock: mclock.System{}, |
||||
} |
||||
} |
||||
|
||||
// PredictFullConeNAT checks whether the local host is behind full cone NAT. It predicts by
|
||||
// checking whether any statement has been received from a node we didn't contact before
|
||||
// the statement was made.
|
||||
func (it *IPTracker) PredictFullConeNAT() bool { |
||||
now := it.clock.Now() |
||||
it.gcContact(now) |
||||
it.gcStatements(now) |
||||
for host, st := range it.statements { |
||||
if c, ok := it.contact[host]; !ok || c > st.time { |
||||
return true |
||||
} |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// PredictEndpoint returns the current prediction of the external endpoint.
|
||||
func (it *IPTracker) PredictEndpoint() string { |
||||
it.gcStatements(it.clock.Now()) |
||||
|
||||
// The current strategy is simple: find the endpoint with most statements.
|
||||
counts := make(map[string]int) |
||||
maxcount, max := 0, "" |
||||
for _, s := range it.statements { |
||||
c := counts[s.endpoint] + 1 |
||||
counts[s.endpoint] = c |
||||
if c > maxcount && c >= it.minStatements { |
||||
maxcount, max = c, s.endpoint |
||||
} |
||||
} |
||||
return max |
||||
} |
||||
|
||||
// AddStatement records that a certain host thinks our external endpoint is the one given.
|
||||
func (it *IPTracker) AddStatement(host, endpoint string) { |
||||
now := it.clock.Now() |
||||
it.statements[host] = ipStatement{endpoint, now} |
||||
if time.Duration(now-it.lastStatementGC) >= it.window { |
||||
it.gcStatements(now) |
||||
} |
||||
} |
||||
|
||||
// AddContact records that a packet containing our endpoint information has been sent to a
|
||||
// certain host.
|
||||
func (it *IPTracker) AddContact(host string) { |
||||
now := it.clock.Now() |
||||
it.contact[host] = now |
||||
if time.Duration(now-it.lastContactGC) >= it.contactWindow { |
||||
it.gcContact(now) |
||||
} |
||||
} |
||||
|
||||
func (it *IPTracker) gcStatements(now mclock.AbsTime) { |
||||
it.lastStatementGC = now |
||||
cutoff := now.Add(-it.window) |
||||
for host, s := range it.statements { |
||||
if s.time < cutoff { |
||||
delete(it.statements, host) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (it *IPTracker) gcContact(now mclock.AbsTime) { |
||||
it.lastContactGC = now |
||||
cutoff := now.Add(-it.contactWindow) |
||||
for host, ct := range it.contact { |
||||
if ct < cutoff { |
||||
delete(it.contact, host) |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,138 @@ |
||||
// Copyright 2018 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package netutil |
||||
|
||||
import ( |
||||
"fmt" |
||||
mrand "math/rand" |
||||
"testing" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/common/mclock" |
||||
) |
||||
|
||||
const ( |
||||
opStatement = iota |
||||
opContact |
||||
opPredict |
||||
opCheckFullCone |
||||
) |
||||
|
||||
type iptrackTestEvent struct { |
||||
op int |
||||
time int // absolute, in milliseconds
|
||||
ip, from string |
||||
} |
||||
|
||||
func TestIPTracker(t *testing.T) { |
||||
tests := map[string][]iptrackTestEvent{ |
||||
"minStatements": { |
||||
{opPredict, 0, "", ""}, |
||||
{opStatement, 0, "127.0.0.1", "127.0.0.2"}, |
||||
{opPredict, 1000, "", ""}, |
||||
{opStatement, 1000, "127.0.0.1", "127.0.0.3"}, |
||||
{opPredict, 1000, "", ""}, |
||||
{opStatement, 1000, "127.0.0.1", "127.0.0.4"}, |
||||
{opPredict, 1000, "127.0.0.1", ""}, |
||||
}, |
||||
"window": { |
||||
{opStatement, 0, "127.0.0.1", "127.0.0.2"}, |
||||
{opStatement, 2000, "127.0.0.1", "127.0.0.3"}, |
||||
{opStatement, 3000, "127.0.0.1", "127.0.0.4"}, |
||||
{opPredict, 10000, "127.0.0.1", ""}, |
||||
{opPredict, 10001, "", ""}, // first statement expired
|
||||
{opStatement, 10100, "127.0.0.1", "127.0.0.2"}, |
||||
{opPredict, 10200, "127.0.0.1", ""}, |
||||
}, |
||||
"fullcone": { |
||||
{opContact, 0, "", "127.0.0.2"}, |
||||
{opStatement, 10, "127.0.0.1", "127.0.0.2"}, |
||||
{opContact, 2000, "", "127.0.0.3"}, |
||||
{opStatement, 2010, "127.0.0.1", "127.0.0.3"}, |
||||
{opContact, 3000, "", "127.0.0.4"}, |
||||
{opStatement, 3010, "127.0.0.1", "127.0.0.4"}, |
||||
{opCheckFullCone, 3500, "false", ""}, |
||||
}, |
||||
"fullcone_2": { |
||||
{opContact, 0, "", "127.0.0.2"}, |
||||
{opStatement, 10, "127.0.0.1", "127.0.0.2"}, |
||||
{opContact, 2000, "", "127.0.0.3"}, |
||||
{opStatement, 2010, "127.0.0.1", "127.0.0.3"}, |
||||
{opStatement, 3000, "127.0.0.1", "127.0.0.4"}, |
||||
{opContact, 3010, "", "127.0.0.4"}, |
||||
{opCheckFullCone, 3500, "true", ""}, |
||||
}, |
||||
} |
||||
for name, test := range tests { |
||||
t.Run(name, func(t *testing.T) { runIPTrackerTest(t, test) }) |
||||
} |
||||
} |
||||
|
||||
func runIPTrackerTest(t *testing.T, evs []iptrackTestEvent) { |
||||
var ( |
||||
clock mclock.Simulated |
||||
it = NewIPTracker(10*time.Second, 10*time.Second, 3) |
||||
) |
||||
it.clock = &clock |
||||
for i, ev := range evs { |
||||
evtime := time.Duration(ev.time) * time.Millisecond |
||||
clock.Run(evtime - time.Duration(clock.Now())) |
||||
switch ev.op { |
||||
case opStatement: |
||||
it.AddStatement(ev.from, ev.ip) |
||||
case opContact: |
||||
it.AddContact(ev.from) |
||||
case opPredict: |
||||
if pred := it.PredictEndpoint(); pred != ev.ip { |
||||
t.Errorf("op %d: wrong prediction %q, want %q", i, pred, ev.ip) |
||||
} |
||||
case opCheckFullCone: |
||||
pred := fmt.Sprintf("%t", it.PredictFullConeNAT()) |
||||
if pred != ev.ip { |
||||
t.Errorf("op %d: wrong prediction %s, want %s", i, pred, ev.ip) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
// This checks that old statements and contacts are GCed even if Predict* isn't called.
|
||||
func TestIPTrackerForceGC(t *testing.T) { |
||||
var ( |
||||
clock mclock.Simulated |
||||
window = 10 * time.Second |
||||
rate = 50 * time.Millisecond |
||||
max = int(window/rate) + 1 |
||||
it = NewIPTracker(window, window, 3) |
||||
) |
||||
it.clock = &clock |
||||
|
||||
for i := 0; i < 5*max; i++ { |
||||
e1 := make([]byte, 4) |
||||
e2 := make([]byte, 4) |
||||
mrand.Read(e1) |
||||
mrand.Read(e2) |
||||
it.AddStatement(string(e1), string(e2)) |
||||
it.AddContact(string(e1)) |
||||
clock.Run(rate) |
||||
} |
||||
if len(it.contact) > 2*max { |
||||
t.Errorf("contacts not GCed, have %d", len(it.contact)) |
||||
} |
||||
if len(it.statements) > 2*max { |
||||
t.Errorf("statements not GCed, have %d", len(it.statements)) |
||||
} |
||||
} |
||||
Loading…
Reference in new issue