github.com/n1ghtfa1l/go-vnt@v0.6.4-alpha.6/whisper/whisperv5/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 whisperv5 18 19 import ( 20 "bytes" 21 "crypto/ecdsa" 22 "fmt" 23 "net" 24 "sync" 25 "testing" 26 "time" 27 28 libp2p "github.com/libp2p/go-libp2p" 29 "github.com/vntchain/go-vnt/common" 30 "github.com/vntchain/go-vnt/crypto" 31 p2p "github.com/vntchain/go-vnt/vntp2p" 32 ) 33 34 var keys = []string{ 35 "d49dcf37238dc8a7aac57dc61b9fee68f0a97f062968978b9fafa7d1033d03a9", 36 "73fd6143c48e80ed3c56ea159fe7494a0b6b393a392227b422f4c3e8f1b54f98", 37 "119dd32adb1daa7a4c7bf77f847fb28730785aa92947edf42fdd997b54de40dc", 38 "deeda8709dea935bb772248a3144dea449ffcc13e8e5a1fd4ef20ce4e9c87837", 39 "5bd208a079633befa349441bdfdc4d85ba9bd56081525008380a63ac38a407cf", 40 "1d27fb4912002d58a2a42a50c97edb05c1b3dffc665dbaa42df1fe8d3d95c9b5", 41 "15def52800c9d6b8ca6f3066b7767a76afc7b611786c1276165fbc61636afb68", 42 "51be6ab4b2dc89f251ff2ace10f3c1cc65d6855f3e083f91f6ff8efdfd28b48c", 43 "ef1ef7441bf3c6419b162f05da6037474664f198b58db7315a6f4de52414b4a0", 44 "09bdf6985aabc696dc1fbeb5381aebd7a6421727343872eb2fadfc6d82486fd9", 45 "15d811bf2e01f99a224cdc91d0cf76cea08e8c67905c16fee9725c9be71185c4", 46 "2f83e45cf1baaea779789f755b7da72d8857aeebff19362dd9af31d3c9d14620", 47 "73f04e34ac6532b19c2aae8f8e52f38df1ac8f5cd10369f92325b9b0494b0590", 48 "1e2e07b69e5025537fb73770f483dc8d64f84ae3403775ef61cd36e3faf162c1", 49 "8963d9bbb3911aac6d30388c786756b1c423c4fbbc95d1f96ddbddf39809e43a", 50 "0422da85abc48249270b45d8de38a4cc3c02032ede1fcf0864a51092d58a2f1f", 51 "8ae5c15b0e8c7cade201fdc149831aa9b11ff626a7ffd27188886cc108ad0fa8", 52 "acd8f5a71d4aecfcb9ad00d32aa4bcf2a602939b6a9dd071bab443154184f805", 53 "a285a922125a7481600782ad69debfbcdb0316c1e97c267aff29ef50001ec045", 54 "28fd4eee78c6cd4bf78f39f8ab30c32c67c24a6223baa40e6f9c9a0e1de7cef5", 55 "c5cca0c9e6f043b288c6f1aef448ab59132dab3e453671af5d0752961f013fc7", 56 "46df99b051838cb6f8d1b73f232af516886bd8c4d0ee07af9a0a033c391380fd", 57 "c6a06a53cbaadbb432884f36155c8f3244e244881b5ee3e92e974cfa166d793f", 58 "783b90c75c63dc72e2f8d11b6f1b4de54d63825330ec76ee8db34f06b38ea211", 59 "9450038f10ca2c097a8013e5121b36b422b95b04892232f930a29292d9935611", 60 "e215e6246ed1cfdcf7310d4d8cdbe370f0d6a8371e4eb1089e2ae05c0e1bc10f", 61 "487110939ed9d64ebbc1f300adeab358bc58875faf4ca64990fbd7fe03b78f2b", 62 "824a70ea76ac81366da1d4f4ac39de851c8ac49dca456bb3f0a186ceefa269a5", 63 "ba8f34fa40945560d1006a328fe70c42e35cc3d1017e72d26864cd0d1b150f15", 64 "30a5dfcfd144997f428901ea88a43c8d176b19c79dde54cc58eea001aa3d246c", 65 "de59f7183aca39aa245ce66a05245fecfc7e2c75884184b52b27734a4a58efa2", 66 "92629e2ff5f0cb4f5f08fffe0f64492024d36f045b901efb271674b801095c5a", 67 "7184c1701569e3a4c4d2ddce691edd983b81e42e09196d332e1ae2f1e062cff4", 68 } 69 70 const NumNodes = 16 // must not exceed the number of keys (32) 71 72 type TestData struct { 73 counter [NumNodes]int 74 mutex sync.RWMutex 75 } 76 77 type TestNode struct { 78 shh *Whisper 79 id *ecdsa.PrivateKey 80 server *p2p.Server 81 filerId string 82 } 83 84 var result TestData 85 var nodes [NumNodes]*TestNode 86 var sharedKey = []byte("some arbitrary data here") 87 var sharedTopic TopicType = TopicType{0xF, 0x1, 0x2, 0} 88 var expectedMessage = []byte("per rectum ad astra") 89 90 // This test does the following: 91 // 1. creates a chain of whisper nodes, 92 // 2. installs the filters with shared (predefined) parameters, 93 // 3. each node sends a number of random (undecryptable) messages, 94 // 4. first node sends one expected (decryptable) message, 95 // 5. checks if each node have received and decrypted exactly one message. 96 func TestSimulation(t *testing.T) { 97 initialize(t) 98 99 for i := 0; i < NumNodes; i++ { 100 sendMsg(t, false, i) 101 } 102 103 sendMsg(t, true, 0) 104 checkPropagation(t) 105 stopServers() 106 } 107 108 func initialize(t *testing.T) { 109 var err error 110 ip := net.IPv4(127, 0, 0, 1) 111 port0 := 30303 112 113 for i := 0; i < NumNodes; i++ { 114 var node TestNode 115 node.shh = New(&DefaultConfig) 116 node.shh.SetMinimumPoW(0.00000001) 117 node.shh.Start(nil) 118 topics := make([]TopicType, 0) 119 topics = append(topics, sharedTopic) 120 f := Filter{KeySym: sharedKey} 121 f.Topics = [][]byte{topics[0][:]} 122 node.filerId, err = node.shh.Subscribe(&f) 123 if err != nil { 124 t.Fatalf("failed to install the filter: %s.", err) 125 } 126 node.id, err = crypto.HexToECDSA(keys[i]) 127 if err != nil { 128 t.Fatalf("failed convert the key: %s.", keys[i]) 129 } 130 port := port0 + i 131 addr := fmt.Sprintf(":%d", port) // e.g. ":30303" 132 name := common.MakeName("whisper-go", "2.0") 133 var peers []*p2p.Node 134 if i > 0 { 135 peerNodeId := nodes[i-1].id 136 peerPort := uint16(port - 1) 137 peerNode := p2p.PubkeyID(&peerNodeId.PublicKey) 138 peer := p2p.NewNode(peerNode, ip, peerPort, peerPort) 139 peers = append(peers, peer) 140 } 141 142 node.server = &p2p.Server{ 143 Config: p2p.Config{ 144 PrivateKey: node.id, 145 MaxPeers: NumNodes/2 + 1, 146 Name: name, 147 Protocols: node.shh.Protocols(), 148 ListenAddr: addr, 149 NAT: libp2p.NATPortMap(), 150 BootstrapNodes: peers, 151 StaticNodes: peers, 152 TrustedNodes: peers, 153 }, 154 } 155 156 err = node.server.Start() 157 if err != nil { 158 t.Fatalf("failed to start server %d, err=%s", i, err) 159 } 160 161 nodes[i] = &node 162 } 163 } 164 165 func stopServers() { 166 for i := 0; i < NumNodes; i++ { 167 n := nodes[i] 168 if n != nil { 169 n.shh.Unsubscribe(n.filerId) 170 n.shh.Stop() 171 n.server.Stop() 172 } 173 } 174 } 175 176 func checkPropagation(t *testing.T) { 177 if t.Failed() { 178 return 179 } 180 181 const cycle = 100 182 const iterations = 100 183 184 for j := 0; j < iterations; j++ { 185 time.Sleep(cycle * time.Millisecond) 186 187 for i := 0; i < NumNodes; i++ { 188 f := nodes[i].shh.GetFilter(nodes[i].filerId) 189 if f == nil { 190 t.Fatalf("failed to get filterId %s from node %d.", nodes[i].filerId, i) 191 } 192 193 mail := f.Retrieve() 194 if !validateMail(t, i, mail) { 195 return 196 } 197 198 if isTestComplete() { 199 return 200 } 201 } 202 } 203 204 //t.Fatalf("Test was not complete: timeout %d seconds.", iterations*cycle/1000) 205 } 206 207 func validateMail(t *testing.T, index int, mail []*ReceivedMessage) bool { 208 var cnt int 209 for _, m := range mail { 210 if bytes.Equal(m.Payload, expectedMessage) { 211 cnt++ 212 } 213 } 214 215 if cnt == 0 { 216 // no messages received yet: nothing is wrong 217 return true 218 } 219 if cnt > 1 { 220 t.Fatalf("node %d received %d.", index, cnt) 221 return false 222 } 223 224 if cnt > 0 { 225 result.mutex.Lock() 226 defer result.mutex.Unlock() 227 result.counter[index] += cnt 228 if result.counter[index] > 1 { 229 t.Fatalf("node %d accumulated %d.", index, result.counter[index]) 230 } 231 } 232 return true 233 } 234 235 func isTestComplete() bool { 236 result.mutex.RLock() 237 defer result.mutex.RUnlock() 238 239 for i := 0; i < NumNodes; i++ { 240 if result.counter[i] < 1 { 241 return false 242 } 243 } 244 245 for i := 0; i < NumNodes; i++ { 246 envelopes := nodes[i].shh.Envelopes() 247 if len(envelopes) < 2 { 248 return false 249 } 250 } 251 252 return true 253 } 254 255 func sendMsg(t *testing.T, expected bool, id int) { 256 if t.Failed() { 257 return 258 } 259 260 opt := MessageParams{KeySym: sharedKey, Topic: sharedTopic, Payload: expectedMessage, PoW: 0.00000001, WorkTime: 1} 261 if !expected { 262 opt.KeySym[0]++ 263 opt.Topic[0]++ 264 opt.Payload = opt.Payload[1:] 265 } 266 267 msg, err := NewSentMessage(&opt) 268 if err != nil { 269 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 270 } 271 envelope, err := msg.Wrap(&opt) 272 if err != nil { 273 t.Fatalf("failed to seal message: %s", err) 274 } 275 276 err = nodes[id].shh.Send(envelope) 277 if err != nil { 278 t.Fatalf("failed to send message: %s", err) 279 } 280 } 281 282 func TestPeerBasic(t *testing.T) { 283 InitSingleTest() 284 285 params, err := generateMessageParams() 286 if err != nil { 287 t.Fatalf("failed generateMessageParams with seed %d.", seed) 288 } 289 290 params.PoW = 0.001 291 msg, err := NewSentMessage(params) 292 if err != nil { 293 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 294 } 295 env, err := msg.Wrap(params) 296 if err != nil { 297 t.Fatalf("failed Wrap with seed %d.", seed) 298 } 299 300 p := newPeer(nil, nil, nil) 301 p.mark(env) 302 if !p.marked(env) { 303 t.Fatalf("failed mark with seed %d.", seed) 304 } 305 }