p2p: add static node dialing test

p2p/server.go

@@ -103,8 +103,9 @@ type Server struct {
 	lock        sync.RWMutex // protects running, peers and the trust fields
 	running     bool
 	peers       map[discover.NodeID]*Peer
-	statics    map[discover.NodeID]*discover.Node // Map of currently static remote nodes
+	staticNodes map[discover.NodeID]*discover.Node // Map of currently maintained static remote nodes
 	staticDial  chan *discover.Node                // Dial request channel reserved for the static nodes
+	staticCycle time.Duration                      // Overrides staticPeerCheckInterval, used for testing
 
 	ntab     *discover.Table
 	listener net.Listener
@@ -144,7 +145,7 @@ func (srv *Server) AddPeer(node *discover.Node) {
 	srv.lock.Lock()
 	defer srv.lock.Unlock()
 
-	srv.statics[node.ID] = node
+	srv.staticNodes[node.ID] = node
 }
 
 // Broadcast sends an RLP-encoded message to all connected peers.
@@ -207,9 +208,9 @@ func (srv *Server) Start() (err error) {
 	srv.peers = make(map[discover.NodeID]*Peer)
 
 	// Create the current trust map, and the associated dialing channel
-	srv.statics = make(map[discover.NodeID]*discover.Node)
+	srv.staticNodes = make(map[discover.NodeID]*discover.Node)
 	for _, node := range srv.StaticNodes {
-		srv.statics[node.ID] = node
+		srv.staticNodes[node.ID] = node
 	}
 	srv.staticDial = make(chan *discover.Node)
 
@@ -345,17 +346,23 @@ func (srv *Server) listenLoop() {
 // staticNodesLoop is responsible for periodically checking that static
 // connections are actually live, and requests dialing if not.
 func (srv *Server) staticNodesLoop() {
-	tick := time.Tick(staticPeerCheckInterval)
+	// Create a default maintenance ticker, but override it requested
+	cycle := staticPeerCheckInterval
+	if srv.staticCycle != 0 {
+		cycle = srv.staticCycle
+	}
+	tick := time.NewTicker(cycle)
+
 	for {
 		select {
 		case <-srv.quit:
 			return
 
-		case <-tick:
+		case <-tick.C:
 			// Collect all the non-connected static nodes
 			needed := []*discover.Node{}
 			srv.lock.RLock()
-			for id, node := range srv.statics {
+			for id, node := range srv.staticNodes {
 				if _, ok := srv.peers[id]; !ok {
 					needed = append(needed, node)
 				}
@@ -473,7 +480,7 @@ func (srv *Server) startPeer(fd net.Conn, dest *discover.Node) {
 	srv.lock.RLock()
 	atcap := len(srv.peers) == srv.MaxPeers
 	if dest != nil {
-		if _, ok := srv.statics[dest.ID]; ok {
+		if _, ok := srv.staticNodes[dest.ID]; ok {
 			atcap = false
 		}
 	}
@@ -536,7 +543,7 @@ func (srv *Server) addPeer(id discover.NodeID, p *Peer) (bool, DiscReason) {
 // in the pool, or if it's of no use.
 func (srv *Server) checkPeer(id discover.NodeID) (bool, DiscReason) {
 	// First up, figure out if the peer is static
-	_, static := srv.statics[id]
+	_, static := srv.staticNodes[id]
 
 	// Make sure the peer passes all required checks
 	switch {

p2p/server_test.go

@@ -219,6 +219,94 @@ func TestServerDisconnectAtCap(t *testing.T) {
 	}
 }
 
+// Tests that static peers are (re)connected, and done so even above max peers.
+func TestServerStaticPeers(t *testing.T) {
+	defer testlog(t).detach()
+
+	// Create a test server with limited connection slots
+	started := make(chan *Peer)
+	server := &Server{
+		ListenAddr:  "127.0.0.1:0",
+		PrivateKey:  newkey(),
+		MaxPeers:    3,
+		newPeerHook: func(p *Peer) { started <- p },
+		staticCycle: time.Second,
+	}
+	if err := server.Start(); err != nil {
+		t.Fatal(err)
+	}
+	defer server.Stop()
+
+	// Fill up all the slots on the server
+	dialer := &net.Dialer{Deadline: time.Now().Add(3 * time.Second)}
+	for i := 0; i < server.MaxPeers; i++ {
+		// Establish a new connection
+		conn, err := dialer.Dial("tcp", server.ListenAddr)
+		if err != nil {
+			t.Fatalf("conn %d: dial error: %v", i, err)
+		}
+		defer conn.Close()
+
+		// Run the handshakes just like a real peer would, and wait for completion
+		key := newkey()
+		shake := &protoHandshake{Version: baseProtocolVersion, ID: discover.PubkeyID(&key.PublicKey)}
+		if _, err = setupConn(conn, key, shake, server.Self(), false); err != nil {
+			t.Fatalf("conn %d: unexpected error: %v", i, err)
+		}
+		<-started
+	}
+	// Open a TCP listener to accept static connections
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("failed to setup listener: %v", err)
+	}
+	defer listener.Close()
+
+	connected := make(chan net.Conn)
+	go func() {
+		for i := 0; i < 3; i++ {
+			conn, err := listener.Accept()
+			if err == nil {
+				connected <- conn
+			}
+		}
+	}()
+	// Inject a static node and wait for a remote dial, then redial, then nothing
+	addr := listener.Addr().(*net.TCPAddr)
+	static := &discover.Node{
+		ID:      discover.PubkeyID(&newkey().PublicKey),
+		IP:      addr.IP,
+		TCPPort: addr.Port,
+	}
+	server.AddPeer(static)
+
+	select {
+	case conn := <-connected:
+		// Close the first connection, expect redial
+		conn.Close()
+
+	case <-time.After(2 * server.staticCycle):
+		t.Fatalf("remote dial timeout")
+	}
+
+	select {
+	case conn := <-connected:
+		// Keep the second connection, don't expect redial
+		defer conn.Close()
+
+	case <-time.After(2 * server.staticCycle):
+		t.Fatalf("remote re-dial timeout")
+	}
+
+	select {
+	case <-time.After(2 * server.staticCycle):
+		// Timeout as no dial occurred
+
+	case <-connected:
+		t.Fatalf("connected node dialed")
+	}
+}
+
 /*
 // Tests that trusted peers and can connect above max peer caps.
 func TestServerTrustedPeers(t *testing.T) {