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, 59 deletions

diff --git a/p2p/dial.go b/p2p/dial.go
index 909bed863..99acade36 100644
--- a/p2p/dial.go
+++ b/p2p/dial.go
@@ -64,12 +64,6 @@ func (t TCPDialer) Dial(dest *enode.Node) (net.Conn, error) {
 	return t.Dialer.Dial("tcp", addr.String())
 }
 
-type dialGroup struct {
-	name  string
-	nodes map[enode.ID]*enode.Node
-	num   uint64
-}
-
 // dialstate schedules dials and discovery lookups.
 // it get's a chance to compute new tasks on every iteration
 // of the main loop in Server.run.
@@ -85,7 +79,6 @@ type dialstate struct {
 	randomNodes   []*enode.Node // filled from Table
 	static        map[enode.ID]*dialTask
 	direct        map[enode.ID]*dialTask
-	group         map[string]*dialGroup
 	hist          *dialHistory
 
 	start     time.Time     // time when the dialer was first used
@@ -143,7 +136,6 @@ func newDialState(self enode.ID, static []*enode.Node, bootnodes []*enode.Node,
 		netrestrict: netrestrict,
 		static:      make(map[enode.ID]*dialTask),
 		direct:      make(map[enode.ID]*dialTask),
-		group:       make(map[string]*dialGroup),
 		dialing:     make(map[enode.ID]connFlag),
 		bootnodes:   make([]*enode.Node, len(bootnodes)),
 		randomNodes: make([]*enode.Node, maxdyn/2),
@@ -179,14 +171,6 @@ func (s *dialstate) removeDirect(n *enode.Node) {
 	s.hist.remove(n.ID())
 }
 
-func (s *dialstate) addGroup(g *dialGroup) {
-	s.group[g.name] = g
-}
-
-func (s *dialstate) removeGroup(g *dialGroup) {
-	delete(s.group, g.name)
-}
-
 func (s *dialstate) newTasks(nRunning int, peers map[enode.ID]*Peer, now time.Time) []task {
 	if s.start.IsZero() {
 		s.start = now
@@ -244,49 +228,6 @@ func (s *dialstate) newTasks(nRunning int, peers map[enode.ID]*Peer, now time.Ti
 		}
 	}
 
-	// compute connected
-	connected := map[string]map[enode.ID]struct{}{}
-	for _, g := range s.group {
-		connected[g.name] = map[enode.ID]struct{}{}
-	}
-
-	for id := range peers {
-		for _, g := range s.group {
-			if _, ok := g.nodes[id]; ok {
-				connected[g.name][id] = struct{}{}
-			}
-		}
-	}
-
-	for id := range s.dialing {
-		for _, g := range s.group {
-			if _, ok := g.nodes[id]; ok {
-				connected[g.name][id] = struct{}{}
-			}
-		}
-	}
-
-	groupNodes := map[enode.ID]*enode.Node{}
-	for _, g := range s.group {
-		for _, n := range g.nodes {
-			if uint64(len(connected[g.name])) >= g.num {
-				break
-			}
-			err := s.checkDial(n, peers)
-			switch err {
-			case errNotWhitelisted, errSelf:
-				log.Warn("Removing group dial candidate", "id", n.ID(), "addr", &net.TCPAddr{IP: n.IP(), Port: n.TCP()}, "err", err)
-				delete(g.nodes, n.ID())
-			case nil:
-				groupNodes[n.ID()] = n
-				connected[g.name][n.ID()] = struct{}{}
-			}
-		}
-	}
-	for _, n := range groupNodes {
-		addDial(groupDialedConn, n)
-	}
-
 	// If we don't have any peers whatsoever, try to dial a random bootnode. This
 	// scenario is useful for the testnet (and private networks) where the discovery
 	// table might be full of mostly bad peers, making it hard to find good ones.