github.com/n1ghtfa1l/go-vnt@v0.6.4-alpha.6/whisper/whisperv6/peer_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 package whisperv6 18 19 import ( 20 "bytes" 21 "crypto/ecdsa" 22 "fmt" 23 mrand "math/rand" 24 "net" 25 "sync" 26 "sync/atomic" 27 "testing" 28 "time" 29 30 libp2p "github.com/libp2p/go-libp2p" 31 "github.com/vntchain/go-vnt/common" 32 "github.com/vntchain/go-vnt/common/hexutil" 33 "github.com/vntchain/go-vnt/crypto" 34 p2p "github.com/vntchain/go-vnt/vntp2p" 35 ) 36 37 var keys = []string{ 38 "d49dcf37238dc8a7aac57dc61b9fee68f0a97f062968978b9fafa7d1033d03a9", 39 "73fd6143c48e80ed3c56ea159fe7494a0b6b393a392227b422f4c3e8f1b54f98", 40 "119dd32adb1daa7a4c7bf77f847fb28730785aa92947edf42fdd997b54de40dc", 41 "deeda8709dea935bb772248a3144dea449ffcc13e8e5a1fd4ef20ce4e9c87837", 42 "5bd208a079633befa349441bdfdc4d85ba9bd56081525008380a63ac38a407cf", 43 "1d27fb4912002d58a2a42a50c97edb05c1b3dffc665dbaa42df1fe8d3d95c9b5", 44 "15def52800c9d6b8ca6f3066b7767a76afc7b611786c1276165fbc61636afb68", 45 "51be6ab4b2dc89f251ff2ace10f3c1cc65d6855f3e083f91f6ff8efdfd28b48c", 46 "ef1ef7441bf3c6419b162f05da6037474664f198b58db7315a6f4de52414b4a0", 47 "09bdf6985aabc696dc1fbeb5381aebd7a6421727343872eb2fadfc6d82486fd9", 48 "15d811bf2e01f99a224cdc91d0cf76cea08e8c67905c16fee9725c9be71185c4", 49 "2f83e45cf1baaea779789f755b7da72d8857aeebff19362dd9af31d3c9d14620", 50 "73f04e34ac6532b19c2aae8f8e52f38df1ac8f5cd10369f92325b9b0494b0590", 51 "1e2e07b69e5025537fb73770f483dc8d64f84ae3403775ef61cd36e3faf162c1", 52 "8963d9bbb3911aac6d30388c786756b1c423c4fbbc95d1f96ddbddf39809e43a", 53 "0422da85abc48249270b45d8de38a4cc3c02032ede1fcf0864a51092d58a2f1f", 54 "8ae5c15b0e8c7cade201fdc149831aa9b11ff626a7ffd27188886cc108ad0fa8", 55 "acd8f5a71d4aecfcb9ad00d32aa4bcf2a602939b6a9dd071bab443154184f805", 56 "a285a922125a7481600782ad69debfbcdb0316c1e97c267aff29ef50001ec045", 57 "28fd4eee78c6cd4bf78f39f8ab30c32c67c24a6223baa40e6f9c9a0e1de7cef5", 58 "c5cca0c9e6f043b288c6f1aef448ab59132dab3e453671af5d0752961f013fc7", 59 "46df99b051838cb6f8d1b73f232af516886bd8c4d0ee07af9a0a033c391380fd", 60 "c6a06a53cbaadbb432884f36155c8f3244e244881b5ee3e92e974cfa166d793f", 61 "783b90c75c63dc72e2f8d11b6f1b4de54d63825330ec76ee8db34f06b38ea211", 62 "9450038f10ca2c097a8013e5121b36b422b95b04892232f930a29292d9935611", 63 "e215e6246ed1cfdcf7310d4d8cdbe370f0d6a8371e4eb1089e2ae05c0e1bc10f", 64 "487110939ed9d64ebbc1f300adeab358bc58875faf4ca64990fbd7fe03b78f2b", 65 "824a70ea76ac81366da1d4f4ac39de851c8ac49dca456bb3f0a186ceefa269a5", 66 "ba8f34fa40945560d1006a328fe70c42e35cc3d1017e72d26864cd0d1b150f15", 67 "30a5dfcfd144997f428901ea88a43c8d176b19c79dde54cc58eea001aa3d246c", 68 "de59f7183aca39aa245ce66a05245fecfc7e2c75884184b52b27734a4a58efa2", 69 "92629e2ff5f0cb4f5f08fffe0f64492024d36f045b901efb271674b801095c5a", 70 "7184c1701569e3a4c4d2ddce691edd983b81e42e09196d332e1ae2f1e062cff4", 71 } 72 73 type TestData struct { 74 started int64 75 counter [NumNodes]int 76 mutex sync.RWMutex 77 } 78 79 type TestNode struct { 80 shh *Whisper 81 id *ecdsa.PrivateKey 82 server *p2p.Server 83 filerID string 84 } 85 86 const NumNodes = 8 // must not exceed the number of keys (32) 87 88 var result TestData 89 var nodes [NumNodes]*TestNode 90 var sharedKey = hexutil.MustDecode("0x03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31") 91 var wrongKey = hexutil.MustDecode("0xf91156714d7ec88d3edc1c652c2181dbb3044e8771c683f3b30d33c12b986b11") 92 var sharedTopic = TopicType{0xF, 0x1, 0x2, 0} 93 var wrongTopic = TopicType{0, 0, 0, 0} 94 var expectedMessage = []byte("per aspera ad astra") 95 var unexpectedMessage = []byte("per rectum ad astra") 96 var masterBloomFilter []byte 97 var masterPow = 0.00000001 98 var round = 1 99 var debugMode = false 100 var prevTime time.Time 101 var cntPrev int 102 103 func TestSimulation(t *testing.T) { 104 // create a chain of whisper nodes, 105 // installs the filters with shared (predefined) parameters 106 initialize(t) 107 108 // each node sends one random (not decryptable) message 109 for i := 0; i < NumNodes; i++ { 110 sendMsg(t, false, i) 111 } 112 113 // node #0 sends one expected (decryptable) message 114 sendMsg(t, true, 0) 115 116 // check if each node have received and decrypted exactly one message 117 checkPropagation(t, true) 118 119 // check if Status message was correctly decoded 120 checkBloomFilterExchange(t) 121 checkPowExchange(t) 122 123 // send new pow and bloom exchange messages 124 resetParams(t) 125 126 // node #1 sends one expected (decryptable) message 127 sendMsg(t, true, 1) 128 129 // check if each node (except node #0) have received and decrypted exactly one message 130 checkPropagation(t, false) 131 132 // check if corresponding protocol-level messages were correctly decoded 133 checkPowExchangeForNodeZero(t) 134 checkBloomFilterExchange(t) 135 136 stopServers() 137 } 138 139 func resetParams(t *testing.T) { 140 // change pow only for node zero 141 masterPow = 7777777.0 142 nodes[0].shh.SetMinimumPoW(masterPow) 143 144 // change bloom for all nodes 145 masterBloomFilter = TopicToBloom(sharedTopic) 146 for i := 0; i < NumNodes; i++ { 147 nodes[i].shh.SetBloomFilter(masterBloomFilter) 148 } 149 150 round++ 151 } 152 153 func initBloom(t *testing.T) { 154 masterBloomFilter = make([]byte, BloomFilterSize) 155 _, err := mrand.Read(masterBloomFilter) 156 if err != nil { 157 t.Fatalf("rand failed: %s.", err) 158 } 159 160 msgBloom := TopicToBloom(sharedTopic) 161 masterBloomFilter = addBloom(masterBloomFilter, msgBloom) 162 for i := 0; i < 32; i++ { 163 masterBloomFilter[i] = 0xFF 164 } 165 166 if !BloomFilterMatch(masterBloomFilter, msgBloom) { 167 t.Fatalf("bloom mismatch on initBloom.") 168 } 169 } 170 171 func initialize(t *testing.T) { 172 initBloom(t) 173 174 var err error 175 ip := net.IPv4(127, 0, 0, 1) 176 port0 := 30303 177 178 for i := 0; i < NumNodes; i++ { 179 var node TestNode 180 b := make([]byte, BloomFilterSize) 181 copy(b, masterBloomFilter) 182 node.shh = New(&DefaultConfig) 183 node.shh.SetMinimumPoW(masterPow) 184 node.shh.SetBloomFilter(b) 185 if !bytes.Equal(node.shh.BloomFilter(), masterBloomFilter) { 186 t.Fatalf("bloom mismatch on init.") 187 } 188 node.shh.Start(nil) 189 topics := make([]TopicType, 0) 190 topics = append(topics, sharedTopic) 191 f := Filter{KeySym: sharedKey} 192 f.Topics = [][]byte{topics[0][:]} 193 node.filerID, err = node.shh.Subscribe(&f) 194 if err != nil { 195 t.Fatalf("failed to install the filter: %s.", err) 196 } 197 node.id, err = crypto.HexToECDSA(keys[i]) 198 if err != nil { 199 t.Fatalf("failed convert the key: %s.", keys[i]) 200 } 201 port := port0 + i 202 addr := fmt.Sprintf(":%d", port) // e.g. ":30303" 203 name := common.MakeName("whisper-go", "2.0") 204 var peers []*p2p.Node 205 if i > 0 { 206 peerNodeID := nodes[i-1].id 207 peerPort := uint16(port - 1) 208 peerNode := p2p.PubkeyID(&peerNodeID.PublicKey) 209 peer := p2p.NewNode(peerNode, ip, peerPort, peerPort) 210 peers = append(peers, peer) 211 } 212 213 node.server = &p2p.Server{ 214 Config: p2p.Config{ 215 PrivateKey: node.id, 216 MaxPeers: NumNodes/2 + 1, 217 Name: name, 218 Protocols: node.shh.Protocols(), 219 ListenAddr: addr, 220 NAT: libp2p.NATPortMap(), 221 BootstrapNodes: peers, 222 StaticNodes: peers, 223 TrustedNodes: peers, 224 }, 225 } 226 227 nodes[i] = &node 228 } 229 230 for i := 0; i < NumNodes; i++ { 231 go startServer(t, nodes[i].server) 232 } 233 234 waitForServersToStart(t) 235 } 236 237 func startServer(t *testing.T, s *p2p.Server) { 238 err := s.Start() 239 if err != nil { 240 t.Fatalf("failed to start the fisrt server.") 241 } 242 243 atomic.AddInt64(&result.started, 1) 244 } 245 246 func stopServers() { 247 for i := 0; i < NumNodes; i++ { 248 n := nodes[i] 249 if n != nil { 250 n.shh.Unsubscribe(n.filerID) 251 n.shh.Stop() 252 n.server.Stop() 253 } 254 } 255 } 256 257 func checkPropagation(t *testing.T, includingNodeZero bool) { 258 if t.Failed() { 259 return 260 } 261 262 prevTime = time.Now() 263 // (cycle * iterations) should not exceed 50 seconds, since TTL=50 264 const cycle = 200 // time in milliseconds 265 const iterations = 250 266 267 first := 0 268 if !includingNodeZero { 269 first = 1 270 } 271 272 for j := 0; j < iterations; j++ { 273 for i := first; i < NumNodes; i++ { 274 f := nodes[i].shh.GetFilter(nodes[i].filerID) 275 if f == nil { 276 t.Fatalf("failed to get filterId %s from node %d, round %d.", nodes[i].filerID, i, round) 277 } 278 279 mail := f.Retrieve() 280 validateMail(t, i, mail) 281 282 if isTestComplete() { 283 checkTestStatus() 284 return 285 } 286 } 287 288 checkTestStatus() 289 time.Sleep(cycle * time.Millisecond) 290 } 291 292 if !includingNodeZero { 293 //f := nodes[0].shh.GetFilter(nodes[0].filerID) 294 //if f != nil { 295 // t.Fatalf("node zero received a message with low PoW.") 296 //} 297 } 298 299 //t.Fatalf("Test was not complete (%d round): timeout %d seconds. nodes=%v", round, iterations*cycle/1000, nodes) 300 } 301 302 func validateMail(t *testing.T, index int, mail []*ReceivedMessage) { 303 var cnt int 304 for _, m := range mail { 305 if bytes.Equal(m.Payload, expectedMessage) { 306 cnt++ 307 } 308 } 309 310 if cnt == 0 { 311 // no messages received yet: nothing is wrong 312 return 313 } 314 if cnt > 1 { 315 t.Fatalf("node %d received %d.", index, cnt) 316 } 317 318 if cnt == 1 { 319 result.mutex.Lock() 320 defer result.mutex.Unlock() 321 result.counter[index] += cnt 322 if result.counter[index] > 1 { 323 t.Fatalf("node %d accumulated %d.", index, result.counter[index]) 324 } 325 } 326 } 327 328 func checkTestStatus() { 329 var cnt int 330 var arr [NumNodes]int 331 332 for i := 0; i < NumNodes; i++ { 333 arr[i] = nodes[i].server.PeerCount() 334 envelopes := nodes[i].shh.Envelopes() 335 if len(envelopes) >= NumNodes { 336 cnt++ 337 } 338 } 339 340 if debugMode { 341 if cntPrev != cnt { 342 fmt.Printf(" %v \t number of nodes that have received all msgs: %d, number of peers per node: %v \n", 343 time.Since(prevTime), cnt, arr) 344 prevTime = time.Now() 345 cntPrev = cnt 346 } 347 } 348 } 349 350 func isTestComplete() bool { 351 result.mutex.RLock() 352 defer result.mutex.RUnlock() 353 354 for i := 0; i < NumNodes; i++ { 355 if result.counter[i] < 1 { 356 return false 357 } 358 } 359 360 for i := 0; i < NumNodes; i++ { 361 envelopes := nodes[i].shh.Envelopes() 362 if len(envelopes) < NumNodes+1 { 363 return false 364 } 365 } 366 367 return true 368 } 369 370 func sendMsg(t *testing.T, expected bool, id int) { 371 if t.Failed() { 372 return 373 } 374 375 opt := MessageParams{KeySym: sharedKey, Topic: sharedTopic, Payload: expectedMessage, PoW: 0.00000001, WorkTime: 1} 376 if !expected { 377 opt.KeySym = wrongKey 378 opt.Topic = wrongTopic 379 opt.Payload = unexpectedMessage 380 opt.Payload[0] = byte(id) 381 } 382 383 msg, err := NewSentMessage(&opt) 384 if err != nil { 385 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 386 } 387 envelope, err := msg.Wrap(&opt) 388 if err != nil { 389 t.Fatalf("failed to seal message: %s", err) 390 } 391 392 err = nodes[id].shh.Send(envelope) 393 if err != nil { 394 t.Fatalf("failed to send message: %s", err) 395 } 396 } 397 398 func TestPeerBasic(t *testing.T) { 399 InitSingleTest() 400 401 params, err := generateMessageParams() 402 if err != nil { 403 t.Fatalf("failed generateMessageParams with seed %d.", seed) 404 } 405 406 params.PoW = 0.001 407 msg, err := NewSentMessage(params) 408 if err != nil { 409 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 410 } 411 env, err := msg.Wrap(params) 412 if err != nil { 413 t.Fatalf("failed Wrap with seed %d.", seed) 414 } 415 416 p := newPeer(nil, nil, nil) 417 p.mark(env) 418 if !p.marked(env) { 419 t.Fatalf("failed mark with seed %d.", seed) 420 } 421 } 422 423 func checkPowExchangeForNodeZero(t *testing.T) { 424 const iterations = 200 425 for j := 0; j < iterations; j++ { 426 lastCycle := (j == iterations-1) 427 ok := checkPowExchangeForNodeZeroOnce(t, lastCycle) 428 if ok { 429 break 430 } 431 time.Sleep(50 * time.Millisecond) 432 } 433 } 434 435 func checkPowExchangeForNodeZeroOnce(t *testing.T, mustPass bool) bool { 436 cnt := 0 437 for i, node := range nodes { 438 for peer := range node.shh.peers { 439 if peer.peer.RemoteID() == p2p.PubkeyID(&nodes[0].id.PublicKey) { 440 cnt++ 441 if peer.powRequirement != masterPow { 442 if mustPass { 443 t.Fatalf("node %d: failed to set the new pow requirement for node zero.", i) 444 } else { 445 return false 446 } 447 } 448 } 449 } 450 } 451 //if cnt == 0 { 452 // t.Fatalf("looking for node zero: no matching peers found.") 453 //} 454 return true 455 } 456 457 func checkPowExchange(t *testing.T) { 458 for i, node := range nodes { 459 for peer := range node.shh.peers { 460 if peer.peer.RemoteID() != p2p.PubkeyID(&nodes[0].id.PublicKey) { 461 if peer.powRequirement != masterPow { 462 t.Fatalf("node %d: failed to exchange pow requirement in round %d; expected %f, got %f", 463 i, round, masterPow, peer.powRequirement) 464 } 465 } 466 } 467 } 468 } 469 470 func checkBloomFilterExchangeOnce(t *testing.T, mustPass bool) bool { 471 for i, node := range nodes { 472 for peer := range node.shh.peers { 473 peer.bloomMu.Lock() 474 equals := bytes.Equal(peer.bloomFilter, masterBloomFilter) 475 peer.bloomMu.Unlock() 476 if !equals { 477 if mustPass { 478 t.Fatalf("node %d: failed to exchange bloom filter requirement in round %d. \n%x expected \n%x got", 479 i, round, masterBloomFilter, peer.bloomFilter) 480 } else { 481 return false 482 } 483 } 484 } 485 } 486 487 return true 488 } 489 490 func checkBloomFilterExchange(t *testing.T) { 491 const iterations = 200 492 for j := 0; j < iterations; j++ { 493 lastCycle := (j == iterations-1) 494 ok := checkBloomFilterExchangeOnce(t, lastCycle) 495 if ok { 496 break 497 } 498 time.Sleep(50 * time.Millisecond) 499 } 500 } 501 502 func waitForServersToStart(t *testing.T) { 503 const iterations = 200 504 var started int64 505 for j := 0; j < iterations; j++ { 506 time.Sleep(50 * time.Millisecond) 507 started = atomic.LoadInt64(&result.started) 508 if started == NumNodes { 509 return 510 } 511 } 512 t.Fatalf("Failed to start all the servers, running: %d", started) 513 }