You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

829 lines
22 KiB

p2p: seed mode refactoring (#3011) ListOfKnownAddresses is removed panic if addrbook size is less than zero CrawlPeers does not attempt to connect to existing or peers we're currently dialing various perf. fixes improved tests (though not complete) move IsDialingOrExistingAddress check into DialPeerWithAddress (Fixes #2716) * addrbook: preallocate memory when saving addrbook to file * addrbook: remove oldestFirst struct and check for ID * oldestFirst replaced with sort.Slice * ID is now mandatory, so no need to check * addrbook: remove ListOfKnownAddresses GetSelection is used instead in seed mode. * addrbook: panic if size is less than 0 * rewrite addrbook#saveToFile to not use a counter * test AttemptDisconnects func * move IsDialingOrExistingAddress check into DialPeerWithAddress * save and cleanup crawl peer data * get rid of DefaultSeedDisconnectWaitPeriod * make linter happy * fix TestPEXReactorSeedMode * fix comment * add a changelog entry * Apply suggestions from code review Co-Authored-By: melekes <anton.kalyaev@gmail.com> * rename ErrDialingOrExistingAddress to ErrCurrentlyDialingOrExistingAddress * lowercase errors * do not persist seed data pros: - no extra files - less IO cons: - if the node crashes, seed might crawl a peer too soon * fixes after Ethan's review * add a changelog entry * we should only consult Switch about peers checking addrbook size does not make sense since only PEX reactor uses it for dialing peers! https://github.com/tendermint/tendermint/pull/3011#discussion_r270948875
6 years ago
abci: localClient improvements & bugfixes & pubsub Unsubscribe issues (#2748) * use READ lock/unlock in ConsensusState#GetLastHeight Refs #2721 * do not use defers when there's no need * fix peer formatting (output its address instead of the pointer) ``` [54310]: E[11-02|11:59:39.851] Connection failed @ sendRoutine module=p2p peer=0xb78f00 conn=MConn{74.207.236.148:26656} err="pong timeout" ``` https://github.com/tendermint/tendermint/issues/2721#issuecomment-435326581 * panic if peer has no state https://github.com/tendermint/tendermint/issues/2721#issuecomment-435347165 It's confusing that sometimes we check if peer has a state, but most of the times we expect it to be there 1. https://github.com/tendermint/tendermint/blob/add79700b5fe84417538202b6c927c8cc5383672/mempool/reactor.go#L138 2. https://github.com/tendermint/tendermint/blob/add79700b5fe84417538202b6c927c8cc5383672/rpc/core/consensus.go#L196 (edited) I will change everything to always assume peer has a state and panic otherwise that should help identify issues earlier * abci/localclient: extend lock on app callback App callback should be protected by lock as well (note this was already done for InitChainAsync, why not for others???). Otherwise, when we execute the block, tx might come in and call the callback in the same time we're updating it in execBlockOnProxyApp => DATA RACE Fixes #2721 Consensus state is locked ``` goroutine 113333 [semacquire, 309 minutes]: sync.runtime_SemacquireMutex(0xc00180009c, 0xc0000c7e00) /usr/local/go/src/runtime/sema.go:71 +0x3d sync.(*RWMutex).RLock(0xc001800090) /usr/local/go/src/sync/rwmutex.go:50 +0x4e github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).GetRoundState(0xc001800000, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:218 +0x46 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusReactor).queryMaj23Routine(0xc0017def80, 0x11104a0, 0xc0072488f0, 0xc007248 9c0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/reactor.go:735 +0x16d created by github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusReactor).AddPeer /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/reactor.go:172 +0x236 ``` because localClient is locked ``` goroutine 1899 [semacquire, 309 minutes]: sync.runtime_SemacquireMutex(0xc00003363c, 0xc0000cb500) /usr/local/go/src/runtime/sema.go:71 +0x3d sync.(*Mutex).Lock(0xc000033638) /usr/local/go/src/sync/mutex.go:134 +0xff github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client.(*localClient).SetResponseCallback(0xc0001fb560, 0xc007868540) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client/local_client.go:32 +0x33 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy.(*appConnConsensus).SetResponseCallback(0xc00002f750, 0xc007868540) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy/app_conn.go:57 +0x40 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state.execBlockOnProxyApp(0x1104e20, 0xc002ca0ba0, 0x11092a0, 0xc00002f750, 0xc0001fe960, 0xc000bfc660, 0x110cfe0, 0xc000090330, 0xc9d12, 0xc000d9d5a0, ...) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state/execution.go:230 +0x1fd github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state.(*BlockExecutor).ApplyBlock(0xc002c2a230, 0x7, 0x0, 0xc000eae880, 0x6, 0xc002e52c60, 0x16, 0x1f927, 0xc9d12, 0xc000d9d5a0, ...) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state/execution.go:96 +0x142 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).finalizeCommit(0xc001800000, 0x1f928) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1339 +0xa3e github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).tryFinalizeCommit(0xc001800000, 0x1f928) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1270 +0x451 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).enterCommit.func1(0xc001800000, 0x0, 0x1f928) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1218 +0x90 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).enterCommit(0xc001800000, 0x1f928, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1247 +0x6b8 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).addVote(0xc001800000, 0xc003d8dea0, 0xc000cf4cc0, 0x28, 0xf1, 0xc003bc7ad0, 0xc003bc7b10) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1659 +0xbad github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).tryAddVote(0xc001800000, 0xc003d8dea0, 0xc000cf4cc0, 0x28, 0xf1, 0xf1, 0xf1) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1517 +0x59 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).handleMsg(0xc001800000, 0xd98200, 0xc0070dbed0, 0xc000cf4cc0, 0x28) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:660 +0x64b github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).receiveRoutine(0xc001800000, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:617 +0x670 created by github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).OnStart /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:311 +0x132 ``` tx comes in and CheckTx is executed right when we execute the block ``` goroutine 111044 [semacquire, 309 minutes]: sync.runtime_SemacquireMutex(0xc00003363c, 0x0) /usr/local/go/src/runtime/sema.go:71 +0x3d sync.(*Mutex).Lock(0xc000033638) /usr/local/go/src/sync/mutex.go:134 +0xff github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client.(*localClient).CheckTxAsync(0xc0001fb0e0, 0xc002d94500, 0x13f, 0x280, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client/local_client.go:85 +0x47 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy.(*appConnMempool).CheckTxAsync(0xc00002f720, 0xc002d94500, 0x13f, 0x280, 0x1) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy/app_conn.go:114 +0x51 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/mempool.(*Mempool).CheckTx(0xc002d3a320, 0xc002d94500, 0x13f, 0x280, 0xc0072355f0, 0x0, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/mempool/mempool.go:316 +0x17b github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/core.BroadcastTxSync(0xc002d94500, 0x13f, 0x280, 0x0, 0x0, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/core/mempool.go:93 +0xb8 reflect.Value.call(0xd85560, 0x10326c0, 0x13, 0xec7b8b, 0x4, 0xc00663f180, 0x1, 0x1, 0xc00663f180, 0xc00663f188, ...) /usr/local/go/src/reflect/value.go:447 +0x449 reflect.Value.Call(0xd85560, 0x10326c0, 0x13, 0xc00663f180, 0x1, 0x1, 0x0, 0x0, 0xc005cc9344) /usr/local/go/src/reflect/value.go:308 +0xa4 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server.makeHTTPHandler.func2(0x1102060, 0xc00663f100, 0xc0082d7900) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server/handlers.go:269 +0x188 net/http.HandlerFunc.ServeHTTP(0xc002c81f20, 0x1102060, 0xc00663f100, 0xc0082d7900) /usr/local/go/src/net/http/server.go:1964 +0x44 net/http.(*ServeMux).ServeHTTP(0xc002c81b60, 0x1102060, 0xc00663f100, 0xc0082d7900) /usr/local/go/src/net/http/server.go:2361 +0x127 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server.maxBytesHandler.ServeHTTP(0x10f8a40, 0xc002c81b60, 0xf4240, 0x1102060, 0xc00663f100, 0xc0082d7900) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server/http_server.go:219 +0xcf github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server.RecoverAndLogHandler.func1(0x1103220, 0xc00121e620, 0xc0082d7900) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server/http_server.go:192 +0x394 net/http.HandlerFunc.ServeHTTP(0xc002c06ea0, 0x1103220, 0xc00121e620, 0xc0082d7900) /usr/local/go/src/net/http/server.go:1964 +0x44 net/http.serverHandler.ServeHTTP(0xc001a1aa90, 0x1103220, 0xc00121e620, 0xc0082d7900) /usr/local/go/src/net/http/server.go:2741 +0xab net/http.(*conn).serve(0xc00785a3c0, 0x11041a0, 0xc000f844c0) /usr/local/go/src/net/http/server.go:1847 +0x646 created by net/http.(*Server).Serve /usr/local/go/src/net/http/server.go:2851 +0x2f5 ``` * consensus: use read lock in Receive#VoteMessage * use defer to unlock mutex because application might panic * use defer in every method of the localClient * add a changelog entry * drain channels before Unsubscribe(All) Read https://github.com/tendermint/tendermint/blob/55362ed76630f3e1ebec159a598f6a9fb5892cb1/libs/pubsub/pubsub.go#L13 for the detailed explanation of the issue. We'll need to fix it someday. Make sure to keep an eye on https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-033-pubsub.md * retry instead of panic when peer has no state in reactors other than consensus in /dump_consensus_state RPC endpoint, skip a peer with no state * rpc/core/mempool: simplify error messages * rpc/core/mempool: use time.After instead of timer also, do not log DeliverTx result (to be consistent with other memthods) * unlock before calling the callback in reqRes#SetCallback
6 years ago
abci: localClient improvements & bugfixes & pubsub Unsubscribe issues (#2748) * use READ lock/unlock in ConsensusState#GetLastHeight Refs #2721 * do not use defers when there's no need * fix peer formatting (output its address instead of the pointer) ``` [54310]: E[11-02|11:59:39.851] Connection failed @ sendRoutine module=p2p peer=0xb78f00 conn=MConn{74.207.236.148:26656} err="pong timeout" ``` https://github.com/tendermint/tendermint/issues/2721#issuecomment-435326581 * panic if peer has no state https://github.com/tendermint/tendermint/issues/2721#issuecomment-435347165 It's confusing that sometimes we check if peer has a state, but most of the times we expect it to be there 1. https://github.com/tendermint/tendermint/blob/add79700b5fe84417538202b6c927c8cc5383672/mempool/reactor.go#L138 2. https://github.com/tendermint/tendermint/blob/add79700b5fe84417538202b6c927c8cc5383672/rpc/core/consensus.go#L196 (edited) I will change everything to always assume peer has a state and panic otherwise that should help identify issues earlier * abci/localclient: extend lock on app callback App callback should be protected by lock as well (note this was already done for InitChainAsync, why not for others???). Otherwise, when we execute the block, tx might come in and call the callback in the same time we're updating it in execBlockOnProxyApp => DATA RACE Fixes #2721 Consensus state is locked ``` goroutine 113333 [semacquire, 309 minutes]: sync.runtime_SemacquireMutex(0xc00180009c, 0xc0000c7e00) /usr/local/go/src/runtime/sema.go:71 +0x3d sync.(*RWMutex).RLock(0xc001800090) /usr/local/go/src/sync/rwmutex.go:50 +0x4e github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).GetRoundState(0xc001800000, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:218 +0x46 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusReactor).queryMaj23Routine(0xc0017def80, 0x11104a0, 0xc0072488f0, 0xc007248 9c0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/reactor.go:735 +0x16d created by github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusReactor).AddPeer /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/reactor.go:172 +0x236 ``` because localClient is locked ``` goroutine 1899 [semacquire, 309 minutes]: sync.runtime_SemacquireMutex(0xc00003363c, 0xc0000cb500) /usr/local/go/src/runtime/sema.go:71 +0x3d sync.(*Mutex).Lock(0xc000033638) /usr/local/go/src/sync/mutex.go:134 +0xff github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client.(*localClient).SetResponseCallback(0xc0001fb560, 0xc007868540) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client/local_client.go:32 +0x33 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy.(*appConnConsensus).SetResponseCallback(0xc00002f750, 0xc007868540) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy/app_conn.go:57 +0x40 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state.execBlockOnProxyApp(0x1104e20, 0xc002ca0ba0, 0x11092a0, 0xc00002f750, 0xc0001fe960, 0xc000bfc660, 0x110cfe0, 0xc000090330, 0xc9d12, 0xc000d9d5a0, ...) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state/execution.go:230 +0x1fd github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state.(*BlockExecutor).ApplyBlock(0xc002c2a230, 0x7, 0x0, 0xc000eae880, 0x6, 0xc002e52c60, 0x16, 0x1f927, 0xc9d12, 0xc000d9d5a0, ...) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state/execution.go:96 +0x142 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).finalizeCommit(0xc001800000, 0x1f928) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1339 +0xa3e github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).tryFinalizeCommit(0xc001800000, 0x1f928) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1270 +0x451 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).enterCommit.func1(0xc001800000, 0x0, 0x1f928) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1218 +0x90 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).enterCommit(0xc001800000, 0x1f928, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1247 +0x6b8 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).addVote(0xc001800000, 0xc003d8dea0, 0xc000cf4cc0, 0x28, 0xf1, 0xc003bc7ad0, 0xc003bc7b10) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1659 +0xbad github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).tryAddVote(0xc001800000, 0xc003d8dea0, 0xc000cf4cc0, 0x28, 0xf1, 0xf1, 0xf1) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1517 +0x59 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).handleMsg(0xc001800000, 0xd98200, 0xc0070dbed0, 0xc000cf4cc0, 0x28) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:660 +0x64b github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).receiveRoutine(0xc001800000, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:617 +0x670 created by github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).OnStart /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:311 +0x132 ``` tx comes in and CheckTx is executed right when we execute the block ``` goroutine 111044 [semacquire, 309 minutes]: sync.runtime_SemacquireMutex(0xc00003363c, 0x0) /usr/local/go/src/runtime/sema.go:71 +0x3d sync.(*Mutex).Lock(0xc000033638) /usr/local/go/src/sync/mutex.go:134 +0xff github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client.(*localClient).CheckTxAsync(0xc0001fb0e0, 0xc002d94500, 0x13f, 0x280, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client/local_client.go:85 +0x47 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy.(*appConnMempool).CheckTxAsync(0xc00002f720, 0xc002d94500, 0x13f, 0x280, 0x1) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy/app_conn.go:114 +0x51 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/mempool.(*Mempool).CheckTx(0xc002d3a320, 0xc002d94500, 0x13f, 0x280, 0xc0072355f0, 0x0, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/mempool/mempool.go:316 +0x17b github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/core.BroadcastTxSync(0xc002d94500, 0x13f, 0x280, 0x0, 0x0, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/core/mempool.go:93 +0xb8 reflect.Value.call(0xd85560, 0x10326c0, 0x13, 0xec7b8b, 0x4, 0xc00663f180, 0x1, 0x1, 0xc00663f180, 0xc00663f188, ...) /usr/local/go/src/reflect/value.go:447 +0x449 reflect.Value.Call(0xd85560, 0x10326c0, 0x13, 0xc00663f180, 0x1, 0x1, 0x0, 0x0, 0xc005cc9344) /usr/local/go/src/reflect/value.go:308 +0xa4 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server.makeHTTPHandler.func2(0x1102060, 0xc00663f100, 0xc0082d7900) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server/handlers.go:269 +0x188 net/http.HandlerFunc.ServeHTTP(0xc002c81f20, 0x1102060, 0xc00663f100, 0xc0082d7900) /usr/local/go/src/net/http/server.go:1964 +0x44 net/http.(*ServeMux).ServeHTTP(0xc002c81b60, 0x1102060, 0xc00663f100, 0xc0082d7900) /usr/local/go/src/net/http/server.go:2361 +0x127 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server.maxBytesHandler.ServeHTTP(0x10f8a40, 0xc002c81b60, 0xf4240, 0x1102060, 0xc00663f100, 0xc0082d7900) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server/http_server.go:219 +0xcf github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server.RecoverAndLogHandler.func1(0x1103220, 0xc00121e620, 0xc0082d7900) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server/http_server.go:192 +0x394 net/http.HandlerFunc.ServeHTTP(0xc002c06ea0, 0x1103220, 0xc00121e620, 0xc0082d7900) /usr/local/go/src/net/http/server.go:1964 +0x44 net/http.serverHandler.ServeHTTP(0xc001a1aa90, 0x1103220, 0xc00121e620, 0xc0082d7900) /usr/local/go/src/net/http/server.go:2741 +0xab net/http.(*conn).serve(0xc00785a3c0, 0x11041a0, 0xc000f844c0) /usr/local/go/src/net/http/server.go:1847 +0x646 created by net/http.(*Server).Serve /usr/local/go/src/net/http/server.go:2851 +0x2f5 ``` * consensus: use read lock in Receive#VoteMessage * use defer to unlock mutex because application might panic * use defer in every method of the localClient * add a changelog entry * drain channels before Unsubscribe(All) Read https://github.com/tendermint/tendermint/blob/55362ed76630f3e1ebec159a598f6a9fb5892cb1/libs/pubsub/pubsub.go#L13 for the detailed explanation of the issue. We'll need to fix it someday. Make sure to keep an eye on https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-033-pubsub.md * retry instead of panic when peer has no state in reactors other than consensus in /dump_consensus_state RPC endpoint, skip a peer with no state * rpc/core/mempool: simplify error messages * rpc/core/mempool: use time.After instead of timer also, do not log DeliverTx result (to be consistent with other memthods) * unlock before calling the callback in reqRes#SetCallback
6 years ago
p2p: seed mode refactoring (#3011) ListOfKnownAddresses is removed panic if addrbook size is less than zero CrawlPeers does not attempt to connect to existing or peers we're currently dialing various perf. fixes improved tests (though not complete) move IsDialingOrExistingAddress check into DialPeerWithAddress (Fixes #2716) * addrbook: preallocate memory when saving addrbook to file * addrbook: remove oldestFirst struct and check for ID * oldestFirst replaced with sort.Slice * ID is now mandatory, so no need to check * addrbook: remove ListOfKnownAddresses GetSelection is used instead in seed mode. * addrbook: panic if size is less than 0 * rewrite addrbook#saveToFile to not use a counter * test AttemptDisconnects func * move IsDialingOrExistingAddress check into DialPeerWithAddress * save and cleanup crawl peer data * get rid of DefaultSeedDisconnectWaitPeriod * make linter happy * fix TestPEXReactorSeedMode * fix comment * add a changelog entry * Apply suggestions from code review Co-Authored-By: melekes <anton.kalyaev@gmail.com> * rename ErrDialingOrExistingAddress to ErrCurrentlyDialingOrExistingAddress * lowercase errors * do not persist seed data pros: - no extra files - less IO cons: - if the node crashes, seed might crawl a peer too soon * fixes after Ethan's review * add a changelog entry * we should only consult Switch about peers checking addrbook size does not make sense since only PEX reactor uses it for dialing peers! https://github.com/tendermint/tendermint/pull/3011#discussion_r270948875
6 years ago
p2p: seed mode refactoring (#3011) ListOfKnownAddresses is removed panic if addrbook size is less than zero CrawlPeers does not attempt to connect to existing or peers we're currently dialing various perf. fixes improved tests (though not complete) move IsDialingOrExistingAddress check into DialPeerWithAddress (Fixes #2716) * addrbook: preallocate memory when saving addrbook to file * addrbook: remove oldestFirst struct and check for ID * oldestFirst replaced with sort.Slice * ID is now mandatory, so no need to check * addrbook: remove ListOfKnownAddresses GetSelection is used instead in seed mode. * addrbook: panic if size is less than 0 * rewrite addrbook#saveToFile to not use a counter * test AttemptDisconnects func * move IsDialingOrExistingAddress check into DialPeerWithAddress * save and cleanup crawl peer data * get rid of DefaultSeedDisconnectWaitPeriod * make linter happy * fix TestPEXReactorSeedMode * fix comment * add a changelog entry * Apply suggestions from code review Co-Authored-By: melekes <anton.kalyaev@gmail.com> * rename ErrDialingOrExistingAddress to ErrCurrentlyDialingOrExistingAddress * lowercase errors * do not persist seed data pros: - no extra files - less IO cons: - if the node crashes, seed might crawl a peer too soon * fixes after Ethan's review * add a changelog entry * we should only consult Switch about peers checking addrbook size does not make sense since only PEX reactor uses it for dialing peers! https://github.com/tendermint/tendermint/pull/3011#discussion_r270948875
6 years ago
p2p: fix infinite loop in addrbook (#3232) * failing test * fix infinite loop in addrbook There are cases where we only have a small number of addresses marked good ("old"), but the selection mechanism keeps trying to select more of these addresses, and hence ends up in an infinite loop. Here we fix this to only try and select such "old" addresses if we have enough of them. Note this means, if we don't have enough of them, we may return more "new" addresses than otherwise expected by the newSelectionBias. This whole GetSelectionWithBias method probably needs to be rewritten, but this is a quick fix for the issue. * changelog * fix infinite loop if not enough new addrs * fix another potential infinite loop if a.nNew == 0 -> pickFromOldBucket=true, but we don't have enough items (a.nOld > len(oldBucketToAddrsMap) false) * Revert "fix another potential infinite loop" This reverts commit 146540c1125597162bd89820d611f6531f5e5e4b. * check num addresses instead of buckets, new test * fixed the int division * add slack to bias % in test, lint fixes * Added checks for selection content in test * test cleanup * Apply suggestions from code review Co-Authored-By: ebuchman <ethan@coinculture.info> * address review comments * change after Anton's review comments * use the same docker image we use for testing when building a binary for localnet * switch back to circleci classic * more review comments * more review comments * refactor addrbook_test * build linux binary inside docker in attempt to fix ``` --> Running dep + make build-linux GOOS=linux GOARCH=amd64 make build make[1]: Entering directory `/home/circleci/.go_workspace/src/github.com/tendermint/tendermint' CGO_ENABLED=0 go build -ldflags "-X github.com/tendermint/tendermint/version.GitCommit=`git rev-parse --short=8 HEAD`" -tags 'tendermint' -o build/tendermint ./cmd/tendermint/ p2p/pex/addrbook.go:373:13: undefined: math.Round ``` * change dir from /usr to /go * use concrete Go version for localnet binary * check for nil addresses just to be sure
6 years ago
p2p: seed mode refactoring (#3011) ListOfKnownAddresses is removed panic if addrbook size is less than zero CrawlPeers does not attempt to connect to existing or peers we're currently dialing various perf. fixes improved tests (though not complete) move IsDialingOrExistingAddress check into DialPeerWithAddress (Fixes #2716) * addrbook: preallocate memory when saving addrbook to file * addrbook: remove oldestFirst struct and check for ID * oldestFirst replaced with sort.Slice * ID is now mandatory, so no need to check * addrbook: remove ListOfKnownAddresses GetSelection is used instead in seed mode. * addrbook: panic if size is less than 0 * rewrite addrbook#saveToFile to not use a counter * test AttemptDisconnects func * move IsDialingOrExistingAddress check into DialPeerWithAddress * save and cleanup crawl peer data * get rid of DefaultSeedDisconnectWaitPeriod * make linter happy * fix TestPEXReactorSeedMode * fix comment * add a changelog entry * Apply suggestions from code review Co-Authored-By: melekes <anton.kalyaev@gmail.com> * rename ErrDialingOrExistingAddress to ErrCurrentlyDialingOrExistingAddress * lowercase errors * do not persist seed data pros: - no extra files - less IO cons: - if the node crashes, seed might crawl a peer too soon * fixes after Ethan's review * add a changelog entry * we should only consult Switch about peers checking addrbook size does not make sense since only PEX reactor uses it for dialing peers! https://github.com/tendermint/tendermint/pull/3011#discussion_r270948875
6 years ago
p2p: fix infinite loop in addrbook (#3232) * failing test * fix infinite loop in addrbook There are cases where we only have a small number of addresses marked good ("old"), but the selection mechanism keeps trying to select more of these addresses, and hence ends up in an infinite loop. Here we fix this to only try and select such "old" addresses if we have enough of them. Note this means, if we don't have enough of them, we may return more "new" addresses than otherwise expected by the newSelectionBias. This whole GetSelectionWithBias method probably needs to be rewritten, but this is a quick fix for the issue. * changelog * fix infinite loop if not enough new addrs * fix another potential infinite loop if a.nNew == 0 -> pickFromOldBucket=true, but we don't have enough items (a.nOld > len(oldBucketToAddrsMap) false) * Revert "fix another potential infinite loop" This reverts commit 146540c1125597162bd89820d611f6531f5e5e4b. * check num addresses instead of buckets, new test * fixed the int division * add slack to bias % in test, lint fixes * Added checks for selection content in test * test cleanup * Apply suggestions from code review Co-Authored-By: ebuchman <ethan@coinculture.info> * address review comments * change after Anton's review comments * use the same docker image we use for testing when building a binary for localnet * switch back to circleci classic * more review comments * more review comments * refactor addrbook_test * build linux binary inside docker in attempt to fix ``` --> Running dep + make build-linux GOOS=linux GOARCH=amd64 make build make[1]: Entering directory `/home/circleci/.go_workspace/src/github.com/tendermint/tendermint' CGO_ENABLED=0 go build -ldflags "-X github.com/tendermint/tendermint/version.GitCommit=`git rev-parse --short=8 HEAD`" -tags 'tendermint' -o build/tendermint ./cmd/tendermint/ p2p/pex/addrbook.go:373:13: undefined: math.Round ``` * change dir from /usr to /go * use concrete Go version for localnet binary * check for nil addresses just to be sure
6 years ago
p2p: seed mode refactoring (#3011) ListOfKnownAddresses is removed panic if addrbook size is less than zero CrawlPeers does not attempt to connect to existing or peers we're currently dialing various perf. fixes improved tests (though not complete) move IsDialingOrExistingAddress check into DialPeerWithAddress (Fixes #2716) * addrbook: preallocate memory when saving addrbook to file * addrbook: remove oldestFirst struct and check for ID * oldestFirst replaced with sort.Slice * ID is now mandatory, so no need to check * addrbook: remove ListOfKnownAddresses GetSelection is used instead in seed mode. * addrbook: panic if size is less than 0 * rewrite addrbook#saveToFile to not use a counter * test AttemptDisconnects func * move IsDialingOrExistingAddress check into DialPeerWithAddress * save and cleanup crawl peer data * get rid of DefaultSeedDisconnectWaitPeriod * make linter happy * fix TestPEXReactorSeedMode * fix comment * add a changelog entry * Apply suggestions from code review Co-Authored-By: melekes <anton.kalyaev@gmail.com> * rename ErrDialingOrExistingAddress to ErrCurrentlyDialingOrExistingAddress * lowercase errors * do not persist seed data pros: - no extra files - less IO cons: - if the node crashes, seed might crawl a peer too soon * fixes after Ethan's review * add a changelog entry * we should only consult Switch about peers checking addrbook size does not make sense since only PEX reactor uses it for dialing peers! https://github.com/tendermint/tendermint/pull/3011#discussion_r270948875
6 years ago
  1. // Modified for Tendermint
  2. // Originally Copyright (c) 2013-2014 Conformal Systems LLC.
  3. // https://github.com/conformal/btcd/blob/master/LICENSE
  4. package pex
  5. import (
  6. "crypto/sha256"
  7. "encoding/binary"
  8. "fmt"
  9. "math"
  10. "math/rand"
  11. "net"
  12. "sync"
  13. "time"
  14. "github.com/tendermint/tendermint/crypto"
  15. tmmath "github.com/tendermint/tendermint/libs/math"
  16. tmrand "github.com/tendermint/tendermint/libs/rand"
  17. "github.com/tendermint/tendermint/libs/service"
  18. "github.com/tendermint/tendermint/p2p"
  19. )
  20. const (
  21. bucketTypeNew = 0x01
  22. bucketTypeOld = 0x02
  23. )
  24. // AddrBook is an address book used for tracking peers
  25. // so we can gossip about them to others and select
  26. // peers to dial.
  27. // TODO: break this up?
  28. type AddrBook interface {
  29. service.Service
  30. // Add our own addresses so we don't later add ourselves
  31. AddOurAddress(*p2p.NetAddress)
  32. // Check if it is our address
  33. OurAddress(*p2p.NetAddress) bool
  34. AddPrivateIDs([]string)
  35. // Add and remove an address
  36. AddAddress(addr *p2p.NetAddress, src *p2p.NetAddress) error
  37. RemoveAddress(*p2p.NetAddress)
  38. // Check if the address is in the book
  39. HasAddress(*p2p.NetAddress) bool
  40. // Do we need more peers?
  41. NeedMoreAddrs() bool
  42. // Is Address Book Empty? Answer should not depend on being in your own
  43. // address book, or private peers
  44. Empty() bool
  45. // Pick an address to dial
  46. PickAddress(biasTowardsNewAddrs int) *p2p.NetAddress
  47. // Mark address
  48. MarkGood(p2p.ID)
  49. MarkAttempt(*p2p.NetAddress)
  50. MarkBad(*p2p.NetAddress)
  51. IsGood(*p2p.NetAddress) bool
  52. // Send a selection of addresses to peers
  53. GetSelection() []*p2p.NetAddress
  54. // Send a selection of addresses with bias
  55. GetSelectionWithBias(biasTowardsNewAddrs int) []*p2p.NetAddress
  56. Size() int
  57. // Persist to disk
  58. Save()
  59. }
  60. var _ AddrBook = (*addrBook)(nil)
  61. // addrBook - concurrency safe peer address manager.
  62. // Implements AddrBook.
  63. type addrBook struct {
  64. service.BaseService
  65. // accessed concurrently
  66. mtx sync.Mutex
  67. rand *tmrand.Rand
  68. ourAddrs map[string]struct{}
  69. privateIDs map[p2p.ID]struct{}
  70. addrLookup map[p2p.ID]*knownAddress // new & old
  71. bucketsOld []map[string]*knownAddress
  72. bucketsNew []map[string]*knownAddress
  73. nOld int
  74. nNew int
  75. // immutable after creation
  76. filePath string
  77. key string // random prefix for bucket placement
  78. routabilityStrict bool
  79. wg sync.WaitGroup
  80. }
  81. // NewAddrBook creates a new address book.
  82. // Use Start to begin processing asynchronous address updates.
  83. func NewAddrBook(filePath string, routabilityStrict bool) AddrBook {
  84. am := &addrBook{
  85. rand: tmrand.NewRand(),
  86. ourAddrs: make(map[string]struct{}),
  87. privateIDs: make(map[p2p.ID]struct{}),
  88. addrLookup: make(map[p2p.ID]*knownAddress),
  89. filePath: filePath,
  90. routabilityStrict: routabilityStrict,
  91. }
  92. am.init()
  93. am.BaseService = *service.NewBaseService(nil, "AddrBook", am)
  94. return am
  95. }
  96. // Initialize the buckets.
  97. // When modifying this, don't forget to update loadFromFile()
  98. func (a *addrBook) init() {
  99. a.key = crypto.CRandHex(24) // 24/2 * 8 = 96 bits
  100. // New addr buckets
  101. a.bucketsNew = make([]map[string]*knownAddress, newBucketCount)
  102. for i := range a.bucketsNew {
  103. a.bucketsNew[i] = make(map[string]*knownAddress)
  104. }
  105. // Old addr buckets
  106. a.bucketsOld = make([]map[string]*knownAddress, oldBucketCount)
  107. for i := range a.bucketsOld {
  108. a.bucketsOld[i] = make(map[string]*knownAddress)
  109. }
  110. }
  111. // OnStart implements Service.
  112. func (a *addrBook) OnStart() error {
  113. if err := a.BaseService.OnStart(); err != nil {
  114. return err
  115. }
  116. a.loadFromFile(a.filePath)
  117. // wg.Add to ensure that any invocation of .Wait()
  118. // later on will wait for saveRoutine to terminate.
  119. a.wg.Add(1)
  120. go a.saveRoutine()
  121. return nil
  122. }
  123. // OnStop implements Service.
  124. func (a *addrBook) OnStop() {
  125. a.BaseService.OnStop()
  126. }
  127. func (a *addrBook) Wait() {
  128. a.wg.Wait()
  129. }
  130. func (a *addrBook) FilePath() string {
  131. return a.filePath
  132. }
  133. //-------------------------------------------------------
  134. // AddOurAddress one of our addresses.
  135. func (a *addrBook) AddOurAddress(addr *p2p.NetAddress) {
  136. a.mtx.Lock()
  137. defer a.mtx.Unlock()
  138. a.Logger.Info("Add our address to book", "addr", addr)
  139. a.ourAddrs[addr.String()] = struct{}{}
  140. }
  141. // OurAddress returns true if it is our address.
  142. func (a *addrBook) OurAddress(addr *p2p.NetAddress) bool {
  143. a.mtx.Lock()
  144. defer a.mtx.Unlock()
  145. _, ok := a.ourAddrs[addr.String()]
  146. return ok
  147. }
  148. func (a *addrBook) AddPrivateIDs(ids []string) {
  149. a.mtx.Lock()
  150. defer a.mtx.Unlock()
  151. for _, id := range ids {
  152. a.privateIDs[p2p.ID(id)] = struct{}{}
  153. }
  154. }
  155. // AddAddress implements AddrBook
  156. // Add address to a "new" bucket. If it's already in one, only add it probabilistically.
  157. // Returns error if the addr is non-routable. Does not add self.
  158. // NOTE: addr must not be nil
  159. func (a *addrBook) AddAddress(addr *p2p.NetAddress, src *p2p.NetAddress) error {
  160. a.mtx.Lock()
  161. defer a.mtx.Unlock()
  162. return a.addAddress(addr, src)
  163. }
  164. // RemoveAddress implements AddrBook - removes the address from the book.
  165. func (a *addrBook) RemoveAddress(addr *p2p.NetAddress) {
  166. a.mtx.Lock()
  167. defer a.mtx.Unlock()
  168. ka := a.addrLookup[addr.ID]
  169. if ka == nil {
  170. return
  171. }
  172. a.Logger.Info("Remove address from book", "addr", addr)
  173. a.removeFromAllBuckets(ka)
  174. }
  175. // IsGood returns true if peer was ever marked as good and haven't
  176. // done anything wrong since then.
  177. func (a *addrBook) IsGood(addr *p2p.NetAddress) bool {
  178. a.mtx.Lock()
  179. defer a.mtx.Unlock()
  180. return a.addrLookup[addr.ID].isOld()
  181. }
  182. // HasAddress returns true if the address is in the book.
  183. func (a *addrBook) HasAddress(addr *p2p.NetAddress) bool {
  184. a.mtx.Lock()
  185. defer a.mtx.Unlock()
  186. ka := a.addrLookup[addr.ID]
  187. return ka != nil
  188. }
  189. // NeedMoreAddrs implements AddrBook - returns true if there are not have enough addresses in the book.
  190. func (a *addrBook) NeedMoreAddrs() bool {
  191. return a.Size() < needAddressThreshold
  192. }
  193. // Empty implements AddrBook - returns true if there are no addresses in the address book.
  194. // Does not count the peer appearing in its own address book, or private peers.
  195. func (a *addrBook) Empty() bool {
  196. return a.Size() == 0
  197. }
  198. // PickAddress implements AddrBook. It picks an address to connect to.
  199. // The address is picked randomly from an old or new bucket according
  200. // to the biasTowardsNewAddrs argument, which must be between [0, 100] (or else is truncated to that range)
  201. // and determines how biased we are to pick an address from a new bucket.
  202. // PickAddress returns nil if the AddrBook is empty or if we try to pick
  203. // from an empty bucket.
  204. func (a *addrBook) PickAddress(biasTowardsNewAddrs int) *p2p.NetAddress {
  205. a.mtx.Lock()
  206. defer a.mtx.Unlock()
  207. bookSize := a.size()
  208. if bookSize <= 0 {
  209. if bookSize < 0 {
  210. panic(fmt.Sprintf("Addrbook size %d (new: %d + old: %d) is less than 0", a.nNew+a.nOld, a.nNew, a.nOld))
  211. }
  212. return nil
  213. }
  214. if biasTowardsNewAddrs > 100 {
  215. biasTowardsNewAddrs = 100
  216. }
  217. if biasTowardsNewAddrs < 0 {
  218. biasTowardsNewAddrs = 0
  219. }
  220. // Bias between new and old addresses.
  221. oldCorrelation := math.Sqrt(float64(a.nOld)) * (100.0 - float64(biasTowardsNewAddrs))
  222. newCorrelation := math.Sqrt(float64(a.nNew)) * float64(biasTowardsNewAddrs)
  223. // pick a random peer from a random bucket
  224. var bucket map[string]*knownAddress
  225. pickFromOldBucket := (newCorrelation+oldCorrelation)*a.rand.Float64() < oldCorrelation
  226. if (pickFromOldBucket && a.nOld == 0) ||
  227. (!pickFromOldBucket && a.nNew == 0) {
  228. return nil
  229. }
  230. // loop until we pick a random non-empty bucket
  231. for len(bucket) == 0 {
  232. if pickFromOldBucket {
  233. bucket = a.bucketsOld[a.rand.Intn(len(a.bucketsOld))]
  234. } else {
  235. bucket = a.bucketsNew[a.rand.Intn(len(a.bucketsNew))]
  236. }
  237. }
  238. // pick a random index and loop over the map to return that index
  239. randIndex := a.rand.Intn(len(bucket))
  240. for _, ka := range bucket {
  241. if randIndex == 0 {
  242. return ka.Addr
  243. }
  244. randIndex--
  245. }
  246. return nil
  247. }
  248. // MarkGood implements AddrBook - it marks the peer as good and
  249. // moves it into an "old" bucket.
  250. func (a *addrBook) MarkGood(id p2p.ID) {
  251. a.mtx.Lock()
  252. defer a.mtx.Unlock()
  253. ka := a.addrLookup[id]
  254. if ka == nil {
  255. return
  256. }
  257. ka.markGood()
  258. if ka.isNew() {
  259. a.moveToOld(ka)
  260. }
  261. }
  262. // MarkAttempt implements AddrBook - it marks that an attempt was made to connect to the address.
  263. func (a *addrBook) MarkAttempt(addr *p2p.NetAddress) {
  264. a.mtx.Lock()
  265. defer a.mtx.Unlock()
  266. ka := a.addrLookup[addr.ID]
  267. if ka == nil {
  268. return
  269. }
  270. ka.markAttempt()
  271. }
  272. // MarkBad implements AddrBook. Currently it just ejects the address.
  273. // TODO: black list for some amount of time
  274. func (a *addrBook) MarkBad(addr *p2p.NetAddress) {
  275. a.RemoveAddress(addr)
  276. }
  277. // GetSelection implements AddrBook.
  278. // It randomly selects some addresses (old & new). Suitable for peer-exchange protocols.
  279. // Must never return a nil address.
  280. func (a *addrBook) GetSelection() []*p2p.NetAddress {
  281. a.mtx.Lock()
  282. defer a.mtx.Unlock()
  283. bookSize := a.size()
  284. if bookSize <= 0 {
  285. if bookSize < 0 {
  286. panic(fmt.Sprintf("Addrbook size %d (new: %d + old: %d) is less than 0", a.nNew+a.nOld, a.nNew, a.nOld))
  287. }
  288. return nil
  289. }
  290. numAddresses := tmmath.MaxInt(
  291. tmmath.MinInt(minGetSelection, bookSize),
  292. bookSize*getSelectionPercent/100)
  293. numAddresses = tmmath.MinInt(maxGetSelection, numAddresses)
  294. // XXX: instead of making a list of all addresses, shuffling, and slicing a random chunk,
  295. // could we just select a random numAddresses of indexes?
  296. allAddr := make([]*p2p.NetAddress, bookSize)
  297. i := 0
  298. for _, ka := range a.addrLookup {
  299. allAddr[i] = ka.Addr
  300. i++
  301. }
  302. // Fisher-Yates shuffle the array. We only need to do the first
  303. // `numAddresses' since we are throwing the rest.
  304. for i := 0; i < numAddresses; i++ {
  305. // pick a number between current index and the end
  306. j := tmrand.Intn(len(allAddr)-i) + i
  307. allAddr[i], allAddr[j] = allAddr[j], allAddr[i]
  308. }
  309. // slice off the limit we are willing to share.
  310. return allAddr[:numAddresses]
  311. }
  312. func percentageOfNum(p, n int) int {
  313. return int(math.Round((float64(p) / float64(100)) * float64(n)))
  314. }
  315. // GetSelectionWithBias implements AddrBook.
  316. // It randomly selects some addresses (old & new). Suitable for peer-exchange protocols.
  317. // Must never return a nil address.
  318. //
  319. // Each address is picked randomly from an old or new bucket according to the
  320. // biasTowardsNewAddrs argument, which must be between [0, 100] (or else is truncated to
  321. // that range) and determines how biased we are to pick an address from a new
  322. // bucket.
  323. func (a *addrBook) GetSelectionWithBias(biasTowardsNewAddrs int) []*p2p.NetAddress {
  324. a.mtx.Lock()
  325. defer a.mtx.Unlock()
  326. bookSize := a.size()
  327. if bookSize <= 0 {
  328. if bookSize < 0 {
  329. panic(fmt.Sprintf("Addrbook size %d (new: %d + old: %d) is less than 0", a.nNew+a.nOld, a.nNew, a.nOld))
  330. }
  331. return nil
  332. }
  333. if biasTowardsNewAddrs > 100 {
  334. biasTowardsNewAddrs = 100
  335. }
  336. if biasTowardsNewAddrs < 0 {
  337. biasTowardsNewAddrs = 0
  338. }
  339. numAddresses := tmmath.MaxInt(
  340. tmmath.MinInt(minGetSelection, bookSize),
  341. bookSize*getSelectionPercent/100)
  342. numAddresses = tmmath.MinInt(maxGetSelection, numAddresses)
  343. // number of new addresses that, if possible, should be in the beginning of the selection
  344. // if there are no enough old addrs, will choose new addr instead.
  345. numRequiredNewAdd := tmmath.MaxInt(percentageOfNum(biasTowardsNewAddrs, numAddresses), numAddresses-a.nOld)
  346. selection := a.randomPickAddresses(bucketTypeNew, numRequiredNewAdd)
  347. selection = append(selection, a.randomPickAddresses(bucketTypeOld, numAddresses-len(selection))...)
  348. return selection
  349. }
  350. //------------------------------------------------
  351. // Size returns the number of addresses in the book.
  352. func (a *addrBook) Size() int {
  353. a.mtx.Lock()
  354. defer a.mtx.Unlock()
  355. return a.size()
  356. }
  357. func (a *addrBook) size() int {
  358. return a.nNew + a.nOld
  359. }
  360. //----------------------------------------------------------
  361. // Save persists the address book to disk.
  362. func (a *addrBook) Save() {
  363. a.saveToFile(a.filePath) // thread safe
  364. }
  365. func (a *addrBook) saveRoutine() {
  366. defer a.wg.Done()
  367. saveFileTicker := time.NewTicker(dumpAddressInterval)
  368. out:
  369. for {
  370. select {
  371. case <-saveFileTicker.C:
  372. a.saveToFile(a.filePath)
  373. case <-a.Quit():
  374. break out
  375. }
  376. }
  377. saveFileTicker.Stop()
  378. a.saveToFile(a.filePath)
  379. }
  380. //----------------------------------------------------------
  381. func (a *addrBook) getBucket(bucketType byte, bucketIdx int) map[string]*knownAddress {
  382. switch bucketType {
  383. case bucketTypeNew:
  384. return a.bucketsNew[bucketIdx]
  385. case bucketTypeOld:
  386. return a.bucketsOld[bucketIdx]
  387. default:
  388. panic("Invalid bucket type")
  389. }
  390. }
  391. // Adds ka to new bucket. Returns false if it couldn't do it cuz buckets full.
  392. // NOTE: currently it always returns true.
  393. func (a *addrBook) addToNewBucket(ka *knownAddress, bucketIdx int) {
  394. // Sanity check
  395. if ka.isOld() {
  396. a.Logger.Error("Failed Sanity Check! Cant add old address to new bucket", "ka", ka, "bucket", bucketIdx)
  397. return
  398. }
  399. addrStr := ka.Addr.String()
  400. bucket := a.getBucket(bucketTypeNew, bucketIdx)
  401. // Already exists?
  402. if _, ok := bucket[addrStr]; ok {
  403. return
  404. }
  405. // Enforce max addresses.
  406. if len(bucket) > newBucketSize {
  407. a.Logger.Info("new bucket is full, expiring new")
  408. a.expireNew(bucketIdx)
  409. }
  410. // Add to bucket.
  411. bucket[addrStr] = ka
  412. // increment nNew if the peer doesnt already exist in a bucket
  413. if ka.addBucketRef(bucketIdx) == 1 {
  414. a.nNew++
  415. }
  416. // Add it to addrLookup
  417. a.addrLookup[ka.ID()] = ka
  418. }
  419. // Adds ka to old bucket. Returns false if it couldn't do it cuz buckets full.
  420. func (a *addrBook) addToOldBucket(ka *knownAddress, bucketIdx int) bool {
  421. // Sanity check
  422. if ka.isNew() {
  423. a.Logger.Error(fmt.Sprintf("Cannot add new address to old bucket: %v", ka))
  424. return false
  425. }
  426. if len(ka.Buckets) != 0 {
  427. a.Logger.Error(fmt.Sprintf("Cannot add already old address to another old bucket: %v", ka))
  428. return false
  429. }
  430. addrStr := ka.Addr.String()
  431. bucket := a.getBucket(bucketTypeOld, bucketIdx)
  432. // Already exists?
  433. if _, ok := bucket[addrStr]; ok {
  434. return true
  435. }
  436. // Enforce max addresses.
  437. if len(bucket) > oldBucketSize {
  438. return false
  439. }
  440. // Add to bucket.
  441. bucket[addrStr] = ka
  442. if ka.addBucketRef(bucketIdx) == 1 {
  443. a.nOld++
  444. }
  445. // Ensure in addrLookup
  446. a.addrLookup[ka.ID()] = ka
  447. return true
  448. }
  449. func (a *addrBook) removeFromBucket(ka *knownAddress, bucketType byte, bucketIdx int) {
  450. if ka.BucketType != bucketType {
  451. a.Logger.Error(fmt.Sprintf("Bucket type mismatch: %v", ka))
  452. return
  453. }
  454. bucket := a.getBucket(bucketType, bucketIdx)
  455. delete(bucket, ka.Addr.String())
  456. if ka.removeBucketRef(bucketIdx) == 0 {
  457. if bucketType == bucketTypeNew {
  458. a.nNew--
  459. } else {
  460. a.nOld--
  461. }
  462. delete(a.addrLookup, ka.ID())
  463. }
  464. }
  465. func (a *addrBook) removeFromAllBuckets(ka *knownAddress) {
  466. for _, bucketIdx := range ka.Buckets {
  467. bucket := a.getBucket(ka.BucketType, bucketIdx)
  468. delete(bucket, ka.Addr.String())
  469. }
  470. ka.Buckets = nil
  471. if ka.BucketType == bucketTypeNew {
  472. a.nNew--
  473. } else {
  474. a.nOld--
  475. }
  476. delete(a.addrLookup, ka.ID())
  477. }
  478. //----------------------------------------------------------
  479. func (a *addrBook) pickOldest(bucketType byte, bucketIdx int) *knownAddress {
  480. bucket := a.getBucket(bucketType, bucketIdx)
  481. var oldest *knownAddress
  482. for _, ka := range bucket {
  483. if oldest == nil || ka.LastAttempt.Before(oldest.LastAttempt) {
  484. oldest = ka
  485. }
  486. }
  487. return oldest
  488. }
  489. // adds the address to a "new" bucket. if its already in one,
  490. // it only adds it probabilistically
  491. func (a *addrBook) addAddress(addr, src *p2p.NetAddress) error {
  492. if addr == nil || src == nil {
  493. return ErrAddrBookNilAddr{addr, src}
  494. }
  495. if err := addr.Valid(); err != nil {
  496. return ErrAddrBookInvalidAddr{Addr: addr, AddrErr: err}
  497. }
  498. if _, ok := a.privateIDs[addr.ID]; ok {
  499. return ErrAddrBookPrivate{addr}
  500. }
  501. if _, ok := a.privateIDs[src.ID]; ok {
  502. return ErrAddrBookPrivateSrc{src}
  503. }
  504. // TODO: we should track ourAddrs by ID and by IP:PORT and refuse both.
  505. if _, ok := a.ourAddrs[addr.String()]; ok {
  506. return ErrAddrBookSelf{addr}
  507. }
  508. if a.routabilityStrict && !addr.Routable() {
  509. return ErrAddrBookNonRoutable{addr}
  510. }
  511. ka := a.addrLookup[addr.ID]
  512. if ka != nil {
  513. // If its already old and the addr is the same, ignore it.
  514. if ka.isOld() && ka.Addr.Equals(addr) {
  515. return nil
  516. }
  517. // Already in max new buckets.
  518. if len(ka.Buckets) == maxNewBucketsPerAddress {
  519. return nil
  520. }
  521. // The more entries we have, the less likely we are to add more.
  522. factor := int32(2 * len(ka.Buckets))
  523. if a.rand.Int31n(factor) != 0 {
  524. return nil
  525. }
  526. } else {
  527. ka = newKnownAddress(addr, src)
  528. }
  529. bucket := a.calcNewBucket(addr, src)
  530. a.addToNewBucket(ka, bucket)
  531. return nil
  532. }
  533. func (a *addrBook) randomPickAddresses(bucketType byte, num int) []*p2p.NetAddress {
  534. var buckets []map[string]*knownAddress
  535. switch bucketType {
  536. case bucketTypeNew:
  537. buckets = a.bucketsNew
  538. case bucketTypeOld:
  539. buckets = a.bucketsOld
  540. default:
  541. panic("unexpected bucketType")
  542. }
  543. total := 0
  544. for _, bucket := range buckets {
  545. total += len(bucket)
  546. }
  547. addresses := make([]*knownAddress, 0, total)
  548. for _, bucket := range buckets {
  549. for _, ka := range bucket {
  550. addresses = append(addresses, ka)
  551. }
  552. }
  553. selection := make([]*p2p.NetAddress, 0, num)
  554. chosenSet := make(map[string]bool, num)
  555. rand.Shuffle(total, func(i, j int) {
  556. addresses[i], addresses[j] = addresses[j], addresses[i]
  557. })
  558. for _, addr := range addresses {
  559. if chosenSet[addr.Addr.String()] {
  560. continue
  561. }
  562. chosenSet[addr.Addr.String()] = true
  563. selection = append(selection, addr.Addr)
  564. if len(selection) >= num {
  565. return selection
  566. }
  567. }
  568. return selection
  569. }
  570. // Make space in the new buckets by expiring the really bad entries.
  571. // If no bad entries are available we remove the oldest.
  572. func (a *addrBook) expireNew(bucketIdx int) {
  573. for addrStr, ka := range a.bucketsNew[bucketIdx] {
  574. // If an entry is bad, throw it away
  575. if ka.isBad() {
  576. a.Logger.Info(fmt.Sprintf("expiring bad address %v", addrStr))
  577. a.removeFromBucket(ka, bucketTypeNew, bucketIdx)
  578. return
  579. }
  580. }
  581. // If we haven't thrown out a bad entry, throw out the oldest entry
  582. oldest := a.pickOldest(bucketTypeNew, bucketIdx)
  583. a.removeFromBucket(oldest, bucketTypeNew, bucketIdx)
  584. }
  585. // Promotes an address from new to old. If the destination bucket is full,
  586. // demote the oldest one to a "new" bucket.
  587. // TODO: Demote more probabilistically?
  588. func (a *addrBook) moveToOld(ka *knownAddress) {
  589. // Sanity check
  590. if ka.isOld() {
  591. a.Logger.Error(fmt.Sprintf("Cannot promote address that is already old %v", ka))
  592. return
  593. }
  594. if len(ka.Buckets) == 0 {
  595. a.Logger.Error(fmt.Sprintf("Cannot promote address that isn't in any new buckets %v", ka))
  596. return
  597. }
  598. // Remove from all (new) buckets.
  599. a.removeFromAllBuckets(ka)
  600. // It's officially old now.
  601. ka.BucketType = bucketTypeOld
  602. // Try to add it to its oldBucket destination.
  603. oldBucketIdx := a.calcOldBucket(ka.Addr)
  604. added := a.addToOldBucket(ka, oldBucketIdx)
  605. if !added {
  606. // No room; move the oldest to a new bucket
  607. oldest := a.pickOldest(bucketTypeOld, oldBucketIdx)
  608. a.removeFromBucket(oldest, bucketTypeOld, oldBucketIdx)
  609. newBucketIdx := a.calcNewBucket(oldest.Addr, oldest.Src)
  610. a.addToNewBucket(oldest, newBucketIdx)
  611. // Finally, add our ka to old bucket again.
  612. added = a.addToOldBucket(ka, oldBucketIdx)
  613. if !added {
  614. a.Logger.Error(fmt.Sprintf("Could not re-add ka %v to oldBucketIdx %v", ka, oldBucketIdx))
  615. }
  616. }
  617. }
  618. //---------------------------------------------------------------------
  619. // calculate bucket placements
  620. // doublesha256( key + sourcegroup +
  621. // int64(doublesha256(key + group + sourcegroup))%bucket_per_group ) % num_new_buckets
  622. func (a *addrBook) calcNewBucket(addr, src *p2p.NetAddress) int {
  623. data1 := []byte{}
  624. data1 = append(data1, []byte(a.key)...)
  625. data1 = append(data1, []byte(a.groupKey(addr))...)
  626. data1 = append(data1, []byte(a.groupKey(src))...)
  627. hash1 := doubleSha256(data1)
  628. hash64 := binary.BigEndian.Uint64(hash1)
  629. hash64 %= newBucketsPerGroup
  630. var hashbuf [8]byte
  631. binary.BigEndian.PutUint64(hashbuf[:], hash64)
  632. data2 := []byte{}
  633. data2 = append(data2, []byte(a.key)...)
  634. data2 = append(data2, a.groupKey(src)...)
  635. data2 = append(data2, hashbuf[:]...)
  636. hash2 := doubleSha256(data2)
  637. return int(binary.BigEndian.Uint64(hash2) % newBucketCount)
  638. }
  639. // doublesha256( key + group +
  640. // int64(doublesha256(key + addr))%buckets_per_group ) % num_old_buckets
  641. func (a *addrBook) calcOldBucket(addr *p2p.NetAddress) int {
  642. data1 := []byte{}
  643. data1 = append(data1, []byte(a.key)...)
  644. data1 = append(data1, []byte(addr.String())...)
  645. hash1 := doubleSha256(data1)
  646. hash64 := binary.BigEndian.Uint64(hash1)
  647. hash64 %= oldBucketsPerGroup
  648. var hashbuf [8]byte
  649. binary.BigEndian.PutUint64(hashbuf[:], hash64)
  650. data2 := []byte{}
  651. data2 = append(data2, []byte(a.key)...)
  652. data2 = append(data2, a.groupKey(addr)...)
  653. data2 = append(data2, hashbuf[:]...)
  654. hash2 := doubleSha256(data2)
  655. return int(binary.BigEndian.Uint64(hash2) % oldBucketCount)
  656. }
  657. // Return a string representing the network group of this address.
  658. // This is the /16 for IPv4, the /32 (/36 for he.net) for IPv6, the string
  659. // "local" for a local address and the string "unroutable" for an unroutable
  660. // address.
  661. func (a *addrBook) groupKey(na *p2p.NetAddress) string {
  662. if a.routabilityStrict && na.Local() {
  663. return "local"
  664. }
  665. if a.routabilityStrict && !na.Routable() {
  666. return "unroutable"
  667. }
  668. if ipv4 := na.IP.To4(); ipv4 != nil {
  669. return (&net.IPNet{IP: na.IP, Mask: net.CIDRMask(16, 32)}).String()
  670. }
  671. if na.RFC6145() || na.RFC6052() {
  672. // last four bytes are the ip address
  673. ip := na.IP[12:16]
  674. return (&net.IPNet{IP: ip, Mask: net.CIDRMask(16, 32)}).String()
  675. }
  676. if na.RFC3964() {
  677. ip := na.IP[2:7]
  678. return (&net.IPNet{IP: ip, Mask: net.CIDRMask(16, 32)}).String()
  679. }
  680. if na.RFC4380() {
  681. // teredo tunnels have the last 4 bytes as the v4 address XOR
  682. // 0xff.
  683. ip := net.IP(make([]byte, 4))
  684. for i, byte := range na.IP[12:16] {
  685. ip[i] = byte ^ 0xff
  686. }
  687. return (&net.IPNet{IP: ip, Mask: net.CIDRMask(16, 32)}).String()
  688. }
  689. // OK, so now we know ourselves to be a IPv6 address.
  690. // bitcoind uses /32 for everything, except for Hurricane Electric's
  691. // (he.net) IP range, which it uses /36 for.
  692. bits := 32
  693. heNet := &net.IPNet{IP: net.ParseIP("2001:470::"),
  694. Mask: net.CIDRMask(32, 128)}
  695. if heNet.Contains(na.IP) {
  696. bits = 36
  697. }
  698. return (&net.IPNet{IP: na.IP, Mask: net.CIDRMask(bits, 128)}).String()
  699. }
  700. // doubleSha256 calculates sha256(sha256(b)) and returns the resulting bytes.
  701. func doubleSha256(b []byte) []byte {
  702. hasher := sha256.New()
  703. hasher.Write(b) // nolint:errcheck
  704. sum := hasher.Sum(nil)
  705. hasher.Reset()
  706. hasher.Write(sum) // nolint:errcheck
  707. return hasher.Sum(nil)
  708. }