forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-19 10:22:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

swarm/network/simulation: port to p2p/enode

Browse source
This commit is contained in:
Felix Lange 2018-09-11 18:57:35 +02:00
parent 86d67eda62
commit d7bd31e1b9
11 changed files with 70 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
swarm/network/simulation/bucket.go
View file

@ -16,15 +16,13 @@
package simulation package simulation
import ( import "github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/discover"
)
// BucketKey is the type that should be used for keys in simulation buckets. // BucketKey is the type that should be used for keys in simulation buckets.
type BucketKey string type BucketKey string
// NodeItem returns an item set in ServiceFunc function for a particualar node. // NodeItem returns an item set in ServiceFunc function for a particualar node.
func (s *Simulation) NodeItem(id discover.NodeID, key interface{}) (value interface{}, ok bool) { func (s *Simulation) NodeItem(id enode.ID, key interface{}) (value interface{}, ok bool) {
s.mu.Lock() s.mu.Lock()
defer s.mu.Unlock() defer s.mu.Unlock()
@ -36,7 +34,7 @@ func (s *Simulation) NodeItem(id discover.NodeID, key interface{}) (value interf
// SetNodeItem sets a new item associated with the node with provided NodeID. // SetNodeItem sets a new item associated with the node with provided NodeID.
// Buckets should be used to avoid managing separate simulation global state. // Buckets should be used to avoid managing separate simulation global state.
func (s *Simulation) SetNodeItem(id discover.NodeID, key interface{}, value interface{}) { func (s *Simulation) SetNodeItem(id enode.ID, key interface{}, value interface{}) {
s.mu.Lock() s.mu.Lock()
defer s.mu.Unlock() defer s.mu.Unlock()
@ -45,12 +43,12 @@ func (s *Simulation) SetNodeItem(id discover.NodeID, key interface{}, value inte
// NodesItems returns a map of items from all nodes that are all set under the // NodesItems returns a map of items from all nodes that are all set under the
// same BucketKey. // same BucketKey.
func (s *Simulation) NodesItems(key interface{}) (values map[discover.NodeID]interface{}) { func (s *Simulation) NodesItems(key interface{}) (values map[enode.ID]interface{}) {
s.mu.RLock() s.mu.RLock()
defer s.mu.RUnlock() defer s.mu.RUnlock()
ids := s.NodeIDs() ids := s.NodeIDs()
values = make(map[discover.NodeID]interface{}, len(ids)) values = make(map[enode.ID]interface{}, len(ids))
for _, id := range ids { for _, id := range ids {
if _, ok := s.buckets[id]; !ok { if _, ok := s.buckets[id]; !ok {
continue continue
@ -63,12 +61,12 @@ func (s *Simulation) NodesItems(key interface{}) (values map[discover.NodeID]int
} }
// UpNodesItems returns a map of items with the same BucketKey from all nodes that are up. // UpNodesItems returns a map of items with the same BucketKey from all nodes that are up.
func (s *Simulation) UpNodesItems(key interface{}) (values map[discover.NodeID]interface{}) { func (s *Simulation) UpNodesItems(key interface{}) (values map[enode.ID]interface{}) {
s.mu.RLock() s.mu.RLock()
defer s.mu.RUnlock() defer s.mu.RUnlock()
ids := s.UpNodeIDs() ids := s.UpNodeIDs()
values = make(map[discover.NodeID]interface{}) values = make(map[enode.ID]interface{})
for _, id := range ids { for _, id := range ids {
if _, ok := s.buckets[id]; !ok { if _, ok := s.buckets[id]; !ok {
continue continue

20
swarm/network/simulation/connect.go
View file

@ -19,14 +19,14 @@ package simulation
import ( import (
"strings" "strings"
"github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/p2p/enode"
) )
// ConnectToPivotNode connects the node with provided NodeID // ConnectToPivotNode connects the node with provided NodeID
// to the pivot node, already set by Simulation.SetPivotNode method. // to the pivot node, already set by Simulation.SetPivotNode method.
// It is useful when constructing a star network topology // It is useful when constructing a star network topology
// when simulation adds and removes nodes dynamically. // when simulation adds and removes nodes dynamically.
func (s *Simulation) ConnectToPivotNode(id discover.NodeID) (err error) { func (s *Simulation) ConnectToPivotNode(id enode.ID) (err error) {
pid := s.PivotNodeID() pid := s.PivotNodeID()
if pid == nil { if pid == nil {
return ErrNoPivotNode return ErrNoPivotNode
@ -38,7 +38,7 @@ func (s *Simulation) ConnectToPivotNode(id discover.NodeID) (err error) {
// to the last node that is up, and avoiding connection to self. // to the last node that is up, and avoiding connection to self.
// It is useful when constructing a chain network topology // It is useful when constructing a chain network topology
// when simulation adds and removes nodes dynamically. // when simulation adds and removes nodes dynamically.
func (s *Simulation) ConnectToLastNode(id discover.NodeID) (err error) { func (s *Simulation) ConnectToLastNode(id enode.ID) (err error) {
ids := s.UpNodeIDs() ids := s.UpNodeIDs()
l := len(ids) l := len(ids)
if l < 2 { if l < 2 {
@ -53,7 +53,7 @@ func (s *Simulation) ConnectToLastNode(id discover.NodeID) (err error) {
// ConnectToRandomNode connects the node with provieded NodeID // ConnectToRandomNode connects the node with provieded NodeID
// to a random node that is up. // to a random node that is up.
func (s *Simulation) ConnectToRandomNode(id discover.NodeID) (err error) { func (s *Simulation) ConnectToRandomNode(id enode.ID) (err error) {
n := s.RandomUpNode(id) n := s.RandomUpNode(id)
if n == nil { if n == nil {
return ErrNodeNotFound return ErrNodeNotFound
@ -64,7 +64,7 @@ func (s *Simulation) ConnectToRandomNode(id discover.NodeID) (err error) {
// ConnectNodesFull connects all nodes one to another. // ConnectNodesFull connects all nodes one to another.
// It provides a complete connectivity in the network // It provides a complete connectivity in the network
// which should be rarely needed. // which should be rarely needed.
func (s *Simulation) ConnectNodesFull(ids []discover.NodeID) (err error) { func (s *Simulation) ConnectNodesFull(ids []enode.ID) (err error) {
if ids == nil { if ids == nil {
ids = s.UpNodeIDs() ids = s.UpNodeIDs()
} }
@ -82,7 +82,7 @@ func (s *Simulation) ConnectNodesFull(ids []discover.NodeID) (err error) {
// ConnectNodesChain connects all nodes in a chain topology. // ConnectNodesChain connects all nodes in a chain topology.
// If ids argument is nil, all nodes that are up will be connected. // If ids argument is nil, all nodes that are up will be connected.
func (s *Simulation) ConnectNodesChain(ids []discover.NodeID) (err error) { func (s *Simulation) ConnectNodesChain(ids []enode.ID) (err error) {
if ids == nil { if ids == nil {
ids = s.UpNodeIDs() ids = s.UpNodeIDs()
} }
@ -98,7 +98,7 @@ func (s *Simulation) ConnectNodesChain(ids []discover.NodeID) (err error) {
// ConnectNodesRing connects all nodes in a ring topology. // ConnectNodesRing connects all nodes in a ring topology.
// If ids argument is nil, all nodes that are up will be connected. // If ids argument is nil, all nodes that are up will be connected.
func (s *Simulation) ConnectNodesRing(ids []discover.NodeID) (err error) { func (s *Simulation) ConnectNodesRing(ids []enode.ID) (err error) {
if ids == nil { if ids == nil {
ids = s.UpNodeIDs() ids = s.UpNodeIDs()
} }
@ -118,7 +118,7 @@ func (s *Simulation) ConnectNodesRing(ids []discover.NodeID) (err error) {
// ConnectNodesStar connects all nodes in a star topology // ConnectNodesStar connects all nodes in a star topology
// with the center at provided NodeID. // with the center at provided NodeID.
// If ids argument is nil, all nodes that are up will be connected. // If ids argument is nil, all nodes that are up will be connected.
func (s *Simulation) ConnectNodesStar(id discover.NodeID, ids []discover.NodeID) (err error) { func (s *Simulation) ConnectNodesStar(id enode.ID, ids []enode.ID) (err error) {
if ids == nil { if ids == nil {
ids = s.UpNodeIDs() ids = s.UpNodeIDs()
} }
@ -138,7 +138,7 @@ func (s *Simulation) ConnectNodesStar(id discover.NodeID, ids []discover.NodeID)
// ConnectNodesStarPivot connects all nodes in a star topology // ConnectNodesStarPivot connects all nodes in a star topology
// with the center at already set pivot node. // with the center at already set pivot node.
// If ids argument is nil, all nodes that are up will be connected. // If ids argument is nil, all nodes that are up will be connected.
func (s *Simulation) ConnectNodesStarPivot(ids []discover.NodeID) (err error) { func (s *Simulation) ConnectNodesStarPivot(ids []enode.ID) (err error) {
id := s.PivotNodeID() id := s.PivotNodeID()
if id == nil { if id == nil {
return ErrNoPivotNode return ErrNoPivotNode
@ -147,7 +147,7 @@ func (s *Simulation) ConnectNodesStarPivot(ids []discover.NodeID) (err error) {
} }
// connect connects two nodes but ignores already connected error. // connect connects two nodes but ignores already connected error.
func (s *Simulation) connect(oneID, otherID discover.NodeID) error { func (s *Simulation) connect(oneID, otherID enode.ID) error {
return ignoreAlreadyConnectedErr(s.Net.Connect(oneID, otherID)) return ignoreAlreadyConnectedErr(s.Net.Connect(oneID, otherID))
} }

10
swarm/network/simulation/connect_test.go
View file

@ -19,7 +19,7 @@ package simulation
import ( import (
"testing" "testing"
"github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/p2p/enode"
) )
func TestConnectToPivotNode(t *testing.T) { func TestConnectToPivotNode(t *testing.T) {
@ -143,7 +143,7 @@ func TestConnectNodesFull(t *testing.T) {
testFull(t, sim, ids) testFull(t, sim, ids)
} }
func testFull(t *testing.T, sim *Simulation, ids []discover.NodeID) { func testFull(t *testing.T, sim *Simulation, ids []enode.ID) {
n := len(ids) n := len(ids)
var cc int var cc int
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
@ -182,7 +182,7 @@ func TestConnectNodesChain(t *testing.T) {
testChain(t, sim, ids) testChain(t, sim, ids)
} }
func testChain(t *testing.T, sim *Simulation, ids []discover.NodeID) { func testChain(t *testing.T, sim *Simulation, ids []enode.ID) {
n := len(ids) n := len(ids)
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ { for j := i + 1; j < n; j++ {
@ -221,7 +221,7 @@ func TestConnectNodesRing(t *testing.T) {
testRing(t, sim, ids) testRing(t, sim, ids)
} }
func testRing(t *testing.T, sim *Simulation, ids []discover.NodeID) { func testRing(t *testing.T, sim *Simulation, ids []enode.ID) {
n := len(ids) n := len(ids)
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ { for j := i + 1; j < n; j++ {
@ -262,7 +262,7 @@ func TestConnectToNodesStar(t *testing.T) {
testStar(t, sim, ids, centerIndex) testStar(t, sim, ids, centerIndex)
} }
func testStar(t *testing.T, sim *Simulation, ids []discover.NodeID, centerIndex int) { func testStar(t *testing.T, sim *Simulation, ids []enode.ID, centerIndex int) {
n := len(ids) n := len(ids)
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ { for j := i + 1; j < n; j++ {

9
swarm/network/simulation/events.go
View file

@ -20,15 +20,14 @@ import (
"context" "context"
"sync" "sync"
"github.com/ethereum/go-ethereum/p2p/discover"
"github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/p2p/enode"
) )
// PeerEvent is the type of the channel returned by Simulation.PeerEvents. // PeerEvent is the type of the channel returned by Simulation.PeerEvents.
type PeerEvent struct { type PeerEvent struct {
// NodeID is the ID of node that the event is caught on. // NodeID is the ID of node that the event is caught on.
NodeID discover.NodeID NodeID enode.ID
// Event is the event that is caught. // Event is the event that is caught.
Event *p2p.PeerEvent Event *p2p.PeerEvent
// Error is the error that may have happened during event watching. // Error is the error that may have happened during event watching.
@ -69,7 +68,7 @@ func (f *PeerEventsFilter) MsgCode(c uint64) *PeerEventsFilter {
// PeerEvents returns a channel of events that are captured by admin peerEvents // PeerEvents returns a channel of events that are captured by admin peerEvents
// subscription nodes with provided NodeIDs. Additional filters can be set to ignore // subscription nodes with provided NodeIDs. Additional filters can be set to ignore
// events that are not relevant. // events that are not relevant.
func (s *Simulation) PeerEvents(ctx context.Context, ids []discover.NodeID, filters ...*PeerEventsFilter) <-chan PeerEvent { func (s *Simulation) PeerEvents(ctx context.Context, ids []enode.ID, filters ...*PeerEventsFilter) <-chan PeerEvent {
eventC := make(chan PeerEvent) eventC := make(chan PeerEvent)
// wait group to make sure all subscriptions to admin peerEvents are established // wait group to make sure all subscriptions to admin peerEvents are established
@ -78,7 +77,7 @@ func (s *Simulation) PeerEvents(ctx context.Context, ids []discover.NodeID, filt
for _, id := range ids { for _, id := range ids {
s.shutdownWG.Add(1) s.shutdownWG.Add(1)
subsWG.Add(1) subsWG.Add(1)
go func(id discover.NodeID) { go func(id enode.ID) {
defer s.shutdownWG.Done() defer s.shutdownWG.Done()
client, err := s.Net.GetNode(id).Client() client, err := s.Net.GetNode(id).Client()

2
swarm/network/simulation/example_test.go
View file

@ -36,7 +36,7 @@ import (
func ExampleSimulation_WaitTillHealthy() { func ExampleSimulation_WaitTillHealthy() {
sim := simulation.New(map[string]simulation.ServiceFunc{ sim := simulation.New(map[string]simulation.ServiceFunc{
"bzz": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) { "bzz": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
addr := network.NewAddrFromNodeID(ctx.Config.ID) addr := network.NewAddr(ctx.Config.Node())
hp := network.NewHiveParams() hp := network.NewHiveParams()
hp.Discovery = false hp.Discovery = false
config := &network.BzzConfig{ config := &network.BzzConfig{

11
swarm/network/simulation/kademlia.go
View file

@ -21,10 +21,9 @@ import (
"encoding/hex" "encoding/hex"
"time" "time"
"github.com/ethereum/go-ethereum/p2p/discover"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/swarm/network" "github.com/ethereum/go-ethereum/swarm/network"
) )
@ -34,7 +33,7 @@ var BucketKeyKademlia BucketKey = "kademlia"
// WaitTillHealthy is blocking until the health of all kademlias is true. // WaitTillHealthy is blocking until the health of all kademlias is true.
// If error is not nil, a map of kademlia that was found not healthy is returned. // If error is not nil, a map of kademlia that was found not healthy is returned.
func (s *Simulation) WaitTillHealthy(ctx context.Context, kadMinProxSize int) (ill map[discover.NodeID]*network.Kademlia, err error) { func (s *Simulation) WaitTillHealthy(ctx context.Context, kadMinProxSize int) (ill map[enode.ID]*network.Kademlia, err error) {
// Prepare PeerPot map for checking Kademlia health // Prepare PeerPot map for checking Kademlia health
var ppmap map[string]*network.PeerPot var ppmap map[string]*network.PeerPot
kademlias := s.kademlias() kademlias := s.kademlias()
@ -48,7 +47,7 @@ func (s *Simulation) WaitTillHealthy(ctx context.Context, kadMinProxSize int) (i
ticker := time.NewTicker(200 * time.Millisecond) ticker := time.NewTicker(200 * time.Millisecond)
defer ticker.Stop() defer ticker.Stop()
ill = make(map[discover.NodeID]*network.Kademlia) ill = make(map[enode.ID]*network.Kademlia)
for { for {
select { select {
case <-ctx.Done(): case <-ctx.Done():
@ -82,9 +81,9 @@ func (s *Simulation) WaitTillHealthy(ctx context.Context, kadMinProxSize int) (i
// kademlias returns all Kademlia instances that are set // kademlias returns all Kademlia instances that are set
// in simulation bucket. // in simulation bucket.
func (s *Simulation) kademlias() (ks map[discover.NodeID]*network.Kademlia) { func (s *Simulation) kademlias() (ks map[enode.ID]*network.Kademlia) {
items := s.UpNodesItems(BucketKeyKademlia) items := s.UpNodesItems(BucketKeyKademlia)
ks = make(map[discover.NodeID]*network.Kademlia, len(items)) ks = make(map[enode.ID]*network.Kademlia, len(items))
for id, v := range items { for id, v := range items {
k, ok := v.(*network.Kademlia) k, ok := v.(*network.Kademlia)
if !ok { if !ok {

2
swarm/network/simulation/kademlia_test.go
View file

@ -30,7 +30,7 @@ import (
func TestWaitTillHealthy(t *testing.T) { func TestWaitTillHealthy(t *testing.T) {
sim := New(map[string]ServiceFunc{ sim := New(map[string]ServiceFunc{
"bzz": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) { "bzz": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
addr := network.NewAddrFromNodeID(ctx.Config.ID) addr := network.NewAddr(ctx.Config.Node())
hp := network.NewHiveParams() hp := network.NewHiveParams()
hp.Discovery = false hp.Discovery = false
config := &network.BzzConfig{ config := &network.BzzConfig{

52
swarm/network/simulation/node.go
View file

@ -25,15 +25,15 @@ import (
"time" "time"
"github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/simulations" "github.com/ethereum/go-ethereum/p2p/simulations"
"github.com/ethereum/go-ethereum/p2p/simulations/adapters" "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
) )
// NodeIDs returns NodeIDs for all nodes in the network. // NodeIDs returns NodeIDs for all nodes in the network.
func (s *Simulation) NodeIDs() (ids []discover.NodeID) { func (s *Simulation) NodeIDs() (ids []enode.ID) {
nodes := s.Net.GetNodes() nodes := s.Net.GetNodes()
ids = make([]discover.NodeID, len(nodes)) ids = make([]enode.ID, len(nodes))
for i, node := range nodes { for i, node := range nodes {
ids[i] = node.ID() ids[i] = node.ID()
} }
@ -41,7 +41,7 @@ func (s *Simulation) NodeIDs() (ids []discover.NodeID) {
} }
// UpNodeIDs returns NodeIDs for nodes that are up in the network. // UpNodeIDs returns NodeIDs for nodes that are up in the network.
func (s *Simulation) UpNodeIDs() (ids []discover.NodeID) { func (s *Simulation) UpNodeIDs() (ids []enode.ID) {
nodes := s.Net.GetNodes() nodes := s.Net.GetNodes()
for _, node := range nodes { for _, node := range nodes {
if node.Up { if node.Up {
@ -52,7 +52,7 @@ func (s *Simulation) UpNodeIDs() (ids []discover.NodeID) {
} }
// DownNodeIDs returns NodeIDs for nodes that are stopped in the network. // DownNodeIDs returns NodeIDs for nodes that are stopped in the network.
func (s *Simulation) DownNodeIDs() (ids []discover.NodeID) { func (s *Simulation) DownNodeIDs() (ids []enode.ID) {
nodes := s.Net.GetNodes() nodes := s.Net.GetNodes()
for _, node := range nodes { for _, node := range nodes {
if !node.Up { if !node.Up {
@ -88,7 +88,7 @@ func AddNodeWithService(serviceName string) AddNodeOption {
// applies provided options to the config and adds the node to network. // applies provided options to the config and adds the node to network.
// By default all services will be started on a node. If one or more // By default all services will be started on a node. If one or more
// AddNodeWithService option are provided, only specified services will be started. // AddNodeWithService option are provided, only specified services will be started.
func (s *Simulation) AddNode(opts ...AddNodeOption) (id discover.NodeID, err error) { func (s *Simulation) AddNode(opts ...AddNodeOption) (id enode.ID, err error) {
conf := adapters.RandomNodeConfig() conf := adapters.RandomNodeConfig()
for _, o := range opts { for _, o := range opts {
o(conf) o(conf)
@ -105,8 +105,8 @@ func (s *Simulation) AddNode(opts ...AddNodeOption) (id discover.NodeID, err err
// AddNodes creates new nodes with random configurations, // AddNodes creates new nodes with random configurations,
// applies provided options to the config and adds nodes to network. // applies provided options to the config and adds nodes to network.
func (s *Simulation) AddNodes(count int, opts ...AddNodeOption) (ids []discover.NodeID, err error) { func (s *Simulation) AddNodes(count int, opts ...AddNodeOption) (ids []enode.ID, err error) {
ids = make([]discover.NodeID, 0, count) ids = make([]enode.ID, 0, count)
for i := 0; i < count; i++ { for i := 0; i < count; i++ {
id, err := s.AddNode(opts...) id, err := s.AddNode(opts...)
if err != nil { if err != nil {
@ -119,7 +119,7 @@ func (s *Simulation) AddNodes(count int, opts ...AddNodeOption) (ids []discover.
// AddNodesAndConnectFull is a helpper method that combines // AddNodesAndConnectFull is a helpper method that combines
// AddNodes and ConnectNodesFull. Only new nodes will be connected. // AddNodes and ConnectNodesFull. Only new nodes will be connected.
func (s *Simulation) AddNodesAndConnectFull(count int, opts ...AddNodeOption) (ids []discover.NodeID, err error) { func (s *Simulation) AddNodesAndConnectFull(count int, opts ...AddNodeOption) (ids []enode.ID, err error) {
if count < 2 { if count < 2 {
return nil, errors.New("count of nodes must be at least 2") return nil, errors.New("count of nodes must be at least 2")
} }
@ -137,7 +137,7 @@ func (s *Simulation) AddNodesAndConnectFull(count int, opts ...AddNodeOption) (i
// AddNodesAndConnectChain is a helpper method that combines // AddNodesAndConnectChain is a helpper method that combines
// AddNodes and ConnectNodesChain. The chain will be continued from the last // AddNodes and ConnectNodesChain. The chain will be continued from the last
// added node, if there is one in simulation using ConnectToLastNode method. // added node, if there is one in simulation using ConnectToLastNode method.
func (s *Simulation) AddNodesAndConnectChain(count int, opts ...AddNodeOption) (ids []discover.NodeID, err error) { func (s *Simulation) AddNodesAndConnectChain(count int, opts ...AddNodeOption) (ids []enode.ID, err error) {
if count < 2 { if count < 2 {
return nil, errors.New("count of nodes must be at least 2") return nil, errors.New("count of nodes must be at least 2")
} }
@ -153,7 +153,7 @@ func (s *Simulation) AddNodesAndConnectChain(count int, opts ...AddNodeOption) (
if err != nil { if err != nil {
return nil, err return nil, err
} }
ids = append([]discover.NodeID{id}, ids...) ids = append([]enode.ID{id}, ids...)
err = s.ConnectNodesChain(ids) err = s.ConnectNodesChain(ids)
if err != nil { if err != nil {
return nil, err return nil, err
@ -163,7 +163,7 @@ func (s *Simulation) AddNodesAndConnectChain(count int, opts ...AddNodeOption) (
// AddNodesAndConnectRing is a helpper method that combines // AddNodesAndConnectRing is a helpper method that combines
// AddNodes and ConnectNodesRing. // AddNodes and ConnectNodesRing.
func (s *Simulation) AddNodesAndConnectRing(count int, opts ...AddNodeOption) (ids []discover.NodeID, err error) { func (s *Simulation) AddNodesAndConnectRing(count int, opts ...AddNodeOption) (ids []enode.ID, err error) {
if count < 2 { if count < 2 {
return nil, errors.New("count of nodes must be at least 2") return nil, errors.New("count of nodes must be at least 2")
} }
@ -180,7 +180,7 @@ func (s *Simulation) AddNodesAndConnectRing(count int, opts ...AddNodeOption) (i
// AddNodesAndConnectStar is a helpper method that combines // AddNodesAndConnectStar is a helpper method that combines
// AddNodes and ConnectNodesStar. // AddNodes and ConnectNodesStar.
func (s *Simulation) AddNodesAndConnectStar(count int, opts ...AddNodeOption) (ids []discover.NodeID, err error) { func (s *Simulation) AddNodesAndConnectStar(count int, opts ...AddNodeOption) (ids []enode.ID, err error) {
if count < 2 { if count < 2 {
return nil, errors.New("count of nodes must be at least 2") return nil, errors.New("count of nodes must be at least 2")
} }
@ -246,7 +246,7 @@ func (s *Simulation) UploadSnapshot(snapshotFile string, opts ...AddNodeOption)
// differently then other nodes in test. SetPivotNode and // differently then other nodes in test. SetPivotNode and
// PivotNodeID are just a convenient functions to set and // PivotNodeID are just a convenient functions to set and
// retrieve it. // retrieve it.
func (s *Simulation) SetPivotNode(id discover.NodeID) { func (s *Simulation) SetPivotNode(id enode.ID) {
s.mu.Lock() s.mu.Lock()
defer s.mu.Unlock() defer s.mu.Unlock()
s.pivotNodeID = &id s.pivotNodeID = &id
@ -254,19 +254,19 @@ func (s *Simulation) SetPivotNode(id discover.NodeID) {
// PivotNodeID returns NodeID of the pivot node set by // PivotNodeID returns NodeID of the pivot node set by
// Simulation.SetPivotNode method. // Simulation.SetPivotNode method.
func (s *Simulation) PivotNodeID() (id *discover.NodeID) { func (s *Simulation) PivotNodeID() (id *enode.ID) {
s.mu.Lock() s.mu.Lock()
defer s.mu.Unlock() defer s.mu.Unlock()
return s.pivotNodeID return s.pivotNodeID
} }
// StartNode starts a node by NodeID. // StartNode starts a node by NodeID.
func (s *Simulation) StartNode(id discover.NodeID) (err error) { func (s *Simulation) StartNode(id enode.ID) (err error) {
return s.Net.Start(id) return s.Net.Start(id)
} }
// StartRandomNode starts a random node. // StartRandomNode starts a random node.
func (s *Simulation) StartRandomNode() (id discover.NodeID, err error) { func (s *Simulation) StartRandomNode() (id enode.ID, err error) {
n := s.randomDownNode() n := s.randomDownNode()
if n == nil { if n == nil {
return id, ErrNodeNotFound return id, ErrNodeNotFound
@ -275,8 +275,8 @@ func (s *Simulation) StartRandomNode() (id discover.NodeID, err error) {
} }
// StartRandomNodes starts random nodes. // StartRandomNodes starts random nodes.
func (s *Simulation) StartRandomNodes(count int) (ids []discover.NodeID, err error) { func (s *Simulation) StartRandomNodes(count int) (ids []enode.ID, err error) {
ids = make([]discover.NodeID, 0, count) ids = make([]enode.ID, 0, count)
downIDs := s.DownNodeIDs() downIDs := s.DownNodeIDs()
for i := 0; i < count; i++ { for i := 0; i < count; i++ {
n := s.randomNode(downIDs, ids...) n := s.randomNode(downIDs, ids...)
@ -293,12 +293,12 @@ func (s *Simulation) StartRandomNodes(count int) (ids []discover.NodeID, err err
} }
// StopNode stops a node by NodeID. // StopNode stops a node by NodeID.
func (s *Simulation) StopNode(id discover.NodeID) (err error) { func (s *Simulation) StopNode(id enode.ID) (err error) {
return s.Net.Stop(id) return s.Net.Stop(id)
} }
// StopRandomNode stops a random node. // StopRandomNode stops a random node.
func (s *Simulation) StopRandomNode() (id discover.NodeID, err error) { func (s *Simulation) StopRandomNode() (id enode.ID, err error) {
n := s.RandomUpNode() n := s.RandomUpNode()
if n == nil { if n == nil {
return id, ErrNodeNotFound return id, ErrNodeNotFound
@ -307,8 +307,8 @@ func (s *Simulation) StopRandomNode() (id discover.NodeID, err error) {
} }
// StopRandomNodes stops random nodes. // StopRandomNodes stops random nodes.
func (s *Simulation) StopRandomNodes(count int) (ids []discover.NodeID, err error) { func (s *Simulation) StopRandomNodes(count int) (ids []enode.ID, err error) {
ids = make([]discover.NodeID, 0, count) ids = make([]enode.ID, 0, count)
upIDs := s.UpNodeIDs() upIDs := s.UpNodeIDs()
for i := 0; i < count; i++ { for i := 0; i < count; i++ {
n := s.randomNode(upIDs, ids...) n := s.randomNode(upIDs, ids...)
@ -331,17 +331,17 @@ func init() {
// RandomUpNode returns a random SimNode that is up. // RandomUpNode returns a random SimNode that is up.
// Arguments are NodeIDs for nodes that should not be returned. // Arguments are NodeIDs for nodes that should not be returned.
func (s *Simulation) RandomUpNode(exclude ...discover.NodeID) *adapters.SimNode { func (s *Simulation) RandomUpNode(exclude ...enode.ID) *adapters.SimNode {
return s.randomNode(s.UpNodeIDs(), exclude...) return s.randomNode(s.UpNodeIDs(), exclude...)
} }
// randomDownNode returns a random SimNode that is not up. // randomDownNode returns a random SimNode that is not up.
func (s *Simulation) randomDownNode(exclude ...discover.NodeID) *adapters.SimNode { func (s *Simulation) randomDownNode(exclude ...enode.ID) *adapters.SimNode {
return s.randomNode(s.DownNodeIDs(), exclude...) return s.randomNode(s.DownNodeIDs(), exclude...)
} }
// randomNode returns a random SimNode from the slice of NodeIDs. // randomNode returns a random SimNode from the slice of NodeIDs.
func (s *Simulation) randomNode(ids []discover.NodeID, exclude ...discover.NodeID) *adapters.SimNode { func (s *Simulation) randomNode(ids []enode.ID, exclude ...enode.ID) *adapters.SimNode {
for _, e := range exclude { for _, e := range exclude {
var i int var i int
for _, id := range ids { for _, id := range ids {

6
swarm/network/simulation/node_test.go
View file

@ -25,7 +25,7 @@ import (
"github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/simulations/adapters" "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
"github.com/ethereum/go-ethereum/swarm/network" "github.com/ethereum/go-ethereum/swarm/network"
) )
@ -75,7 +75,7 @@ func TestUpDownNodeIDs(t *testing.T) {
} }
} }
func equalNodeIDs(one, other []discover.NodeID) bool { func equalNodeIDs(one, other []enode.ID) bool {
if len(one) != len(other) { if len(one) != len(other) {
return false return false
} }
@ -244,7 +244,7 @@ func TestUploadSnapshot(t *testing.T) {
log.Debug("Creating simulation") log.Debug("Creating simulation")
s := New(map[string]ServiceFunc{ s := New(map[string]ServiceFunc{
"bzz": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) { "bzz": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
addr := network.NewAddrFromNodeID(ctx.Config.ID) addr := network.NewAddr(ctx.Config.Node())
hp := network.NewHiveParams() hp := network.NewHiveParams()
hp.Discovery = false hp.Discovery = false
config := &network.BzzConfig{ config := &network.BzzConfig{

8
swarm/network/simulation/service.go
View file

@ -18,13 +18,13 @@ package simulation
import ( import (
"github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/simulations/adapters" "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
) )
// Service returns a single Service by name on a particular node // Service returns a single Service by name on a particular node
// with provided id. // with provided id.
func (s *Simulation) Service(name string, id discover.NodeID) node.Service { func (s *Simulation) Service(name string, id enode.ID) node.Service {
simNode, ok := s.Net.GetNode(id).Node.(*adapters.SimNode) simNode, ok := s.Net.GetNode(id).Node.(*adapters.SimNode)
if !ok { if !ok {
return nil return nil
@ -48,9 +48,9 @@ func (s *Simulation) RandomService(name string) node.Service {
// Services returns all services with a provided name // Services returns all services with a provided name
// from nodes that are up. // from nodes that are up.
func (s *Simulation) Services(name string) (services map[discover.NodeID]node.Service) { func (s *Simulation) Services(name string) (services map[enode.ID]node.Service) {
nodes := s.Net.GetNodes() nodes := s.Net.GetNodes()
services = make(map[discover.NodeID]node.Service) services = make(map[enode.ID]node.Service)
for _, node := range nodes { for _, node := range nodes {
if !node.Up { if !node.Up {
continue continue

8
swarm/network/simulation/simulation.go
View file

@ -25,7 +25,7 @@ import (
"github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/simulations" "github.com/ethereum/go-ethereum/p2p/simulations"
"github.com/ethereum/go-ethereum/p2p/simulations/adapters" "github.com/ethereum/go-ethereum/p2p/simulations/adapters"
) )
@ -45,8 +45,8 @@ type Simulation struct {
serviceNames []string serviceNames []string
cleanupFuncs []func() cleanupFuncs []func()
buckets map[discover.NodeID]*sync.Map buckets map[enode.ID]*sync.Map
pivotNodeID *discover.NodeID pivotNodeID *enode.ID
shutdownWG sync.WaitGroup shutdownWG sync.WaitGroup
done chan struct{} done chan struct{}
mu sync.RWMutex mu sync.RWMutex
@ -70,7 +70,7 @@ type ServiceFunc func(ctx *adapters.ServiceContext, bucket *sync.Map) (s node.Se
// simulations.Network initialized with provided services. // simulations.Network initialized with provided services.
func New(services map[string]ServiceFunc) (s *Simulation) { func New(services map[string]ServiceFunc) (s *Simulation) {
s = &Simulation{ s = &Simulation{
buckets: make(map[discover.NodeID]*sync.Map), buckets: make(map[enode.ID]*sync.Map),
done: make(chan struct{}), done: make(chan struct{}),
} }