github.com/daeglee/go-ethereum@v0.0.0-20190504220456-cad3e8d18e9b/les/helper_test.go (about) 1 // Copyright 2016 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 // This file contains some shares testing functionality, common to multiple 18 // different files and modules being tested. 19 20 package les 21 22 import ( 23 "crypto/rand" 24 "math/big" 25 "sync" 26 "testing" 27 "time" 28 29 "github.com/ethereum/go-ethereum/common" 30 "github.com/ethereum/go-ethereum/common/mclock" 31 "github.com/ethereum/go-ethereum/consensus/ethash" 32 "github.com/ethereum/go-ethereum/core" 33 "github.com/ethereum/go-ethereum/core/rawdb" 34 "github.com/ethereum/go-ethereum/core/types" 35 "github.com/ethereum/go-ethereum/core/vm" 36 "github.com/ethereum/go-ethereum/crypto" 37 "github.com/ethereum/go-ethereum/eth" 38 "github.com/ethereum/go-ethereum/ethdb" 39 "github.com/ethereum/go-ethereum/event" 40 "github.com/ethereum/go-ethereum/les/flowcontrol" 41 "github.com/ethereum/go-ethereum/light" 42 "github.com/ethereum/go-ethereum/p2p" 43 "github.com/ethereum/go-ethereum/p2p/enode" 44 "github.com/ethereum/go-ethereum/params" 45 ) 46 47 var ( 48 testBankKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") 49 testBankAddress = crypto.PubkeyToAddress(testBankKey.PublicKey) 50 testBankFunds = big.NewInt(1000000000000000000) 51 52 acc1Key, _ = crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a") 53 acc2Key, _ = crypto.HexToECDSA("49a7b37aa6f6645917e7b807e9d1c00d4fa71f18343b0d4122a4d2df64dd6fee") 54 acc1Addr = crypto.PubkeyToAddress(acc1Key.PublicKey) 55 acc2Addr = crypto.PubkeyToAddress(acc2Key.PublicKey) 56 57 testContractCode = common.Hex2Bytes("606060405260cc8060106000396000f360606040526000357c01000000000000000000000000000000000000000000000000000000009004806360cd2685146041578063c16431b914606b57603f565b005b6055600480803590602001909190505060a9565b6040518082815260200191505060405180910390f35b60886004808035906020019091908035906020019091905050608a565b005b80600060005083606481101560025790900160005b50819055505b5050565b6000600060005082606481101560025790900160005b5054905060c7565b91905056") 58 testContractAddr common.Address 59 testContractCodeDeployed = testContractCode[16:] 60 testContractDeployed = uint64(2) 61 62 testEventEmitterCode = common.Hex2Bytes("60606040523415600e57600080fd5b7f57050ab73f6b9ebdd9f76b8d4997793f48cf956e965ee070551b9ca0bb71584e60405160405180910390a160358060476000396000f3006060604052600080fd00a165627a7a723058203f727efcad8b5811f8cb1fc2620ce5e8c63570d697aef968172de296ea3994140029") 63 testEventEmitterAddr common.Address 64 65 testBufLimit = uint64(100) 66 ) 67 68 /* 69 contract test { 70 71 uint256[100] data; 72 73 function Put(uint256 addr, uint256 value) { 74 data[addr] = value; 75 } 76 77 function Get(uint256 addr) constant returns (uint256 value) { 78 return data[addr]; 79 } 80 } 81 */ 82 83 func testChainGen(i int, block *core.BlockGen) { 84 signer := types.HomesteadSigner{} 85 86 switch i { 87 case 0: 88 // In block 1, the test bank sends account #1 some ether. 89 tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), signer, testBankKey) 90 block.AddTx(tx) 91 case 1: 92 // In block 2, the test bank sends some more ether to account #1. 93 // acc1Addr passes it on to account #2. 94 // acc1Addr creates a test contract. 95 // acc1Addr creates a test event. 96 nonce := block.TxNonce(acc1Addr) 97 98 tx1, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, testBankKey) 99 tx2, _ := types.SignTx(types.NewTransaction(nonce, acc2Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, acc1Key) 100 tx3, _ := types.SignTx(types.NewContractCreation(nonce+1, big.NewInt(0), 200000, big.NewInt(0), testContractCode), signer, acc1Key) 101 testContractAddr = crypto.CreateAddress(acc1Addr, nonce+1) 102 tx4, _ := types.SignTx(types.NewContractCreation(nonce+2, big.NewInt(0), 200000, big.NewInt(0), testEventEmitterCode), signer, acc1Key) 103 testEventEmitterAddr = crypto.CreateAddress(acc1Addr, nonce+2) 104 block.AddTx(tx1) 105 block.AddTx(tx2) 106 block.AddTx(tx3) 107 block.AddTx(tx4) 108 case 2: 109 // Block 3 is empty but was mined by account #2. 110 block.SetCoinbase(acc2Addr) 111 block.SetExtra([]byte("yeehaw")) 112 data := common.Hex2Bytes("C16431B900000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001") 113 tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), 100000, nil, data), signer, testBankKey) 114 block.AddTx(tx) 115 case 3: 116 // Block 4 includes blocks 2 and 3 as uncle headers (with modified extra data). 117 b2 := block.PrevBlock(1).Header() 118 b2.Extra = []byte("foo") 119 block.AddUncle(b2) 120 b3 := block.PrevBlock(2).Header() 121 b3.Extra = []byte("foo") 122 block.AddUncle(b3) 123 data := common.Hex2Bytes("C16431B900000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002") 124 tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), 100000, nil, data), signer, testBankKey) 125 block.AddTx(tx) 126 } 127 } 128 129 // testIndexers creates a set of indexers with specified params for testing purpose. 130 func testIndexers(db ethdb.Database, odr light.OdrBackend, iConfig *light.IndexerConfig) (*core.ChainIndexer, *core.ChainIndexer, *core.ChainIndexer) { 131 chtIndexer := light.NewChtIndexer(db, odr, iConfig.ChtSize, iConfig.ChtConfirms) 132 bloomIndexer := eth.NewBloomIndexer(db, iConfig.BloomSize, iConfig.BloomConfirms) 133 bloomTrieIndexer := light.NewBloomTrieIndexer(db, odr, iConfig.BloomSize, iConfig.BloomTrieSize) 134 bloomIndexer.AddChildIndexer(bloomTrieIndexer) 135 return chtIndexer, bloomIndexer, bloomTrieIndexer 136 } 137 138 // newTestProtocolManager creates a new protocol manager for testing purposes, 139 // with the given number of blocks already known, potential notification 140 // channels for different events and relative chain indexers array. 141 func newTestProtocolManager(lightSync bool, blocks int, generator func(int, *core.BlockGen), odr *LesOdr, peers *peerSet, db ethdb.Database, ulcConfig *eth.ULCConfig) (*ProtocolManager, error) { 142 var ( 143 evmux = new(event.TypeMux) 144 engine = ethash.NewFaker() 145 gspec = core.Genesis{ 146 Config: params.TestChainConfig, 147 Alloc: core.GenesisAlloc{testBankAddress: {Balance: testBankFunds}}, 148 } 149 genesis = gspec.MustCommit(db) 150 chain BlockChain 151 ) 152 if peers == nil { 153 peers = newPeerSet() 154 } 155 156 if lightSync { 157 chain, _ = light.NewLightChain(odr, gspec.Config, engine) 158 } else { 159 blockchain, _ := core.NewBlockChain(db, nil, gspec.Config, engine, vm.Config{}, nil) 160 gchain, _ := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, blocks, generator) 161 if _, err := blockchain.InsertChain(gchain); err != nil { 162 panic(err) 163 } 164 chain = blockchain 165 } 166 167 indexConfig := light.TestServerIndexerConfig 168 if lightSync { 169 indexConfig = light.TestClientIndexerConfig 170 } 171 pm, err := NewProtocolManager(gspec.Config, indexConfig, lightSync, NetworkId, evmux, engine, peers, chain, nil, db, odr, nil, nil, make(chan struct{}), new(sync.WaitGroup), ulcConfig) 172 if err != nil { 173 return nil, err 174 } 175 if !lightSync { 176 srv := &LesServer{lesCommons: lesCommons{protocolManager: pm}} 177 pm.server = srv 178 pm.servingQueue.setThreads(4) 179 180 srv.defParams = flowcontrol.ServerParams{ 181 BufLimit: testBufLimit, 182 MinRecharge: 1, 183 } 184 185 srv.fcManager = flowcontrol.NewClientManager(nil, &mclock.System{}) 186 } 187 pm.Start(1000) 188 return pm, nil 189 } 190 191 // newTestProtocolManagerMust creates a new protocol manager for testing purposes, 192 // with the given number of blocks already known, potential notification 193 // channels for different events and relative chain indexers array. In case of an error, the constructor force- 194 // fails the test. 195 func newTestProtocolManagerMust(t *testing.T, lightSync bool, blocks int, generator func(int, *core.BlockGen), odr *LesOdr, peers *peerSet, db ethdb.Database, ulcConfig *eth.ULCConfig) *ProtocolManager { 196 pm, err := newTestProtocolManager(lightSync, blocks, generator, odr, peers, db, ulcConfig) 197 if err != nil { 198 t.Fatalf("Failed to create protocol manager: %v", err) 199 } 200 return pm 201 } 202 203 // testPeer is a simulated peer to allow testing direct network calls. 204 type testPeer struct { 205 net p2p.MsgReadWriter // Network layer reader/writer to simulate remote messaging 206 app *p2p.MsgPipeRW // Application layer reader/writer to simulate the local side 207 *peer 208 } 209 210 // newTestPeer creates a new peer registered at the given protocol manager. 211 func newTestPeer(t *testing.T, name string, version int, pm *ProtocolManager, shake bool) (*testPeer, <-chan error) { 212 // Create a message pipe to communicate through 213 app, net := p2p.MsgPipe() 214 215 // Generate a random id and create the peer 216 var id enode.ID 217 rand.Read(id[:]) 218 219 peer := pm.newPeer(version, NetworkId, p2p.NewPeer(id, name, nil), net) 220 221 // Start the peer on a new thread 222 errc := make(chan error, 1) 223 go func() { 224 select { 225 case pm.newPeerCh <- peer: 226 errc <- pm.handle(peer) 227 case <-pm.quitSync: 228 errc <- p2p.DiscQuitting 229 } 230 }() 231 tp := &testPeer{ 232 app: app, 233 net: net, 234 peer: peer, 235 } 236 // Execute any implicitly requested handshakes and return 237 if shake { 238 var ( 239 genesis = pm.blockchain.Genesis() 240 head = pm.blockchain.CurrentHeader() 241 td = pm.blockchain.GetTd(head.Hash(), head.Number.Uint64()) 242 ) 243 tp.handshake(t, td, head.Hash(), head.Number.Uint64(), genesis.Hash()) 244 } 245 return tp, errc 246 } 247 248 func newTestPeerPair(name string, version int, pm, pm2 *ProtocolManager) (*peer, <-chan error, *peer, <-chan error) { 249 // Create a message pipe to communicate through 250 app, net := p2p.MsgPipe() 251 252 // Generate a random id and create the peer 253 var id enode.ID 254 rand.Read(id[:]) 255 256 peer := pm.newPeer(version, NetworkId, p2p.NewPeer(id, name, nil), net) 257 peer2 := pm2.newPeer(version, NetworkId, p2p.NewPeer(id, name, nil), app) 258 259 // Start the peer on a new thread 260 errc := make(chan error, 1) 261 errc2 := make(chan error, 1) 262 go func() { 263 select { 264 case pm.newPeerCh <- peer: 265 errc <- pm.handle(peer) 266 case <-pm.quitSync: 267 errc <- p2p.DiscQuitting 268 } 269 }() 270 go func() { 271 select { 272 case pm2.newPeerCh <- peer2: 273 errc2 <- pm2.handle(peer2) 274 case <-pm2.quitSync: 275 errc2 <- p2p.DiscQuitting 276 } 277 }() 278 return peer, errc, peer2, errc2 279 } 280 281 // handshake simulates a trivial handshake that expects the same state from the 282 // remote side as we are simulating locally. 283 func (p *testPeer) handshake(t *testing.T, td *big.Int, head common.Hash, headNum uint64, genesis common.Hash) { 284 var expList keyValueList 285 expList = expList.add("protocolVersion", uint64(p.version)) 286 expList = expList.add("networkId", uint64(NetworkId)) 287 expList = expList.add("headTd", td) 288 expList = expList.add("headHash", head) 289 expList = expList.add("headNum", headNum) 290 expList = expList.add("genesisHash", genesis) 291 sendList := make(keyValueList, len(expList)) 292 copy(sendList, expList) 293 expList = expList.add("serveHeaders", nil) 294 expList = expList.add("serveChainSince", uint64(0)) 295 expList = expList.add("serveStateSince", uint64(0)) 296 expList = expList.add("txRelay", nil) 297 expList = expList.add("flowControl/BL", testBufLimit) 298 expList = expList.add("flowControl/MRR", uint64(1)) 299 expList = expList.add("flowControl/MRC", testCostList()) 300 301 if err := p2p.ExpectMsg(p.app, StatusMsg, expList); err != nil { 302 t.Fatalf("status recv: %v", err) 303 } 304 if err := p2p.Send(p.app, StatusMsg, sendList); err != nil { 305 t.Fatalf("status send: %v", err) 306 } 307 308 p.fcParams = flowcontrol.ServerParams{ 309 BufLimit: testBufLimit, 310 MinRecharge: 1, 311 } 312 } 313 314 // close terminates the local side of the peer, notifying the remote protocol 315 // manager of termination. 316 func (p *testPeer) close() { 317 p.app.Close() 318 } 319 320 // TestEntity represents a network entity for testing with necessary auxiliary fields. 321 type TestEntity struct { 322 db ethdb.Database 323 rPeer *peer 324 tPeer *testPeer 325 peers *peerSet 326 pm *ProtocolManager 327 // Indexers 328 chtIndexer *core.ChainIndexer 329 bloomIndexer *core.ChainIndexer 330 bloomTrieIndexer *core.ChainIndexer 331 } 332 333 // newServerEnv creates a server testing environment with a connected test peer for testing purpose. 334 func newServerEnv(t *testing.T, blocks int, protocol int, waitIndexers func(*core.ChainIndexer, *core.ChainIndexer, *core.ChainIndexer)) (*TestEntity, func()) { 335 db := rawdb.NewMemoryDatabase() 336 cIndexer, bIndexer, btIndexer := testIndexers(db, nil, light.TestServerIndexerConfig) 337 338 pm := newTestProtocolManagerMust(t, false, blocks, testChainGen, nil, nil, db, nil) 339 peer, _ := newTestPeer(t, "peer", protocol, pm, true) 340 341 cIndexer.Start(pm.blockchain.(*core.BlockChain)) 342 bIndexer.Start(pm.blockchain.(*core.BlockChain)) 343 344 // Wait until indexers generate enough index data. 345 if waitIndexers != nil { 346 waitIndexers(cIndexer, bIndexer, btIndexer) 347 } 348 349 return &TestEntity{ 350 db: db, 351 tPeer: peer, 352 pm: pm, 353 chtIndexer: cIndexer, 354 bloomIndexer: bIndexer, 355 bloomTrieIndexer: btIndexer, 356 }, func() { 357 peer.close() 358 // Note bloom trie indexer will be closed by it parent recursively. 359 cIndexer.Close() 360 bIndexer.Close() 361 } 362 } 363 364 // newClientServerEnv creates a client/server arch environment with a connected les server and light client pair 365 // for testing purpose. 366 func newClientServerEnv(t *testing.T, blocks int, protocol int, waitIndexers func(*core.ChainIndexer, *core.ChainIndexer, *core.ChainIndexer), newPeer bool) (*TestEntity, *TestEntity, func()) { 367 db, ldb := rawdb.NewMemoryDatabase(), rawdb.NewMemoryDatabase() 368 peers, lPeers := newPeerSet(), newPeerSet() 369 370 dist := newRequestDistributor(lPeers, make(chan struct{}), &mclock.System{}) 371 rm := newRetrieveManager(lPeers, dist, nil) 372 odr := NewLesOdr(ldb, light.TestClientIndexerConfig, rm) 373 374 cIndexer, bIndexer, btIndexer := testIndexers(db, nil, light.TestServerIndexerConfig) 375 lcIndexer, lbIndexer, lbtIndexer := testIndexers(ldb, odr, light.TestClientIndexerConfig) 376 odr.SetIndexers(lcIndexer, lbtIndexer, lbIndexer) 377 378 pm := newTestProtocolManagerMust(t, false, blocks, testChainGen, nil, peers, db, nil) 379 lpm := newTestProtocolManagerMust(t, true, 0, nil, odr, lPeers, ldb, nil) 380 381 startIndexers := func(clientMode bool, pm *ProtocolManager) { 382 if clientMode { 383 lcIndexer.Start(pm.blockchain.(*light.LightChain)) 384 lbIndexer.Start(pm.blockchain.(*light.LightChain)) 385 } else { 386 cIndexer.Start(pm.blockchain.(*core.BlockChain)) 387 bIndexer.Start(pm.blockchain.(*core.BlockChain)) 388 } 389 } 390 391 startIndexers(false, pm) 392 startIndexers(true, lpm) 393 394 // Execute wait until function if it is specified. 395 if waitIndexers != nil { 396 waitIndexers(cIndexer, bIndexer, btIndexer) 397 } 398 399 var ( 400 peer, lPeer *peer 401 err1, err2 <-chan error 402 ) 403 if newPeer { 404 peer, err1, lPeer, err2 = newTestPeerPair("peer", protocol, pm, lpm) 405 select { 406 case <-time.After(time.Millisecond * 100): 407 case err := <-err1: 408 t.Fatalf("peer 1 handshake error: %v", err) 409 case err := <-err2: 410 t.Fatalf("peer 2 handshake error: %v", err) 411 } 412 } 413 414 return &TestEntity{ 415 db: db, 416 pm: pm, 417 rPeer: peer, 418 peers: peers, 419 chtIndexer: cIndexer, 420 bloomIndexer: bIndexer, 421 bloomTrieIndexer: btIndexer, 422 }, &TestEntity{ 423 db: ldb, 424 pm: lpm, 425 rPeer: lPeer, 426 peers: lPeers, 427 chtIndexer: lcIndexer, 428 bloomIndexer: lbIndexer, 429 bloomTrieIndexer: lbtIndexer, 430 }, func() { 431 // Note bloom trie indexers will be closed by their parents recursively. 432 cIndexer.Close() 433 bIndexer.Close() 434 lcIndexer.Close() 435 lbIndexer.Close() 436 } 437 }