diff options
| -rw-r--r-- | cmd/geth/main.go | 1 | ||||
| -rw-r--r-- | cmd/mist/main.go | 1 | ||||
| -rw-r--r-- | cmd/utils/flags.go | 6 | ||||
| -rw-r--r-- | eth/backend.go | 26 | ||||
| -rw-r--r-- | p2p/server.go | 25 | ||||
| -rw-r--r-- | p2p/server_test.go | 130 |
6 files changed, 170 insertions, 19 deletions
diff --git a/cmd/geth/main.go b/cmd/geth/main.go index 92c3b7a90..284f78c3e 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -242,6 +242,7 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso utils.JSpathFlag, utils.ListenPortFlag, utils.MaxPeersFlag, + utils.MaxPendingPeersFlag, utils.EtherbaseFlag, utils.MinerThreadsFlag, utils.MiningEnabledFlag, diff --git a/cmd/mist/main.go b/cmd/mist/main.go index 1030d6ada..9d92cc175 100644 --- a/cmd/mist/main.go +++ b/cmd/mist/main.go @@ -75,6 +75,7 @@ func init() { utils.LogFileFlag, utils.LogLevelFlag, utils.MaxPeersFlag, + utils.MaxPendingPeersFlag, utils.MinerThreadsFlag, utils.NATFlag, utils.NodeKeyFileFlag, diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index 1fdc8dfe5..0a1d650d6 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -197,6 +197,11 @@ var ( Usage: "Maximum number of network peers (network disabled if set to 0)", Value: 16, } + MaxPendingPeersFlag = cli.IntFlag{ + Name: "maxpendpeers", + Usage: "Maximum number of pending connection attempts (defaults used if set to 0)", + Value: 0, + } ListenPortFlag = cli.IntFlag{ Name: "port", Usage: "Network listening port", @@ -286,6 +291,7 @@ func MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config { AccountManager: GetAccountManager(ctx), VmDebug: ctx.GlobalBool(VMDebugFlag.Name), MaxPeers: ctx.GlobalInt(MaxPeersFlag.Name), + MaxPendingPeers: ctx.GlobalInt(MaxPendingPeersFlag.Name), Port: ctx.GlobalString(ListenPortFlag.Name), NAT: GetNAT(ctx), NatSpec: ctx.GlobalBool(NatspecEnabledFlag.Name), diff --git a/eth/backend.go b/eth/backend.go index 791336d75..0f23cde2f 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -60,8 +60,9 @@ type Config struct { VmDebug bool NatSpec bool - MaxPeers int - Port string + MaxPeers int + MaxPendingPeers int + Port string // Space-separated list of discovery node URLs BootNodes string @@ -280,16 +281,17 @@ func New(config *Config) (*Ethereum, error) { protocols = append(protocols, eth.whisper.Protocol()) } eth.net = &p2p.Server{ - PrivateKey: netprv, - Name: config.Name, - MaxPeers: config.MaxPeers, - Protocols: protocols, - NAT: config.NAT, - NoDial: !config.Dial, - BootstrapNodes: config.parseBootNodes(), - StaticNodes: config.parseNodes(staticNodes), - TrustedNodes: config.parseNodes(trustedNodes), - NodeDatabase: nodeDb, + PrivateKey: netprv, + Name: config.Name, + MaxPeers: config.MaxPeers, + MaxPendingPeers: config.MaxPendingPeers, + Protocols: protocols, + NAT: config.NAT, + NoDial: !config.Dial, + BootstrapNodes: config.parseBootNodes(), + StaticNodes: config.parseNodes(staticNodes), + TrustedNodes: config.parseNodes(trustedNodes), + NodeDatabase: nodeDb, } if len(config.Port) > 0 { eth.net.ListenAddr = ":" + config.Port diff --git a/p2p/server.go b/p2p/server.go index 164aaba37..77f66f167 100644 --- a/p2p/server.go +++ b/p2p/server.go @@ -22,9 +22,7 @@ const ( refreshPeersInterval = 30 * time.Second staticPeerCheckInterval = 15 * time.Second - // This is the maximum number of inbound connection - // that are allowed to linger between 'accepted' and - // 'added as peer'. + // Maximum number of concurrently handshaking inbound connections. maxAcceptConns = 10 // Maximum number of concurrently dialing outbound connections. @@ -55,6 +53,11 @@ type Server struct { // connected. It must be greater than zero. MaxPeers int + // MaxPendingPeers is the maximum number of peers that can be pending in the + // handshake phase, counted separately for inbound and outbound connections. + // Zero defaults to preset values. + MaxPendingPeers int + // Name sets the node name of this server. // Use common.MakeName to create a name that follows existing conventions. Name string @@ -334,8 +337,12 @@ func (srv *Server) listenLoop() { // This channel acts as a semaphore limiting // active inbound connections that are lingering pre-handshake. // If all slots are taken, no further connections are accepted. - slots := make(chan struct{}, maxAcceptConns) - for i := 0; i < maxAcceptConns; i++ { + tokens := maxAcceptConns + if srv.MaxPendingPeers > 0 { + tokens = srv.MaxPendingPeers + } + slots := make(chan struct{}, tokens) + for i := 0; i < tokens; i++ { slots <- struct{}{} } @@ -405,8 +412,12 @@ func (srv *Server) dialLoop() { defer refresh.Stop() // Limit the number of concurrent dials - slots := make(chan struct{}, maxDialingConns) - for i := 0; i < maxDialingConns; i++ { + tokens := maxAcceptConns + if srv.MaxPendingPeers > 0 { + tokens = srv.MaxPendingPeers + } + slots := make(chan struct{}, tokens) + for i := 0; i < tokens; i++ { slots <- struct{}{} } dial := func(dest *discover.Node) { diff --git a/p2p/server_test.go b/p2p/server_test.go index 3f9db343c..85a5a98cd 100644 --- a/p2p/server_test.go +++ b/p2p/server_test.go @@ -369,6 +369,136 @@ func TestServerTrustedPeers(t *testing.T) { } } +// Tests that a failed dial will temporarily throttle a peer. +func TestServerMaxPendingDials(t *testing.T) { + defer testlog(t).detach() + + // Start a simple test server + server := &Server{ + ListenAddr: "127.0.0.1:0", + PrivateKey: newkey(), + MaxPeers: 10, + MaxPendingPeers: 1, + } + if err := server.Start(); err != nil { + t.Fatal("failed to start test server: %v", err) + } + defer server.Stop() + + // Simulate two separate remote peers + peers := make(chan *discover.Node, 2) + conns := make(chan net.Conn, 2) + for i := 0; i < 2; i++ { + listener, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatalf("listener %d: failed to setup: %v", i, err) + } + defer listener.Close() + + addr := listener.Addr().(*net.TCPAddr) + peers <- &discover.Node{ + ID: discover.PubkeyID(&newkey().PublicKey), + IP: addr.IP, + TCP: uint16(addr.Port), + } + go func() { + conn, err := listener.Accept() + if err == nil { + conns <- conn + } + }() + } + // Request a dial for both peers + go func() { + for i := 0; i < 2; i++ { + server.staticDial <- <-peers // hack piggybacking the static implementation + } + }() + + // Make sure only one outbound connection goes through + var conn net.Conn + + select { + case conn = <-conns: + case <-time.After(100 * time.Millisecond): + t.Fatalf("first dial timeout") + } + select { + case conn = <-conns: + t.Fatalf("second dial completed prematurely") + case <-time.After(100 * time.Millisecond): + } + // Finish the first dial, check the second + conn.Close() + select { + case conn = <-conns: + conn.Close() + + case <-time.After(100 * time.Millisecond): + t.Fatalf("second dial timeout") + } +} + +func TestServerMaxPendingAccepts(t *testing.T) { + defer testlog(t).detach() + + // Start a test server and a peer sink for synchronization + started := make(chan *Peer) + server := &Server{ + ListenAddr: "127.0.0.1:0", + PrivateKey: newkey(), + MaxPeers: 10, + MaxPendingPeers: 1, + NoDial: true, + newPeerHook: func(p *Peer) { started <- p }, + } + if err := server.Start(); err != nil { + t.Fatal("failed to start test server: %v", err) + } + defer server.Stop() + + // Try and connect to the server on multiple threads concurrently + conns := make([]net.Conn, 2) + for i := 0; i < 2; i++ { + dialer := &net.Dialer{Deadline: time.Now().Add(3 * time.Second)} + + conn, err := dialer.Dial("tcp", server.ListenAddr) + if err != nil { + t.Fatalf("failed to dial server: %v", err) + } + conns[i] = conn + } + // Check that a handshake on the second doesn't pass + go func() { + key := newkey() + shake := &protoHandshake{Version: baseProtocolVersion, ID: discover.PubkeyID(&key.PublicKey)} + if _, err := setupConn(conns[1], key, shake, server.Self(), false, server.trustedNodes); err != nil { + t.Fatalf("failed to run handshake: %v", err) + } + }() + select { + case <-started: + t.Fatalf("handshake on second connection accepted") + + case <-time.After(100 * time.Millisecond): + } + // Shake on first, check that both go through + go func() { + key := newkey() + shake := &protoHandshake{Version: baseProtocolVersion, ID: discover.PubkeyID(&key.PublicKey)} + if _, err := setupConn(conns[0], key, shake, server.Self(), false, server.trustedNodes); err != nil { + t.Fatalf("failed to run handshake: %v", err) + } + }() + for i := 0; i < 2; i++ { + select { + case <-started: + case <-time.After(100 * time.Millisecond): + t.Fatalf("peer %d: handshake timeout", i) + } + } +} + func newkey() *ecdsa.PrivateKey { key, err := crypto.GenerateKey() if err != nil { |