p2p, dex: rework connection management (#183)

* p2p, dex: rework connection management
* dex: refresh our node record periodically
* dex: don't send new record event if no new record

1 files changed, 0 insertions, 131 deletions

diff --git a/p2p/dial_test.go b/p2p/dial_test.go
index 35e439798..ab687c2ea 100644
--- a/p2p/dial_test.go
+++ b/p2p/dial_test.go
@@ -611,137 +611,6 @@ func TestDialStateDirectDial(t *testing.T) {
 	})
 }
 
-func TestDialStateGroupDial(t *testing.T) {
-	groups := []*dialGroup{
-		{
-			name: "g1",
-			nodes: map[enode.ID]*enode.Node{
-				uintID(1): newNode(uintID(1), nil),
-				uintID(2): newNode(uintID(2), nil),
-			},
-			num: 2,
-		},
-		{
-			name: "g2",
-			nodes: map[enode.ID]*enode.Node{
-				uintID(2): newNode(uintID(2), nil),
-				uintID(3): newNode(uintID(3), nil),
-				uintID(4): newNode(uintID(4), nil),
-				uintID(5): newNode(uintID(5), nil),
-				uintID(6): newNode(uintID(6), nil),
-			},
-			num: 2,
-		},
-	}
-
-	type groupTest struct {
-		peers   []*Peer
-		dialing map[enode.ID]connFlag
-		ceiling map[string]uint64
-	}
-
-	tests := []groupTest{
-		{
-			peers:   nil,
-			dialing: map[enode.ID]connFlag{},
-			ceiling: map[string]uint64{"g1": 2, "g2": 4},
-		},
-		{
-			peers: []*Peer{
-				{rw: &conn{flags: staticDialedConn, node: newNode(uintID(2), nil)}},
-			},
-			dialing: map[enode.ID]connFlag{
-				uintID(1): staticDialedConn,
-			},
-			ceiling: map[string]uint64{"g1": 2, "g2": 2},
-		},
-		{
-			peers: []*Peer{
-				{rw: &conn{flags: staticDialedConn, node: newNode(uintID(1), nil)}},
-				{rw: &conn{flags: staticDialedConn, node: newNode(uintID(3), nil)}},
-				{rw: &conn{flags: staticDialedConn, node: newNode(uintID(4), nil)}},
-				{rw: &conn{flags: staticDialedConn, node: newNode(uintID(5), nil)}},
-			},
-			dialing: map[enode.ID]connFlag{
-				uintID(2): staticDialedConn,
-			},
-			ceiling: map[string]uint64{"g1": 2, "g2": 4},
-		},
-		{
-			peers: nil,
-			dialing: map[enode.ID]connFlag{
-				uintID(1): staticDialedConn,
-				uintID(2): staticDialedConn,
-				uintID(3): staticDialedConn,
-			},
-			ceiling: map[string]uint64{"g1": 2, "g2": 4},
-		},
-	}
-
-	pm := func(ps []*Peer) map[enode.ID]*Peer {
-		m := make(map[enode.ID]*Peer)
-		for _, p := range ps {
-			m[p.rw.node.ID()] = p
-		}
-		return m
-	}
-
-	run := func(i int, tt groupTest) {
-		d := newDialState(enode.ID{}, nil, nil, fakeTable{}, 0, nil)
-		d.dialing = make(map[enode.ID]connFlag)
-		for k, v := range tt.dialing {
-			d.dialing[k] = v
-		}
-
-		for _, g := range groups {
-			d.addGroup(g)
-		}
-		peermap := pm(tt.peers)
-		new := d.newTasks(len(tt.dialing), peermap, time.Now())
-
-		cnt := map[string]uint64{}
-		for id := range peermap {
-			for _, g := range groups {
-				if _, ok := g.nodes[id]; ok {
-					cnt[g.name]++
-				}
-			}
-		}
-
-		for id := range tt.dialing {
-			for _, g := range groups {
-				if _, ok := g.nodes[id]; ok {
-					cnt[g.name]++
-				}
-			}
-		}
-
-		for _, task := range new {
-			id := task.(*dialTask).dest.ID()
-			for _, g := range groups {
-				if _, ok := g.nodes[id]; ok {
-					cnt[g.name]++
-				}
-			}
-		}
-
-		for _, g := range groups {
-			if cnt[g.name] < g.num {
-				t.Errorf("test %d) group %s peers + dialing + new < num (%d < %d)",
-					i, g.name, cnt[g.name], g.num)
-			}
-			if cnt[g.name] > tt.ceiling[g.name] {
-				t.Errorf("test %d) group %s peers + dialing + new > ceiling (%d > %d)",
-					i, g.name, cnt[g.name], tt.ceiling[g.name])
-			}
-		}
-	}
-
-	for i, tt := range tests {
-		run(i, tt)
-	}
-}
-
 // This test checks that static peers will be redialed immediately if they were re-added to a static list.
 func TestDialStaticAfterReset(t *testing.T) {
 	wantStatic := []*enode.Node{