From bcf2622f29de956ddd0a8c6549df2dd6f51dfdb3 Mon Sep 17 00:00:00 2001 From: Lewis Marshall Date: Wed, 19 Apr 2017 22:02:15 +0100 Subject: [PATCH] swarm/network: Don't require NodeAdapter to initialise bzz protocol Signed-off-by: Lewis Marshall --- p2p/adapters/types.go | 2 - p2p/protocols/protocol_test.go | 106 +++++++++--------- p2p/testing/protocoltester.go | 4 +- swarm/network/protocol.go | 20 +--- swarm/network/protocol_test.go | 5 +- swarm/network/pss_test.go | 5 +- .../simulations/discovery/discovery_test.go | 2 +- swarm/network/simulations/overlay.go | 2 +- 8 files changed, 61 insertions(+), 85 deletions(-) diff --git a/p2p/adapters/types.go b/p2p/adapters/types.go index a3019c546e..f85b8523e5 100644 --- a/p2p/adapters/types.go +++ b/p2p/adapters/types.go @@ -67,8 +67,6 @@ type NodeAdapter interface { Connect([]byte) error Disconnect([]byte) error // Disconnect(*p2p.Peer, p2p.MsgReadWriter) - LocalAddr() []byte - ParseAddr([]byte, string) ([]byte, error) } type ProtocolRunner interface { diff --git a/p2p/protocols/protocol_test.go b/p2p/protocols/protocol_test.go index 14a11bb79a..f4b57d8eed 100644 --- a/p2p/protocols/protocol_test.go +++ b/p2p/protocols/protocol_test.go @@ -56,66 +56,64 @@ const networkId = "420" // newProtocol sets up a protocol // the run function here demonstrates a typical protocol using peerPool, handshake // and messages registered to handlers -func newProtocol(pp *p2ptest.TestPeerPool) func(adapters.NodeAdapter) adapters.ProtoCall { +func newProtocol(pp *p2ptest.TestPeerPool) adapters.ProtoCall { ct := NewCodeMap("test", 42, 1024, &protoHandshake{}, &hs0{}, &kill{}, &drop{}) - return func(na adapters.NodeAdapter) adapters.ProtoCall { - return func(p *p2p.Peer, rw p2p.MsgReadWriter) error { - peer := NewPeer(p, ct, rw) + return func(p *p2p.Peer, rw p2p.MsgReadWriter) error { + peer := NewPeer(p, ct, rw) - // demonstrates use of peerPool, killing another peer connection as a response to a message - peer.Register(&kill{}, func(msg interface{}) error { - id := msg.(*kill).C - pp.Get(id).Drop(fmt.Errorf("killed")) - glog.V(logger.Detail).Infof("id %v killed", id) - return nil - }) + // demonstrates use of peerPool, killing another peer connection as a response to a message + peer.Register(&kill{}, func(msg interface{}) error { + id := msg.(*kill).C + pp.Get(id).Drop(fmt.Errorf("killed")) + glog.V(logger.Detail).Infof("id %v killed", id) + return nil + }) - // for testing we can trigger self induced disconnect upon receiving drop message - peer.Register(&drop{}, func(msg interface{}) error { - glog.V(logger.Detail).Infof("dropped") - return fmt.Errorf("dropped") - }) - - // initiate one-off protohandshake and check validity - phs := &protoHandshake{ct.Version, networkId} - hs, err := peer.Handshake(phs) - if err != nil { - return err - } - rhs := hs.(*protoHandshake) - err = checkProtoHandshake(phs, rhs) - if err != nil { - return err - } - - lhs := &hs0{42} - // module handshake demonstrating a simple repeatable exchange of same-type message - hs, err = peer.Handshake(lhs) - if err != nil { - return err - } - - if rmhs := hs.(*hs0); rmhs.C > lhs.C { - return fmt.Errorf("handshake mismatch remote %v > local %v", rmhs.C, lhs.C) - } - - peer.Register(lhs, func(msg interface{}) error { - rhs := msg.(*hs0) - if rhs.C > lhs.C { - return fmt.Errorf("handshake mismatch remote %v > local %v", rhs.C, lhs.C) - } - lhs.C += rhs.C - return peer.Send(lhs) - }) - - glog.V(logger.Detail).Infof("adding peer %v", peer) - pp.Add(peer) - defer pp.Remove(peer) - err = peer.Run() - glog.V(logger.Detail).Infof("peer %v protocol quitting: %v", peer, err) + // for testing we can trigger self induced disconnect upon receiving drop message + peer.Register(&drop{}, func(msg interface{}) error { + glog.V(logger.Detail).Infof("dropped") + return fmt.Errorf("dropped") + }) + // initiate one-off protohandshake and check validity + phs := &protoHandshake{ct.Version, networkId} + hs, err := peer.Handshake(phs) + if err != nil { return err } + rhs := hs.(*protoHandshake) + err = checkProtoHandshake(phs, rhs) + if err != nil { + return err + } + + lhs := &hs0{42} + // module handshake demonstrating a simple repeatable exchange of same-type message + hs, err = peer.Handshake(lhs) + if err != nil { + return err + } + + if rmhs := hs.(*hs0); rmhs.C > lhs.C { + return fmt.Errorf("handshake mismatch remote %v > local %v", rmhs.C, lhs.C) + } + + peer.Register(lhs, func(msg interface{}) error { + rhs := msg.(*hs0) + if rhs.C > lhs.C { + return fmt.Errorf("handshake mismatch remote %v > local %v", rhs.C, lhs.C) + } + lhs.C += rhs.C + return peer.Send(lhs) + }) + + glog.V(logger.Detail).Infof("adding peer %v", peer) + pp.Add(peer) + defer pp.Remove(peer) + err = peer.Run() + glog.V(logger.Detail).Infof("peer %v protocol quitting: %v", peer, err) + + return err } } diff --git a/p2p/testing/protocoltester.go b/p2p/testing/protocoltester.go index 2c20b1798d..07657d9a89 100644 --- a/p2p/testing/protocoltester.go +++ b/p2p/testing/protocoltester.go @@ -15,14 +15,14 @@ type ProtocolTester struct { na adapters.NodeAdapter } -func NewProtocolTester(t *testing.T, id *adapters.NodeId, n int, run func(id adapters.NodeAdapter) adapters.ProtoCall) *ProtocolTester { +func NewProtocolTester(t *testing.T, id *adapters.NodeId, n int, run adapters.ProtoCall) *ProtocolTester { net := simulations.NewNetwork(&simulations.NetworkConfig{}) naf := func(conf *simulations.NodeConfig) adapters.NodeAdapter { na := adapters.NewSimNode(conf.Id, net) if conf.Id.NodeID == id.NodeID { glog.V(logger.Detail).Infof("adapter run function set to protocol for node %v (=%v)", conf.Id, id) - na.Run = run(na) + na.Run = run } return na } diff --git a/swarm/network/protocol.go b/swarm/network/protocol.go index ebc451d2d9..9f5bd053b1 100644 --- a/swarm/network/protocol.go +++ b/swarm/network/protocol.go @@ -21,7 +21,6 @@ import ( "time" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/logger/glog" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p/adapters" @@ -40,7 +39,6 @@ const ( // bzz is the bzz protocol view of a protocols.Peer (itself an extension of p2p.Peer) type bzzPeer struct { *protocols.Peer - network adapters.NodeAdapter localAddr *peerAddr *peerAddr // remote address lastActive time.Time @@ -79,14 +77,11 @@ func BzzCodeMap(msgs ...interface{}) *protocols.CodeMap { // Bzz is the protocol constructor // returns p2p.Protocol that is to be offered by the node.Service -func Bzz(localAddr []byte, na adapters.NodeAdapter, ct *protocols.CodeMap, services func(Peer) error, peerInfo func(id discover.NodeID) interface{}, nodeInfo func() interface{}) *p2p.Protocol { +func Bzz(oAddr, uAddr []byte, ct *protocols.CodeMap, services func(Peer) error, peerInfo func(id discover.NodeID) interface{}, nodeInfo func() interface{}) *p2p.Protocol { run := func(p *protocols.Peer) error { - addr := &peerAddr{localAddr, na.LocalAddr()} - bee := &bzzPeer{ Peer: p, - network: na, - localAddr: addr, + localAddr: &peerAddr{oAddr, uAddr}, } // protocol handshake and its validation // sets remote peer address @@ -193,22 +188,13 @@ func (self *bzzPeer) bzzHandshake() error { } rhs := hs.(*bzzHandshake) + self.peerAddr = rhs.Addr err = checkBzzHandshake(rhs) if err != nil { glog.V(6).Infof("handshake between %v and %v failed: %v", self.localAddr, self.peerAddr, err) return err } - addr := rhs.Addr - // Addr returns the remote address of the network connection. - // with rlpx use this to set adverrtised IP - self.localAddr.UAddr, err = self.network.ParseAddr(self.localAddr.UAddr, self.RemoteAddr().String()) - if err != nil { - return err - } - - glog.V(logger.Debug).Infof("self: advertised net address: %x, local address: %v\npeer: advertised: %v, remote address: %v\n", self.network.LocalAddr(), self.LocalAddr(), NodeId(addr), self.RemoteAddr()) - self.peerAddr = addr return nil } diff --git a/swarm/network/protocol_test.go b/swarm/network/protocol_test.go index b09db764e7..9c5b3b3933 100644 --- a/swarm/network/protocol_test.go +++ b/swarm/network/protocol_test.go @@ -47,10 +47,7 @@ func newBzzBaseTester(t *testing.T, n int, addr *peerAddr, ct *protocols.CodeMap return services(p) } - protocall := func(na adapters.NodeAdapter) adapters.ProtoCall { - protocol := Bzz(addr.OverlayAddr(), na, ct, srv, nil, nil) - return protocol.Run - } + protocall := Bzz(addr.OverlayAddr(), addr.UnderlayAddr(), ct, srv, nil, nil).Run s := p2ptest.NewProtocolTester(t, NodeId(addr), n, protocall) diff --git a/swarm/network/pss_test.go b/swarm/network/pss_test.go index 2ff8acd5ba..3c4df0cbd2 100644 --- a/swarm/network/pss_test.go +++ b/swarm/network/pss_test.go @@ -190,10 +190,7 @@ func newPssBaseTester(t *testing.T, addr *peerAddr, n int) *pssTester { }) return nil } - protocall := func(na adapters.NodeAdapter) adapters.ProtoCall { - protocol := Bzz(addr.OverlayAddr(), na, ct, srv, nil, nil) - return protocol.Run - } + protocall := Bzz(addr.OverlayAddr(), addr.UnderlayAddr(), ct, srv, nil, nil).Run s := p2ptest.NewProtocolTester(t, NodeId(addr), n, protocall) diff --git a/swarm/network/simulations/discovery/discovery_test.go b/swarm/network/simulations/discovery/discovery_test.go index 6860db3ec5..3e93e9093b 100644 --- a/swarm/network/simulations/discovery/discovery_test.go +++ b/swarm/network/simulations/discovery/discovery_test.go @@ -125,7 +125,7 @@ func newNode(id *adapters.NodeId, net *simulations.Network, trigger chan *adapte }) return nil } - nodeAdapter.Run = network.Bzz(addr.OverlayAddr(), nodeAdapter, codeMap, services, nil, nil).Run + nodeAdapter.Run = network.Bzz(addr.OverlayAddr(), addr.UnderlayAddr(), codeMap, services, nil, nil).Run return node } diff --git a/swarm/network/simulations/overlay.go b/swarm/network/simulations/overlay.go index eb842aefa0..79f26211e7 100644 --- a/swarm/network/simulations/overlay.go +++ b/swarm/network/simulations/overlay.go @@ -87,7 +87,7 @@ func (self *Network) NewSimNode(conf *simulations.NodeConfig) adapters.NodeAdapt } ct := network.BzzCodeMap(network.DiscoveryMsgs...) // bzz protocol code map - na.Run = network.Bzz(addr.OverlayAddr(), na, ct, services, nil, nil).Run + na.Run = network.Bzz(addr.OverlayAddr(), addr.UnderlayAddr(), ct, services, nil, nil).Run connect := func(s string) error { return self.Connect(id, adapters.NewNodeIdFromHex(s)) }