peer: Remove error return from Connect.

peer/example_test.go

@@ -39,10 +39,7 @@ func mockRemotePeer() error {
 
 		// Create and start the inbound peer.
 		p := peer.NewInboundPeer(peerCfg)
-		if err := p.Connect(conn); err != nil {
+		p.Connect(conn)
-			fmt.Printf("Connect: error %v\n", err)
-			return
-		}
 	}()
 
 	return nil
@@ -93,10 +90,7 @@ func Example_newOutboundPeer() {
 		fmt.Printf("net.Dial: error %v\n", err)
 		return
 	}
-	if err := p.Connect(conn); err != nil {
+	p.Connect(conn)
-		fmt.Printf("Connect: error %v\n", err)
-		return
-	}
 
 	// Wait for the verack message or timeout in case of failure.
 	select {

peer/peer.go

@@ -775,7 +775,6 @@ func (p *Peer) pushVersionMsg() error {
 	// recently seen nonces.
 	nonce, err := wire.RandomUint64()
 	if err != nil {
-		fmt.Println(err)
 		return err
 	}
 	sentNonces.Add(nonce)
@@ -1951,10 +1950,10 @@ func (p *Peer) QueueInventory(invVect *wire.InvVect) {
 
 // Connect uses the given conn to connect to the peer. Calling this function when
 // the peer is already connected  will have no effect.
-func (p *Peer) Connect(conn net.Conn) error {
+func (p *Peer) Connect(conn net.Conn) {
 	// Already connected?
 	if !atomic.CompareAndSwapInt32(&p.connected, 0, 1) {
-		return nil
+		return
 	}
 
 	if p.inbound {
@@ -1963,7 +1962,11 @@ func (p *Peer) Connect(conn net.Conn) error {
 	p.conn = conn
 	p.timeConnected = time.Now()
 
-	return p.start()
+	go func() {
+		if err := p.start(); err != nil {
+			log.Errorf("Cannot start peer %v: %v", p, err)
+		}
+	}()
 }
 
 // Connected returns whether or not the peer is currently connected.

peer/peer_test.go

@@ -245,16 +245,13 @@ func TestPeerConnection(t *testing.T) {
 					&conn{raddr: "10.0.0.2:8333"},
 				)
 				inPeer := peer.NewInboundPeer(peerCfg)
-				if err := inPeer.Connect(inConn); err != nil {
+				inPeer.Connect(inConn)
-					return nil, nil, err
+
-				}
 				outPeer, err := peer.NewOutboundPeer(peerCfg, "10.0.0.2:8333")
 				if err != nil {
 					return nil, nil, err
 				}
-				if err := outPeer.Connect(outConn); err != nil {
+				outPeer.Connect(outConn)
-					return nil, nil, err
-				}
 
 				for i := 0; i < 2; i++ {
 					select {
@@ -274,16 +271,14 @@ func TestPeerConnection(t *testing.T) {
 					&conn{raddr: "10.0.0.2:8333"},
 				)
 				inPeer := peer.NewInboundPeer(peerCfg)
-				if err := inPeer.Connect(inConn); err != nil {
+				inPeer.Connect(inConn)
-					return nil, nil, err
+
-				}
 				outPeer, err := peer.NewOutboundPeer(peerCfg, "10.0.0.2:8333")
 				if err != nil {
 					return nil, nil, err
 				}
-				if err := outPeer.Connect(outConn); err != nil {
+				outPeer.Connect(outConn)
-					return nil, nil, err
+
-				}
 				for i := 0; i < 2; i++ {
 					select {
 					case <-verack:
@@ -393,10 +388,8 @@ func TestPeerListeners(t *testing.T) {
 		&conn{raddr: "10.0.0.2:8333"},
 	)
 	inPeer := peer.NewInboundPeer(peerCfg)
-	if err := inPeer.Connect(inConn); err != nil {
+	inPeer.Connect(inConn)
-		t.Errorf("TestPeerListeners: unexpected err %v\n", err)
+
-		return
-	}
 	peerCfg.Listeners = peer.MessageListeners{
 		OnVerAck: func(p *peer.Peer, msg *wire.MsgVerAck) {
 			verack <- struct{}{}
@@ -407,10 +400,8 @@ func TestPeerListeners(t *testing.T) {
 		t.Errorf("NewOutboundPeer: unexpected err %v\n", err)
 		return
 	}
-	if err := outPeer.Connect(outConn); err != nil {
+	outPeer.Connect(outConn)
-		t.Errorf("TestPeerListeners: unexpected err %v\n", err)
+
-		return
-	}
 	for i := 0; i < 2; i++ {
 		select {
 		case <-verack:
@@ -524,14 +515,11 @@ func TestPeerListeners(t *testing.T) {
 
 // TestOutboundPeer tests that the outbound peer works as expected.
 func TestOutboundPeer(t *testing.T) {
-	// Use a mock NewestBlock func to test errs
-	var errBlockNotFound = errors.New("newest block not found")
-	var mockNewestSha = func() (*wire.ShaHash, int32, error) {
-		return nil, 0, errBlockNotFound
-	}
 
 	peerCfg := &peer.Config{
-		NewestBlock:      mockNewestSha,
+		NewestBlock: func() (*wire.ShaHash, int32, error) {
+			return nil, 0, errors.New("newest block not found")
+		},
 		UserAgentName:    "peer",
 		UserAgentVersion: "1.0",
 		ChainParams:      &chaincfg.MainNetParams,
@@ -547,26 +535,35 @@ func TestOutboundPeer(t *testing.T) {
 		return
 	}
 
-	wantErr := errBlockNotFound
+	// Test trying to connect twice.
-	if err := p.Connect(c); err != wantErr {
+	p.Connect(c)
-		t.Errorf("Connect: expected err %v, got %v\n", wantErr, err)
+	p.Connect(c)
-		return
+
+	disconnected := make(chan struct{})
+	go func() {
+		p.WaitForDisconnect()
+		disconnected <- struct{}{}
+	}()
+
+	select {
+	case <-disconnected:
+	case <-time.After(time.Second):
+		t.Fatal("Peer did not automatically disconnect.")
 	}
 
-	// Test already connected.
+	if p.Connected() {
-	if err := p.Connect(c); err != nil {
+		t.Fatalf("Should not be connected as NewestBlock produces error.")
-		t.Errorf("Connect: unexpected err %v\n", err)
-		return
 	}
 
 	// Test Queue Inv
 	fakeBlockHash := &wire.ShaHash{0: 0x00, 1: 0x01}
 	fakeInv := wire.NewInvVect(wire.InvTypeBlock, fakeBlockHash)
+
+	// Should be noops as the peer could not connect.
 	p.QueueInventory(fakeInv)
 	p.AddKnownInventory(fakeInv)
 	p.QueueInventory(fakeInv)
 
-	// Test Queue Message
 	fakeMsg := wire.NewMsgVerAck()
 	p.QueueMessage(fakeMsg, nil)
 	done := make(chan struct{})
@@ -591,10 +588,7 @@ func TestOutboundPeer(t *testing.T) {
 		t.Errorf("NewOutboundPeer: unexpected err - %v\n", err)
 		return
 	}
-	if err := p1.Connect(c1); err != nil {
+	p1.Connect(c1)
-		t.Errorf("Connect: unexpected err %v\n", err)
-		return
-	}
 
 	// Test update latest block
 	latestBlockSha, err := wire.NewShaHashFromStr("1a63f9cdff1752e6375c8c76e543a71d239e1a2e5c6db1aa679")
@@ -624,10 +618,7 @@ func TestOutboundPeer(t *testing.T) {
 		t.Errorf("NewOutboundPeer: unexpected err - %v\n", err)
 		return
 	}
-	if err := p2.Connect(c2); err != nil {
+	p2.Connect(c2)
-		t.Errorf("Connect: unexpected err %v\n", err)
-		return
-	}
 
 	// Test PushXXX
 	var addrs []*wire.NetAddress

server.go

@@ -1573,12 +1573,7 @@ func (s *server) listenHandler(listener net.Listener) {
 		sp := newServerPeer(s, false)
 		sp.Peer = peer.NewInboundPeer(newPeerConfig(sp))
 		go s.peerDoneHandler(sp)
-		if err := sp.Connect(conn); err != nil {
+		sp.Connect(conn)
-			if atomic.LoadInt32(&s.shutdown) == 0 {
-				srvrLog.Errorf("Can't accept connection: %v", err)
-			}
-			continue
-		}
 	}
 	s.wg.Done()
 	srvrLog.Tracef("Listener handler done for %s", listener.Addr())
@@ -1674,9 +1669,7 @@ func (s *server) establishConn(sp *serverPeer) error {
 	if err != nil {
 		return err
 	}
-	if err := sp.Connect(conn); err != nil {
+	sp.Connect(conn)
-		return err
-	}
 	srvrLog.Debugf("Connected to %s", sp.Addr())
 	s.addrManager.Attempt(sp.NA())
 	return nil