github.com/braveheart12/just@v0.8.7/network/hostnetwork/transport_consensus_test.go (about) 1 /* 2 * The Clear BSD License 3 * 4 * Copyright (c) 2019 Insolar Technologies 5 * 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without modification, are permitted (subject to the limitations in the disclaimer below) provided that the following conditions are met: 9 * 10 * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 11 * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 12 * Neither the name of Insolar Technologies nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 13 * 14 * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 15 * 16 */ 17 18 package hostnetwork 19 20 import ( 21 "context" 22 "sync" 23 "testing" 24 25 consensus "github.com/insolar/insolar/consensus/packets" 26 "github.com/insolar/insolar/core" 27 "github.com/insolar/insolar/cryptography" 28 "github.com/insolar/insolar/log" 29 "github.com/insolar/insolar/network" 30 "github.com/insolar/insolar/network/transport/host" 31 "github.com/insolar/insolar/platformpolicy" 32 "github.com/stretchr/testify/require" 33 "github.com/stretchr/testify/suite" 34 ) 35 36 type consensusTransportSuite struct { 37 suite.Suite 38 crypto core.CryptographyService 39 } 40 41 func createTwoConsensusNetworks(id1, id2 core.ShortNodeID) (t1, t2 network.ConsensusNetwork, err error) { 42 m := newMockResolver() 43 44 cn1, err := NewConsensusNetwork("127.0.0.1:0", ID1+DOMAIN, id1, m) 45 if err != nil { 46 return nil, nil, err 47 } 48 cn2, err := NewConsensusNetwork("127.0.0.1:0", ID2+DOMAIN, id2, m) 49 if err != nil { 50 return nil, nil, err 51 } 52 53 ref1, err := core.NewRefFromBase58(ID2 + DOMAIN) 54 if err != nil { 55 return nil, nil, err 56 } 57 routing1, err := host.NewHostNS(cn1.PublicAddress(), *ref1, id1) 58 if err != nil { 59 return nil, nil, err 60 } 61 ref2, err := core.NewRefFromBase58(ID2 + DOMAIN) 62 if err != nil { 63 return nil, nil, err 64 } 65 routing2, err := host.NewHostNS(cn2.PublicAddress(), *ref2, id2) 66 if err != nil { 67 return nil, nil, err 68 } 69 m.addMappingHost(routing1) 70 m.addMappingHost(routing2) 71 72 return cn1, cn2, nil 73 } 74 75 func (t *consensusTransportSuite) sendPacket(packet consensus.ConsensusPacket) { 76 cn1, cn2, err := createTwoConsensusNetworks(0, 1) 77 t.Require().NoError(err) 78 ctx := context.Background() 79 ctx2 := context.Background() 80 81 wg := sync.WaitGroup{} 82 wg.Add(1) 83 84 handler := func(incomingPacket consensus.ConsensusPacket, sender core.RecordRef) { 85 log.Info("handler triggered") 86 wg.Done() 87 } 88 cn2.RegisterPacketHandler(packet.GetType(), handler) 89 90 err = cn2.Start(ctx2) 91 t.Require().NoError(err) 92 err = cn1.Start(ctx) 93 t.Require().NoError(err) 94 defer func() { 95 cn1.Stop(ctx) 96 cn2.Stop(ctx2) 97 }() 98 99 err = cn1.SignAndSendPacket(packet, cn2.GetNodeID(), t.crypto) 100 t.Require().NoError(err) 101 wg.Wait() 102 } 103 104 func newPhase1Packet() *consensus.Phase1Packet { 105 return consensus.NewPhase1Packet(core.Pulse{}) 106 } 107 108 func newPhase2Packet() (*consensus.Phase2Packet, error) { 109 bitset, err := consensus.NewBitSet(10) 110 if err != nil { 111 return nil, err 112 } 113 result := consensus.NewPhase2Packet(core.PulseNumber(0)) 114 result.SetBitSet(bitset) 115 return result, nil 116 } 117 118 func newPhase3Packet() (*consensus.Phase3Packet, error) { 119 var ghs consensus.GlobuleHashSignature 120 bitset, err := consensus.NewBitSet(10) 121 if err != nil { 122 return nil, err 123 } 124 return consensus.NewPhase3Packet(core.PulseNumber(0), ghs, bitset), nil 125 } 126 127 func (t *consensusTransportSuite) TestSendPacketPhase1() { 128 packet := newPhase1Packet() 129 t.sendPacket(packet) 130 } 131 132 func (t *consensusTransportSuite) TestSendPacketPhase2() { 133 packet, err := newPhase2Packet() 134 require.NoError(t.T(), err) 135 t.sendPacket(packet) 136 } 137 138 func (t *consensusTransportSuite) TestSendPacketPhase3() { 139 packet, err := newPhase3Packet() 140 require.NoError(t.T(), err) 141 t.sendPacket(packet) 142 } 143 144 func (t *consensusTransportSuite) sendPacketAndVerify(packet consensus.ConsensusPacket) { 145 cn1, cn2, err := createTwoConsensusNetworks(0, 1) 146 t.Require().NoError(err) 147 ctx := context.Background() 148 ctx2 := context.Background() 149 150 result := make(chan bool, 1) 151 152 handler := func(incomingPacket consensus.ConsensusPacket, sender core.RecordRef) { 153 log.Info("handler triggered") 154 pk, err := t.crypto.GetPublicKey() 155 if err != nil { 156 log.Error("handler get public key error: " + err.Error()) 157 result <- false 158 return 159 } 160 err = incomingPacket.Verify(t.crypto, pk) 161 if err != nil { 162 log.Error("verify signature error: " + err.Error()) 163 result <- false 164 return 165 } 166 result <- true 167 } 168 cn2.RegisterPacketHandler(packet.GetType(), handler) 169 170 err = cn2.Start(ctx2) 171 t.Require().NoError(err) 172 err = cn1.Start(ctx) 173 t.Require().NoError(err) 174 defer func() { 175 cn1.Stop(ctx) 176 cn2.Stop(ctx2) 177 }() 178 179 err = cn1.SignAndSendPacket(packet, cn2.GetNodeID(), t.crypto) 180 t.Require().NoError(err) 181 t.True(<-result) 182 } 183 184 func (t *consensusTransportSuite) TestVerifySignPhase1() { 185 packet := newPhase1Packet() 186 t.sendPacketAndVerify(packet) 187 } 188 189 func (t *consensusTransportSuite) TestVerifySignPhase2() { 190 packet, err := newPhase2Packet() 191 require.NoError(t.T(), err) 192 t.sendPacketAndVerify(packet) 193 } 194 195 func (t *consensusTransportSuite) TestVerifySignPhase3() { 196 packet, err := newPhase3Packet() 197 require.NoError(t.T(), err) 198 t.sendPacketAndVerify(packet) 199 } 200 201 func NewSuite() (*consensusTransportSuite, error) { 202 kp := platformpolicy.NewKeyProcessor() 203 sk, err := kp.GeneratePrivateKey() 204 if err != nil { 205 return nil, err 206 } 207 cryptoService := cryptography.NewKeyBoundCryptographyService(sk) 208 209 return &consensusTransportSuite{ 210 Suite: suite.Suite{}, 211 crypto: cryptoService, 212 }, nil 213 } 214 215 func TestConsensusTransport(t *testing.T) { 216 s, err := NewSuite() 217 require.NoError(t, err) 218 suite.Run(t, s) 219 }