Change StopPeerForError to sequential execution

diff --git a/p2p/switch.go b/p2p/switch.go
index 052a534..37bf4e4 100644 (file)
--- a/p2p/switch.go
+++ b/p2p/switch.go
@@ -20,8 +20,8 @@ import (
 )
 
 const (
-       reconnectAttempts = 30
-       reconnectInterval = 3 * time.Second
+       reconnectAttempts = 10
+       reconnectInterval = 10 * time.Second
 
        bannedPeerKey      = "BannedPeer"
        defaultBanDuration = time.Hour * 24
@@ -95,6 +95,8 @@ type Switch struct {
 
 var (
        ErrSwitchDuplicatePeer = errors.New("Duplicate peer")
+       ErrConnectSelf         = errors.New("Connect self")
+       ErrPeerConnected       = errors.New("Peer is connected")
 )
 
 func NewSwitch(config *cfg.P2PConfig, trustHistoryDB dbm.DB) *Switch {
@@ -363,12 +365,12 @@ func (sw *Switch) DialPeerWithAddress(addr *NetAddress, persistent bool) (*Peer,
        if err := sw.checkBannedPeer(addr.IP.String()); err != nil {
                return nil, err
        }
-       if strings.Compare(addr.IP.String(), sw.nodeInfo.ListenHost())==0 {
-               return nil, errors.New("Connect self")
+       if strings.Compare(addr.IP.String(), sw.nodeInfo.ListenHost()) == 0 {
+               return nil, ErrConnectSelf
        }
        for _, v := range sw.Peers().list {
                if strings.Compare(v.mconn.RemoteAddress.IP.String(), addr.IP.String()) == 0 {
-                       return nil, errors.New("Peer is connected")
+                       return nil, ErrPeerConnected
                }
        }
        sw.dialing.Set(addr.IP.String(), addr)
@@ -454,38 +456,38 @@ func (sw *Switch) StopPeerForError(peer *Peer, reason interface{}) {
        sw.stopAndRemovePeer(peer, reason)
 
        if peer.IsPersistent() {
-               go func() {
-                       log.WithField("peer", peer).Info("Reconnecting to peer")
-                       for i := 1; i < reconnectAttempts; i++ {
-                               if !sw.IsRunning() {
-                                       return
-                               }
+               log.WithField("peer", peer).Info("Reconnecting to peer")
+               for i := 1; i < reconnectAttempts; i++ {
+                       if !sw.IsRunning() {
+                               return
+                       }
 
-                               peer, err := sw.DialPeerWithAddress(addr, true)
-                               if err != nil {
-                                       if i == reconnectAttempts {
-                                               log.WithFields(log.Fields{
-                                                       "retries": i,
-                                                       "error":   err,
-                                               }).Info("Error reconnecting to peer. Giving up")
-                                               return
-                                       }
-                                       if errors.Root(err) == ErrSwitchDuplicatePeer {
-                                               log.WithField("error", err).Info("Error reconnecting to peer. ")
-                                               return
-                                       }
+                       peer, err := sw.DialPeerWithAddress(addr, true)
+                       if err != nil {
+                               if i == reconnectAttempts {
                                        log.WithFields(log.Fields{
                                                "retries": i,
                                                "error":   err,
-                                       }).Info("Error reconnecting to peer. Trying again")
-                                       time.Sleep(reconnectInterval)
-                                       continue
+                                       }).Info("Error reconnecting to peer. Giving up")
+                                       return
                                }
 
-                               log.WithField("peer", peer).Info("Reconnected to peer")
-                               return
+                               if errors.Root(err) == ErrConnectBannedPeer || errors.Root(err) == ErrPeerConnected || errors.Root(err) == ErrSwitchDuplicatePeer || errors.Root(err) == ErrConnectSelf {
+                                       log.WithField("error", err).Info("Error reconnecting to peer. ")
+                                       return
+                               }
+
+                               log.WithFields(log.Fields{
+                                       "retries": i,
+                                       "error":   err,
+                               }).Info("Error reconnecting to peer. Trying again")
+                               time.Sleep(reconnectInterval)
+                               continue
                        }
-               }()
+
+                       log.WithField("peer", peer).Info("Reconnected to peer")
+                       return
+               }
        }
 }