From 7c59c1356a93e386c85bee004e21fcb4483a4b91 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Milo=C5=A1=20=C5=BDivkovi=C4=87?= Date: Sat, 16 Nov 2024 12:51:53 +0900 Subject: [PATCH] Save unit test progress --- gno.land/cmd/gnoland/secrets_get.go | 3 +- tm2/pkg/bft/mempool/reactor.go | 22 +-- tm2/pkg/bft/mempool/reactor_test.go | 220 ++++++++++++++++++++++++---- tm2/pkg/bft/node/node.go | 8 +- tm2/pkg/bft/rpc/client/local.go | 8 - tm2/pkg/bft/rpc/core/net.go | 42 +----- tm2/pkg/bft/rpc/core/net_test.go | 77 ---------- tm2/pkg/bft/rpc/core/pipe.go | 3 - tm2/pkg/bft/rpc/core/routes.go | 2 - tm2/pkg/p2p/discovery/mock_test.go | 19 ++- tm2/pkg/p2p/events/doc.go | 3 + tm2/pkg/p2p/events/events.go | 104 +++++++++++++ tm2/pkg/p2p/events/events_test.go | 94 ++++++++++++ tm2/pkg/p2p/events/types.go | 39 +++++ tm2/pkg/p2p/mock_test.go | 8 - tm2/pkg/p2p/set.go | 18 +-- tm2/pkg/p2p/set_test.go | 48 ------ tm2/pkg/p2p/switch.go | 29 +++- tm2/pkg/p2p/switch_test.go | 38 ++--- tm2/pkg/p2p/types.go | 5 +- 20 files changed, 517 insertions(+), 273 deletions(-) delete mode 100644 tm2/pkg/bft/rpc/core/net_test.go create mode 100644 tm2/pkg/p2p/events/doc.go create mode 100644 tm2/pkg/p2p/events/events.go create mode 100644 tm2/pkg/p2p/events/events_test.go create mode 100644 tm2/pkg/p2p/events/types.go diff --git a/gno.land/cmd/gnoland/secrets_get.go b/gno.land/cmd/gnoland/secrets_get.go index 64eb48f7d27..0a0a714f6ee 100644 --- a/gno.land/cmd/gnoland/secrets_get.go +++ b/gno.land/cmd/gnoland/secrets_get.go @@ -12,7 +12,6 @@ import ( "github.com/gnolang/gno/tm2/pkg/bft/privval" "github.com/gnolang/gno/tm2/pkg/commands" osm "github.com/gnolang/gno/tm2/pkg/os" - "github.com/gnolang/gno/tm2/pkg/p2p" "github.com/gnolang/gno/tm2/pkg/p2p/types" ) @@ -200,7 +199,7 @@ func readNodeID(path string) (*nodeIDInfo, error) { // constructP2PAddress constructs the P2P address other nodes can use // to connect directly -func constructP2PAddress(nodeID p2p.ID, listenAddress string) string { +func constructP2PAddress(nodeID types.ID, listenAddress string) string { var ( address string parts = strings.SplitN(listenAddress, "://", 2) diff --git a/tm2/pkg/bft/mempool/reactor.go b/tm2/pkg/bft/mempool/reactor.go index 634d92277c2..acb4e351f3f 100644 --- a/tm2/pkg/bft/mempool/reactor.go +++ b/tm2/pkg/bft/mempool/reactor.go @@ -47,12 +47,12 @@ type mempoolIDs struct { // Reserve searches for the next unused ID and assigns it to the // peer. -func (ids *mempoolIDs) ReserveForPeer(peer p2p.Peer) { +func (ids *mempoolIDs) ReserveForPeer(id p2pTypes.ID) { ids.mtx.Lock() defer ids.mtx.Unlock() curID := ids.nextPeerID() - ids.peerMap[peer.ID()] = curID + ids.peerMap[id] = curID ids.activeIDs[curID] = struct{}{} } @@ -74,23 +74,23 @@ func (ids *mempoolIDs) nextPeerID() uint16 { } // Reclaim returns the ID reserved for the peer back to unused pool. -func (ids *mempoolIDs) Reclaim(peer p2p.Peer) { +func (ids *mempoolIDs) Reclaim(id p2pTypes.ID) { ids.mtx.Lock() defer ids.mtx.Unlock() - removedID, ok := ids.peerMap[peer.ID()] + removedID, ok := ids.peerMap[id] if ok { delete(ids.activeIDs, removedID) - delete(ids.peerMap, peer.ID()) + delete(ids.peerMap, id) } } // GetForPeer returns an ID reserved for the peer. -func (ids *mempoolIDs) GetForPeer(peer p2p.Peer) uint16 { +func (ids *mempoolIDs) GetForPeer(id p2pTypes.ID) uint16 { ids.mtx.RLock() defer ids.mtx.RUnlock() - return ids.peerMap[peer.ID()] + return ids.peerMap[id] } func newMempoolIDs() *mempoolIDs { @@ -140,13 +140,13 @@ func (memR *Reactor) GetChannels() []*p2p.ChannelDescriptor { // AddPeer implements Reactor. // It starts a broadcast routine ensuring all txs are forwarded to the given peer. func (memR *Reactor) AddPeer(peer p2p.Peer) { - memR.ids.ReserveForPeer(peer) + memR.ids.ReserveForPeer(peer.ID()) go memR.broadcastTxRoutine(peer) } // RemovePeer implements Reactor. func (memR *Reactor) RemovePeer(peer p2p.Peer, reason interface{}) { - memR.ids.Reclaim(peer) + memR.ids.Reclaim(peer.ID()) // broadcast routine checks if peer is gone and returns } @@ -163,7 +163,7 @@ func (memR *Reactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) { switch msg := msg.(type) { case *TxMessage: - peerID := memR.ids.GetForPeer(src) + peerID := memR.ids.GetForPeer(src.ID()) err := memR.mempool.CheckTxWithInfo(msg.Tx, nil, TxInfo{SenderID: peerID}) if err != nil { memR.Logger.Info("Could not check tx", "tx", txID(msg.Tx), "err", err) @@ -185,7 +185,7 @@ func (memR *Reactor) broadcastTxRoutine(peer p2p.Peer) { return } - peerID := memR.ids.GetForPeer(peer) + peerID := memR.ids.GetForPeer(peer.ID()) var next *clist.CElement for { // In case of both next.NextWaitChan() and peer.Quit() are variable at the same time diff --git a/tm2/pkg/bft/mempool/reactor_test.go b/tm2/pkg/bft/mempool/reactor_test.go index 19403d09b76..d877af3e9cc 100644 --- a/tm2/pkg/bft/mempool/reactor_test.go +++ b/tm2/pkg/bft/mempool/reactor_test.go @@ -1,13 +1,23 @@ package mempool import ( + "context" + "fmt" + "log/slog" "net" + "os" "sync" "testing" "time" "github.com/fortytw2/leaktest" + "github.com/gnolang/gno/tm2/pkg/p2p/conn" + "github.com/gnolang/gno/tm2/pkg/p2p/events" + p2pTypes "github.com/gnolang/gno/tm2/pkg/p2p/types" + "github.com/gnolang/gno/tm2/pkg/versionset" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "golang.org/x/sync/errgroup" "github.com/gnolang/gno/tm2/pkg/bft/abci/example/kvstore" memcfg "github.com/gnolang/gno/tm2/pkg/bft/mempool/config" @@ -17,7 +27,6 @@ import ( "github.com/gnolang/gno/tm2/pkg/log" "github.com/gnolang/gno/tm2/pkg/p2p" p2pcfg "github.com/gnolang/gno/tm2/pkg/p2p/config" - "github.com/gnolang/gno/tm2/pkg/p2p/mock" "github.com/gnolang/gno/tm2/pkg/testutils" ) @@ -39,26 +48,178 @@ func (ps peerState) GetHeight() int64 { } // connect N mempool reactors through N switches -func makeAndConnectReactors(mconfig *memcfg.MempoolConfig, pconfig *p2pcfg.P2PConfig, n int) []*Reactor { - reactors := make([]*Reactor, n) - logger := log.NewNoopLogger() +func makeAndConnectReactors(t *testing.T, mconfig *memcfg.MempoolConfig, pconfig *p2pcfg.P2PConfig, n int) []*Reactor { + t.Helper() + + var ( + reactors = make([]*Reactor, n) + logger = log.NewNoopLogger() + options = make(map[int][]p2p.SwitchOption) + ) + for i := 0; i < n; i++ { app := kvstore.NewKVStoreApplication() cc := proxy.NewLocalClientCreator(app) mempool, cleanup := newMempoolWithApp(cc) defer cleanup() - reactors[i] = NewReactor(mconfig, mempool) // so we dont start the consensus states - reactors[i].SetLogger(logger.With("validator", i)) + reactor := NewReactor(mconfig, mempool) // so we dont start the consensus states + reactor.SetLogger(logger.With("validator", i)) + + options[i] = []p2p.SwitchOption{ + p2p.WithReactor("MEMPOOL", reactor), + } + + reactors[i] = reactor } - p2p.MakeConnectedSwitches(pconfig, n, func(i int, s *p2p.MultiplexSwitch) *p2p.MultiplexSwitch { - s.AddReactor("MEMPOOL", reactors[i]) - return s - }, p2p.Connect2Switches) + // "Simulate" the networking layer + MakeConnectedSwitches(t, pconfig, n, options) + return reactors } +func MakeConnectedSwitches( + t *testing.T, + cfg *p2pcfg.P2PConfig, + n int, + opts map[int][]p2p.SwitchOption, +) []*p2p.MultiplexSwitch { + t.Helper() + + var ( + sws = make([]*p2p.MultiplexSwitch, 0, n) + ts = make([]*p2p.MultiplexTransport, 0, n) + addrs = make([]*p2pTypes.NetAddress, 0, n) + + // TODO remove + lgs = make([]*slog.Logger, 0, n) + ) + + // Generate the switches + for i := range n { + var ( + key = p2pTypes.GenerateNodeKey() + tcpAddr = &net.TCPAddr{ + IP: net.ParseIP("127.0.0.1"), + Port: 0, // random port + } + ) + + addr, err := p2pTypes.NewNetAddress(key.ID(), tcpAddr) + require.NoError(t, err) + + info := p2pTypes.NodeInfo{ + VersionSet: versionset.VersionSet{ + versionset.VersionInfo{ + Name: "p2p", + Version: "v0.0.0", + }, + }, + NetAddress: addr, + Network: "testing", + Software: "p2ptest", + Version: "v1.2.3-rc.0-deadbeef", + Channels: []byte{0x01}, + Moniker: fmt.Sprintf("node-%d", i), + Other: p2pTypes.NodeInfoOther{ + TxIndex: "off", + RPCAddress: fmt.Sprintf("127.0.0.1:%d", 0), + }, + } + + // TODO remove + lg := slog.New(slog.NewTextHandler(os.Stdout, nil)) + + // Create the multiplex transport + multiplexTransport := p2p.NewMultiplexTransport( + info, + *key, + conn.MConfigFromP2P(cfg), + lg, + ) + + // Start the transport + require.NoError(t, multiplexTransport.Listen(*info.NetAddress)) + + t.Cleanup(func() { + assert.NoError(t, multiplexTransport.Close()) + }) + + dialAddr := multiplexTransport.NetAddress() + addrs = append(addrs, &dialAddr) + + ts = append(ts, multiplexTransport) + + // TODO remove + lgs = append(lgs, lg) + } + + ctx, cancelFn := context.WithTimeout(context.Background(), 10*time.Second) + defer cancelFn() + + g, _ := errgroup.WithContext(ctx) + + for i := range n { + // Make sure the switches connect to each other. + // Set up event listeners to make sure + // the setup method blocks until switches are connected + // Create the multiplex switch + newOpts := []p2p.SwitchOption{ + p2p.WithPersistentPeers(addrs), + } + + newOpts = append(newOpts, opts[i]...) + + multiplexSwitch := p2p.NewMultiplexSwitch(ts[i], newOpts...) + + multiplexSwitch.SetLogger(lgs[i].With("sw", i)) // TODO remove + + ch, unsubFn := multiplexSwitch.Subscribe(func(event events.Event) bool { + return event.Type() == events.PeerConnected + }) + + // Start the switch + require.NoError(t, multiplexSwitch.Start()) + + sws = append(sws, multiplexSwitch) + + g.Go(func() error { + defer func() { + unsubFn() + }() + + timer := time.NewTimer(5 * time.Second) + defer timer.Stop() + + connectedPeers := make(map[p2pTypes.ID]struct{}) + + for { + select { + case evRaw := <-ch: + ev := evRaw.(events.PeerConnectedEvent) + + connectedPeers[ev.PeerID] = struct{}{} + + if len(connectedPeers) == n-1 { + return nil + } + case <-timer.C: + return errors.New("timed out waiting for peers to connect") + } + } + }) + + sws[i].DialPeers(addrs...) + } + + require.NoError(t, g.Wait()) + + fmt.Printf("\n\nDONE\n\n") + + return sws +} + func waitForTxsOnReactors(t *testing.T, txs types.Txs, reactors []*Reactor) { t.Helper() @@ -120,14 +281,16 @@ func TestReactorBroadcastTxMessage(t *testing.T) { mconfig := memcfg.TestMempoolConfig() pconfig := testP2PConfig() const N = 4 - reactors := makeAndConnectReactors(mconfig, pconfig, N) - defer func() { + reactors := makeAndConnectReactors(t, mconfig, pconfig, N) + t.Cleanup(func() { for _, r := range reactors { - r.Stop() + assert.NoError(t, r.Stop()) } - }() + }) + for _, r := range reactors { for _, peer := range r.Switch.Peers().List() { + fmt.Printf("Setting peer %s\n", peer.ID()) peer.Set(types.PeerStateKey, peerState{1}) } } @@ -144,7 +307,7 @@ func TestReactorNoBroadcastToSender(t *testing.T) { mconfig := memcfg.TestMempoolConfig() pconfig := testP2PConfig() const N = 2 - reactors := makeAndConnectReactors(mconfig, pconfig, N) + reactors := makeAndConnectReactors(t, mconfig, pconfig, N) defer func() { for _, r := range reactors { r.Stop() @@ -169,7 +332,7 @@ func TestFlappyBroadcastTxForPeerStopsWhenPeerStops(t *testing.T) { mconfig := memcfg.TestMempoolConfig() pconfig := testP2PConfig() const N = 2 - reactors := makeAndConnectReactors(mconfig, pconfig, N) + reactors := makeAndConnectReactors(t, mconfig, pconfig, N) defer func() { for _, r := range reactors { r.Stop() @@ -197,7 +360,7 @@ func TestFlappyBroadcastTxForPeerStopsWhenReactorStops(t *testing.T) { mconfig := memcfg.TestMempoolConfig() pconfig := testP2PConfig() const N = 2 - reactors := makeAndConnectReactors(mconfig, pconfig, N) + reactors := makeAndConnectReactors(t, mconfig, pconfig, N) // stop reactors for _, r := range reactors { @@ -214,15 +377,15 @@ func TestMempoolIDsBasic(t *testing.T) { ids := newMempoolIDs() - peer := mock.NewPeer(net.IP{127, 0, 0, 1}) + id := p2pTypes.GenerateNodeKey().ID() - ids.ReserveForPeer(peer) - assert.EqualValues(t, 1, ids.GetForPeer(peer)) - ids.Reclaim(peer) + ids.ReserveForPeer(id) + assert.EqualValues(t, 1, ids.GetForPeer(id)) + ids.Reclaim(id) - ids.ReserveForPeer(peer) - assert.EqualValues(t, 2, ids.GetForPeer(peer)) - ids.Reclaim(peer) + ids.ReserveForPeer(id) + assert.EqualValues(t, 2, ids.GetForPeer(id)) + ids.Reclaim(id) } func TestMempoolIDsPanicsIfNodeRequestsOvermaxActiveIDs(t *testing.T) { @@ -236,12 +399,13 @@ func TestMempoolIDsPanicsIfNodeRequestsOvermaxActiveIDs(t *testing.T) { ids := newMempoolIDs() for i := 0; i < maxActiveIDs-1; i++ { - peer := mock.NewPeer(net.IP{127, 0, 0, 1}) - ids.ReserveForPeer(peer) + id := p2pTypes.GenerateNodeKey().ID() + ids.ReserveForPeer(id) } assert.Panics(t, func() { - peer := mock.NewPeer(net.IP{127, 0, 0, 1}) - ids.ReserveForPeer(peer) + id := p2pTypes.GenerateNodeKey().ID() + + ids.ReserveForPeer(id) }) } diff --git a/tm2/pkg/bft/node/node.go b/tm2/pkg/bft/node/node.go index dd0c541e20b..8ca3d60fc04 100644 --- a/tm2/pkg/bft/node/node.go +++ b/tm2/pkg/bft/node/node.go @@ -132,7 +132,7 @@ type Node struct { privValidator types.PrivValidator // local node's validator key // network - transport *p2p.Transport + transport *p2p.MultiplexTransport sw *p2p.MultiplexSwitch // p2p connections nodeInfo p2pTypes.NodeInfo nodeKey *p2pTypes.NodeKey // our node privkey @@ -458,7 +458,7 @@ func NewNode(config *cfg.Config, p2pLogger.Error("invalid private peer ID", "err", err) } - sw := p2p.NewSwitch( + sw := p2p.NewMultiplexSwitch( transport, p2p.WithReactor("MEMPOOL", mempoolReactor), p2p.WithReactor("BLOCKCHAIN", bcReactor), @@ -601,7 +601,9 @@ func (n *Node) OnStop() { } // now stop the reactors - n.sw.Stop() + if err := n.sw.Stop(); err != nil { + n.Logger.Error("unable to gracefully close switch", "err", err) + } // stop mempool WAL if n.config.Mempool.WalEnabled() { diff --git a/tm2/pkg/bft/rpc/client/local.go b/tm2/pkg/bft/rpc/client/local.go index 59c4216a468..4bc724e7d70 100644 --- a/tm2/pkg/bft/rpc/client/local.go +++ b/tm2/pkg/bft/rpc/client/local.go @@ -106,14 +106,6 @@ func (c *Local) Health() (*ctypes.ResultHealth, error) { return core.Health(c.ctx) } -func (c *Local) DialSeeds(seeds []string) (*ctypes.ResultDialSeeds, error) { - return core.UnsafeDialSeeds(c.ctx, seeds) -} - -func (c *Local) DialPeers(peers []string, persistent bool) (*ctypes.ResultDialPeers, error) { - return core.UnsafeDialPeers(c.ctx, peers, persistent) -} - func (c *Local) BlockchainInfo(minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error) { return core.BlockchainInfo(c.ctx, minHeight, maxHeight) } diff --git a/tm2/pkg/bft/rpc/core/net.go b/tm2/pkg/bft/rpc/core/net.go index 975d5ed822f..f8839b7d91f 100644 --- a/tm2/pkg/bft/rpc/core/net.go +++ b/tm2/pkg/bft/rpc/core/net.go @@ -3,7 +3,6 @@ package core import ( ctypes "github.com/gnolang/gno/tm2/pkg/bft/rpc/core/types" rpctypes "github.com/gnolang/gno/tm2/pkg/bft/rpc/lib/types" - "github.com/gnolang/gno/tm2/pkg/errors" ) // Get network info. @@ -154,10 +153,14 @@ import ( // } // // ``` -func NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, error) { - out, in, _ := p2pPeers.NumPeers() +func NetInfo(_ *rpctypes.Context) (*ctypes.ResultNetInfo, error) { + var ( + set = p2pPeers.Peers() + out, in = set.NumOutbound(), set.NumInbound() + ) + peers := make([]ctypes.Peer, 0, out+in) - for _, peer := range p2pPeers.Peers().List() { + for _, peer := range set.List() { nodeInfo := peer.NodeInfo() peers = append(peers, ctypes.Peer{ NodeInfo: nodeInfo, @@ -166,9 +169,7 @@ func NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, error) { RemoteIP: peer.RemoteIP().String(), }) } - // TODO: Should we include PersistentPeers and Seeds in here? - // PRO: useful info - // CON: privacy + return &ctypes.ResultNetInfo{ Listening: p2pTransport.IsListening(), Listeners: p2pTransport.Listeners(), @@ -177,33 +178,6 @@ func NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, error) { }, nil } -func UnsafeDialSeeds(ctx *rpctypes.Context, seeds []string) (*ctypes.ResultDialSeeds, error) { - if len(seeds) == 0 { - return &ctypes.ResultDialSeeds{}, errors.New("No seeds provided") - } - logger.Info("DialSeeds", "seeds", seeds) - if err := p2pPeers.DialPeersAsync(seeds); err != nil { - return &ctypes.ResultDialSeeds{}, err - } - return &ctypes.ResultDialSeeds{Log: "Dialing seeds in progress. See /net_info for details"}, nil -} - -func UnsafeDialPeers(ctx *rpctypes.Context, peers []string, persistent bool) (*ctypes.ResultDialPeers, error) { - if len(peers) == 0 { - return &ctypes.ResultDialPeers{}, errors.New("No peers provided") - } - logger.Info("DialPeers", "peers", peers, "persistent", persistent) - if persistent { - if err := p2pPeers.AddPersistentPeers(peers); err != nil { - return &ctypes.ResultDialPeers{}, err - } - } - if err := p2pPeers.DialPeersAsync(peers); err != nil { - return &ctypes.ResultDialPeers{}, err - } - return &ctypes.ResultDialPeers{Log: "Dialing peers in progress. See /net_info for details"}, nil -} - // Get genesis file. // // ```shell diff --git a/tm2/pkg/bft/rpc/core/net_test.go b/tm2/pkg/bft/rpc/core/net_test.go deleted file mode 100644 index 163312e2ed9..00000000000 --- a/tm2/pkg/bft/rpc/core/net_test.go +++ /dev/null @@ -1,77 +0,0 @@ -package core - -import ( - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" - - rpctypes "github.com/gnolang/gno/tm2/pkg/bft/rpc/lib/types" - "github.com/gnolang/gno/tm2/pkg/log" - "github.com/gnolang/gno/tm2/pkg/p2p" - p2pcfg "github.com/gnolang/gno/tm2/pkg/p2p/config" -) - -func TestUnsafeDialSeeds(t *testing.T) { - t.Parallel() - - sw := p2p.MakeSwitch(p2pcfg.DefaultP2PConfig(), 1, "testing", "123.123.123", - func(n int, sw *p2p.MultiplexSwitch) *p2p.MultiplexSwitch { return sw }) - err := sw.Start() - require.NoError(t, err) - defer sw.Stop() - - logger = log.NewNoopLogger() - p2pPeers = sw - - testCases := []struct { - seeds []string - isErr bool - }{ - {[]string{}, true}, - {[]string{"g1m6kmam774klwlh4dhmhaatd7al02m0h0jwnyc6@127.0.0.1:41198"}, false}, - {[]string{"127.0.0.1:41198"}, true}, - } - - for _, tc := range testCases { - res, err := UnsafeDialSeeds(&rpctypes.Context{}, tc.seeds) - if tc.isErr { - assert.Error(t, err) - } else { - assert.NoError(t, err) - assert.NotNil(t, res) - } - } -} - -func TestUnsafeDialPeers(t *testing.T) { - t.Parallel() - - sw := p2p.MakeSwitch(p2pcfg.DefaultP2PConfig(), 1, "testing", "123.123.123", - func(n int, sw *p2p.MultiplexSwitch) *p2p.MultiplexSwitch { return sw }) - err := sw.Start() - require.NoError(t, err) - defer sw.Stop() - - logger = log.NewNoopLogger() - p2pPeers = sw - - testCases := []struct { - peers []string - isErr bool - }{ - {[]string{}, true}, - {[]string{"g1m6kmam774klwlh4dhmhaatd7al02m0h0jwnyc6@127.0.0.1:41198"}, false}, - {[]string{"127.0.0.1:41198"}, true}, - } - - for _, tc := range testCases { - res, err := UnsafeDialPeers(&rpctypes.Context{}, tc.peers, false) - if tc.isErr { - assert.Error(t, err) - } else { - assert.NoError(t, err) - assert.NotNil(t, res) - } - } -} diff --git a/tm2/pkg/bft/rpc/core/pipe.go b/tm2/pkg/bft/rpc/core/pipe.go index d5cdf2c268c..085fc35da55 100644 --- a/tm2/pkg/bft/rpc/core/pipe.go +++ b/tm2/pkg/bft/rpc/core/pipe.go @@ -43,9 +43,6 @@ type transport interface { } type peers interface { - AddPersistentPeers([]string) error - DialPeersAsync([]string) error - NumPeers() (outbound, inbound, dialig int) Peers() p2p.PeerSet } diff --git a/tm2/pkg/bft/rpc/core/routes.go b/tm2/pkg/bft/rpc/core/routes.go index 8d210f67985..76217a7cbd9 100644 --- a/tm2/pkg/bft/rpc/core/routes.go +++ b/tm2/pkg/bft/rpc/core/routes.go @@ -36,8 +36,6 @@ var Routes = map[string]*rpc.RPCFunc{ func AddUnsafeRoutes() { // control API - Routes["dial_seeds"] = rpc.NewRPCFunc(UnsafeDialSeeds, "seeds") - Routes["dial_peers"] = rpc.NewRPCFunc(UnsafeDialPeers, "peers,persistent") Routes["unsafe_flush_mempool"] = rpc.NewRPCFunc(UnsafeFlushMempool, "") // profiler API diff --git a/tm2/pkg/p2p/discovery/mock_test.go b/tm2/pkg/p2p/discovery/mock_test.go index b4a21827ce7..03919a673d3 100644 --- a/tm2/pkg/p2p/discovery/mock_test.go +++ b/tm2/pkg/p2p/discovery/mock_test.go @@ -4,6 +4,7 @@ import ( "net" "github.com/gnolang/gno/tm2/pkg/p2p" + "github.com/gnolang/gno/tm2/pkg/p2p/events" "github.com/gnolang/gno/tm2/pkg/p2p/types" ) @@ -12,6 +13,7 @@ type ( peersDelegate func() p2p.PeerSet stopPeerForErrorDelegate func(p2p.Peer, error) dialPeersDelegate func(...*types.NetAddress) + subscribeDelegate func(events.EventFilter) (<-chan events.Event, func()) ) type mockSwitch struct { @@ -19,6 +21,7 @@ type mockSwitch struct { peersFn peersDelegate stopPeerForErrorFn stopPeerForErrorDelegate dialPeersFn dialPeersDelegate + subscribeFn subscribeDelegate } func (m *mockSwitch) Broadcast(chID byte, data []byte) { @@ -47,6 +50,14 @@ func (m *mockSwitch) DialPeers(peerAddrs ...*types.NetAddress) { } } +func (m *mockSwitch) Subscribe(filter events.EventFilter) (<-chan events.Event, func()) { + if m.subscribeFn != nil { + m.subscribeFn(filter) + } + + return nil, func() {} +} + type ( addDelegate func(p2p.Peer) removeDelegate func(types.ID) bool @@ -91,14 +102,6 @@ func (m *mockPeerSet) Has(key types.ID) bool { return false } -func (m *mockPeerSet) HasIP(ip net.IP) bool { - if m.hasIPFn != nil { - return m.hasIPFn(ip) - } - - return false -} - func (m *mockPeerSet) Get(key types.ID) p2p.Peer { if m.getFn != nil { return m.getFn(key) diff --git a/tm2/pkg/p2p/events/doc.go b/tm2/pkg/p2p/events/doc.go new file mode 100644 index 00000000000..a624102379e --- /dev/null +++ b/tm2/pkg/p2p/events/doc.go @@ -0,0 +1,3 @@ +// Package events contains a simple p2p event system implementation, that simplifies asynchronous event flows in the +// p2p module. The event subscriptions allow for event filtering, which eases the load on the event notification flow. +package events diff --git a/tm2/pkg/p2p/events/events.go b/tm2/pkg/p2p/events/events.go new file mode 100644 index 00000000000..bf76e27d91e --- /dev/null +++ b/tm2/pkg/p2p/events/events.go @@ -0,0 +1,104 @@ +package events + +import ( + "sync" + + "github.com/rs/xid" +) + +// EventFilter is the filter function used to +// filter incoming p2p events. A false flag will +// consider the event as irrelevant +type EventFilter func(Event) bool + +// Events is the p2p event switch +type Events struct { + subs subscriptions + subscriptionsMux sync.RWMutex +} + +// New creates a new event subscription manager +func New() *Events { + return &Events{ + subs: make(subscriptions), + } +} + +// Subscribe registers a new filtered event listener +func (es *Events) Subscribe(filterFn EventFilter) (<-chan Event, func()) { + es.subscriptionsMux.Lock() + defer es.subscriptionsMux.Unlock() + + // Create a new subscription + id, ch := es.subs.add(filterFn) + + // Create the unsubscribe callback + unsubscribeFn := func() { + es.subscriptionsMux.Lock() + defer es.subscriptionsMux.Unlock() + + es.subs.remove(id) + } + + return ch, unsubscribeFn +} + +// Notify notifies all subscribers of an incoming event [BLOCKING] +func (es *Events) Notify(event Event) { + es.subscriptionsMux.RLock() + defer es.subscriptionsMux.RUnlock() + + es.subs.notify(event) +} + +type ( + // subscriptions holds the corresponding subscription information + subscriptions map[string]subscription // subscription ID -> subscription + + // subscription wraps the subscription notification channel, + // and the event filter + subscription struct { + ch chan Event + filterFn EventFilter + } +) + +// add adds a new subscription to the subscription map. +// Returns the subscription ID, and update channel +func (s *subscriptions) add(filterFn EventFilter) (string, chan Event) { + var ( + id = xid.New().String() + ch = make(chan Event, 1) + ) + + (*s)[id] = subscription{ + ch: ch, + filterFn: filterFn, + } + + return id, ch +} + +// remove removes the given subscription +func (s *subscriptions) remove(id string) { + if sub, exists := (*s)[id]; exists { + // Close the notification channel + close(sub.ch) + } + + // Delete the subscription + delete(*s, id) +} + +// notify notifies all subscription listeners, +// if their filters pass +func (s *subscriptions) notify(event Event) { + // Notify the listeners + for _, sub := range *s { + if !sub.filterFn(event) { + continue + } + + sub.ch <- event + } +} diff --git a/tm2/pkg/p2p/events/events_test.go b/tm2/pkg/p2p/events/events_test.go new file mode 100644 index 00000000000..a0feafceddb --- /dev/null +++ b/tm2/pkg/p2p/events/events_test.go @@ -0,0 +1,94 @@ +package events + +import ( + "fmt" + "sync" + "testing" + "time" + + "github.com/gnolang/gno/tm2/pkg/p2p/types" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// generateEvents generates p2p events +func generateEvents(count int) []Event { + events := make([]Event, 0, count) + + for i := range count { + var event Event + + if i%2 == 0 { + event = PeerConnectedEvent{ + PeerID: types.ID(fmt.Sprintf("peer-%d", i)), + } + } else { + event = PeerDisconnectedEvent{ + PeerID: types.ID(fmt.Sprintf("peer-%d", i)), + } + } + + events = append(events, event) + } + + return events +} + +func TestEvents_Subscribe(t *testing.T) { + t.Parallel() + + var ( + capturedEvents []Event + + events = generateEvents(10) + subFn = func(e Event) bool { + return e.Type() == PeerDisconnected + } + ) + + // Create the events manager + e := New() + + // Subscribe to events + ch, unsubFn := e.Subscribe(subFn) + defer unsubFn() + + // Listen for the events + var wg sync.WaitGroup + + wg.Add(1) + + go func() { + defer wg.Done() + + timeout := time.After(5 * time.Second) + + for { + select { + case ev := <-ch: + capturedEvents = append(capturedEvents, ev) + + if len(capturedEvents) == len(events)/2 { + return + } + case <-timeout: + return + } + } + }() + + // Send out the events + for _, ev := range events { + e.Notify(ev) + } + + wg.Wait() + + // Make sure the events were captured + // and filtered properly + require.Len(t, capturedEvents, len(events)/2) + + for _, ev := range capturedEvents { + assert.Equal(t, ev.Type(), PeerDisconnected) + } +} diff --git a/tm2/pkg/p2p/events/types.go b/tm2/pkg/p2p/events/types.go new file mode 100644 index 00000000000..cbaac1816ff --- /dev/null +++ b/tm2/pkg/p2p/events/types.go @@ -0,0 +1,39 @@ +package events + +import ( + "net" + + "github.com/gnolang/gno/tm2/pkg/p2p/types" +) + +type EventType string + +const ( + PeerConnected EventType = "PeerConnected" // emitted when a fresh peer connects + PeerDisconnected EventType = "PeerDisconnected" // emitted when a peer disconnects +) + +// Event is a generic p2p event +type Event interface { + // Type returns the type information for the event + Type() EventType +} + +type PeerConnectedEvent struct { + PeerID types.ID // the ID of the peer + Address net.Addr // the remote address of the peer +} + +func (p PeerConnectedEvent) Type() EventType { + return PeerConnected +} + +type PeerDisconnectedEvent struct { + PeerID types.ID // the ID of the peer + Address net.Addr // the remote address of the peer + Reason error // the disconnect reason, if any +} + +func (p PeerDisconnectedEvent) Type() EventType { + return PeerDisconnected +} diff --git a/tm2/pkg/p2p/mock_test.go b/tm2/pkg/p2p/mock_test.go index 25fbb800e69..d870e3f8133 100644 --- a/tm2/pkg/p2p/mock_test.go +++ b/tm2/pkg/p2p/mock_test.go @@ -98,14 +98,6 @@ func (m *mockSet) Has(key types.ID) bool { return false } -func (m *mockSet) HasIP(ip net.IP) bool { - if m.hasIPFn != nil { - return m.hasIPFn(ip) - } - - return false -} - func (m *mockSet) Get(key types.ID) Peer { if m.getFn != nil { return m.getFn(key) diff --git a/tm2/pkg/p2p/set.go b/tm2/pkg/p2p/set.go index a54ad949657..9905fe0ac66 100644 --- a/tm2/pkg/p2p/set.go +++ b/tm2/pkg/p2p/set.go @@ -1,7 +1,6 @@ package p2p import ( - "net" "sync" "github.com/gnolang/gno/tm2/pkg/p2p/types" @@ -51,22 +50,7 @@ func (s *set) Has(peerKey types.ID) bool { return exists } -// HasIP returns true if the set contains the peer referred to by this IP -// address, otherwise false. -func (s *set) HasIP(peerIP net.IP) bool { - s.mux.RLock() - defer s.mux.RUnlock() - - for _, p := range s.peers { - if p.(Peer).RemoteIP().Equal(peerIP) { - return true - } - } - - return false -} - -// Get looks up a peer by the provtypes.IDed peerKey. Returns nil if peer is not +// Get looks up a peer by the peer ID. Returns nil if peer is not // found. func (s *set) Get(key types.ID) Peer { s.mux.RLock() diff --git a/tm2/pkg/p2p/set_test.go b/tm2/pkg/p2p/set_test.go index fd0428d5af0..ced35538a9b 100644 --- a/tm2/pkg/p2p/set_test.go +++ b/tm2/pkg/p2p/set_test.go @@ -1,7 +1,6 @@ package p2p import ( - "net" "sort" "testing" @@ -63,53 +62,6 @@ func TestSet_Remove(t *testing.T) { } } -func TestSet_HasIP(t *testing.T) { - t.Parallel() - - t.Run("present peer with IP", func(t *testing.T) { - t.Parallel() - - var ( - peers = mock.GeneratePeers(t, 100) - ip = net.ParseIP("0.0.0.0") - - s = newSet() - ) - - // Make sure at least one peer has the set IP - peers[len(peers)/2].RemoteIPFn = func() net.IP { - return ip - } - - // Add the peers - for _, peer := range peers { - s.Add(peer) - } - - // Make sure the peer is present - assert.True(t, s.HasIP(ip)) - }) - - t.Run("missing peer with IP", func(t *testing.T) { - t.Parallel() - - var ( - peers = mock.GeneratePeers(t, 100) - ip = net.ParseIP("0.0.0.0") - - s = newSet() - ) - - // Add the peers - for _, peer := range peers { - s.Add(peer) - } - - // Make sure the peer is not present - assert.False(t, s.HasIP(ip)) - }) -} - func TestSet_Get(t *testing.T) { t.Parallel() diff --git a/tm2/pkg/p2p/switch.go b/tm2/pkg/p2p/switch.go index 1ec18437b4a..2cc16b0122e 100644 --- a/tm2/pkg/p2p/switch.go +++ b/tm2/pkg/p2p/switch.go @@ -9,6 +9,7 @@ import ( "github.com/gnolang/gno/tm2/pkg/p2p/config" "github.com/gnolang/gno/tm2/pkg/p2p/conn" "github.com/gnolang/gno/tm2/pkg/p2p/dial" + "github.com/gnolang/gno/tm2/pkg/p2p/events" "github.com/gnolang/gno/tm2/pkg/p2p/types" "github.com/gnolang/gno/tm2/pkg/service" "github.com/gnolang/gno/tm2/pkg/telemetry" @@ -66,10 +67,11 @@ type MultiplexSwitch struct { transport Transport dialQueue *dial.Queue + events *events.Events } -// NewSwitch creates a new MultiplexSwitch with the given config. -func NewSwitch( +// NewMultiplexSwitch creates a new MultiplexSwitch with the given config. +func NewMultiplexSwitch( transport Transport, opts ...SwitchOption, ) *MultiplexSwitch { @@ -80,6 +82,7 @@ func NewSwitch( peers: newSet(), transport: transport, dialQueue: dial.NewQueue(), + events: events.New(), maxInboundPeers: defaultCfg.MaxNumInboundPeers, maxOutboundPeers: defaultCfg.MaxNumOutboundPeers, } @@ -110,6 +113,12 @@ func NewSwitch( return sw } +// Subscribe registers to live events happening on the p2p Switch. +// Returns the notification channel, along with an unsubscribe method +func (sw *MultiplexSwitch) Subscribe(filterFn events.EventFilter) (<-chan events.Event, func()) { + return sw.events.Subscribe(filterFn) +} + // --------------------------------------------------------------------- // Service start/stop @@ -239,6 +248,12 @@ func (sw *MultiplexSwitch) stopAndRemovePeer(peer Peer, err error) { // RemovePeer is finished. // https://github.com/tendermint/classic/issues/3338 sw.peers.Remove(peer.ID()) + + sw.events.Notify(events.PeerDisconnectedEvent{ + Address: peer.RemoteAddr(), + PeerID: peer.ID(), + Reason: err, + }) } // --------------------------------------------------------------------- @@ -278,7 +293,8 @@ func (sw *MultiplexSwitch) runDialLoop(ctx context.Context) { peerAddr := item.Address // Check if the peer is already connected - if sw.Peers().Has(peerAddr.ID) || sw.Peers().HasIP(peerAddr.IP) { + ps := sw.Peers() + if ps.Has(peerAddr.ID) { sw.Logger.Warn( "ignoring dial request for existing peer", "id", peerAddr.ID, @@ -329,7 +345,7 @@ func (sw *MultiplexSwitch) runDialLoop(ctx context.Context) { // runRedialLoop starts the persistent peer redial loop func (sw *MultiplexSwitch) runRedialLoop(ctx context.Context) { - ticker := time.NewTicker(time.Second * 10) + ticker := time.NewTicker(time.Second * 1) // TODO make option defer ticker.Stop() // redialFn goes through the persistent peer list @@ -511,6 +527,11 @@ func (sw *MultiplexSwitch) addPeer(p Peer) error { sw.Logger.Info("Added peer", "peer", p) + sw.events.Notify(events.PeerConnectedEvent{ + Address: p.RemoteAddr(), + PeerID: p.ID(), + }) + return nil } diff --git a/tm2/pkg/p2p/switch_test.go b/tm2/pkg/p2p/switch_test.go index 992c547eab4..d2d8cf06b30 100644 --- a/tm2/pkg/p2p/switch_test.go +++ b/tm2/pkg/p2p/switch_test.go @@ -30,7 +30,7 @@ func TestMultiplexSwitch_Options(t *testing.T) { } ) - sw := NewSwitch(nil, WithReactor(name, mockReactor)) + sw := NewMultiplexSwitch(nil, WithReactor(name, mockReactor)) assert.Equal(t, mockReactor, sw.reactors[name]) }) @@ -40,7 +40,7 @@ func TestMultiplexSwitch_Options(t *testing.T) { peers := generateNetAddr(t, 10) - sw := NewSwitch(nil, WithPersistentPeers(peers)) + sw := NewMultiplexSwitch(nil, WithPersistentPeers(peers)) for _, p := range peers { assert.True(t, sw.isPersistentPeer(p.ID)) @@ -59,7 +59,7 @@ func TestMultiplexSwitch_Options(t *testing.T) { ids = append(ids, p.ID) } - sw := NewSwitch(nil, WithPrivatePeers(ids)) + sw := NewMultiplexSwitch(nil, WithPrivatePeers(ids)) for _, p := range peers { assert.True(t, sw.isPrivatePeer(p.ID)) @@ -71,7 +71,7 @@ func TestMultiplexSwitch_Options(t *testing.T) { maxInbound := uint64(500) - sw := NewSwitch(nil, WithMaxInboundPeers(maxInbound)) + sw := NewMultiplexSwitch(nil, WithMaxInboundPeers(maxInbound)) assert.Equal(t, maxInbound, sw.maxInboundPeers) }) @@ -81,7 +81,7 @@ func TestMultiplexSwitch_Options(t *testing.T) { maxOutbound := uint64(500) - sw := NewSwitch(nil, WithMaxOutboundPeers(maxOutbound)) + sw := NewMultiplexSwitch(nil, WithMaxOutboundPeers(maxOutbound)) assert.Equal(t, maxOutbound, sw.maxOutboundPeers) }) @@ -103,7 +103,7 @@ func TestMultiplexSwitch_Broadcast(t *testing.T) { } peers = mock.GeneratePeers(t, 10) - sw = NewSwitch(mockTransport) + sw = NewMultiplexSwitch(mockTransport) ) require.NoError(t, sw.OnStart()) @@ -139,7 +139,7 @@ func TestMultiplexSwitch_Peers(t *testing.T) { var ( peers = mock.GeneratePeers(t, 10) - sw = NewSwitch(nil) + sw = NewMultiplexSwitch(nil) ) // Create a new peer set @@ -178,7 +178,7 @@ func TestMultiplexSwitch_StopPeer(t *testing.T) { }, } - sw = NewSwitch(mockTransport) + sw = NewMultiplexSwitch(mockTransport) ) // Create a new peer set @@ -208,7 +208,7 @@ func TestMultiplexSwitch_StopPeer(t *testing.T) { }, } - sw = NewSwitch(mockTransport) + sw = NewMultiplexSwitch(mockTransport) ) // Make sure the peer is persistent @@ -281,7 +281,7 @@ func TestMultiplexSwitch_DialLoop(t *testing.T) { }, } - sw = NewSwitch(mockTransport) + sw = NewMultiplexSwitch(mockTransport) ) sw.peers = mockSet @@ -344,7 +344,7 @@ func TestMultiplexSwitch_DialLoop(t *testing.T) { }, } - sw = NewSwitch(mockTransport) + sw = NewMultiplexSwitch(mockTransport) ) sw.peers = mockSet @@ -399,7 +399,7 @@ func TestMultiplexSwitch_DialLoop(t *testing.T) { }, } - sw = NewSwitch(mockTransport) + sw = NewMultiplexSwitch(mockTransport) ) // Prepare the dial queue @@ -461,7 +461,7 @@ func TestMultiplexSwitch_AcceptLoop(t *testing.T) { }, } - sw = NewSwitch( + sw = NewMultiplexSwitch( mockTransport, WithMaxInboundPeers(maxInbound), ) @@ -517,7 +517,7 @@ func TestMultiplexSwitch_AcceptLoop(t *testing.T) { }, } - sw = NewSwitch( + sw = NewMultiplexSwitch( mockTransport, WithMaxInboundPeers(maxInbound), ) @@ -583,7 +583,7 @@ func TestMultiplexSwitch_RedialLoop(t *testing.T) { } // Create the switch - sw := NewSwitch( + sw := NewMultiplexSwitch( nil, WithPersistentPeers(addrs), ) @@ -649,7 +649,7 @@ func TestMultiplexSwitch_RedialLoop(t *testing.T) { } // Create the switch - sw := NewSwitch( + sw := NewMultiplexSwitch( mockTransport, WithPersistentPeers(addrs), ) @@ -731,7 +731,7 @@ func TestMultiplexSwitch_DialPeers(t *testing.T) { } } - sw := NewSwitch(mockTransport) + sw := NewMultiplexSwitch(mockTransport) // Dial the peers sw.DialPeers(p.NodeInfo().NetAddress) @@ -763,7 +763,7 @@ func TestMultiplexSwitch_DialPeers(t *testing.T) { } ) - sw := NewSwitch( + sw := NewMultiplexSwitch( mockTransport, WithMaxOutboundPeers(maxOutbound), ) @@ -803,7 +803,7 @@ func TestMultiplexSwitch_DialPeers(t *testing.T) { } ) - sw := NewSwitch( + sw := NewMultiplexSwitch( mockTransport, WithMaxOutboundPeers(10), ) diff --git a/tm2/pkg/p2p/types.go b/tm2/pkg/p2p/types.go index fe6bccec072..418c5095347 100644 --- a/tm2/pkg/p2p/types.go +++ b/tm2/pkg/p2p/types.go @@ -5,6 +5,7 @@ import ( "net" "github.com/gnolang/gno/tm2/pkg/p2p/conn" + "github.com/gnolang/gno/tm2/pkg/p2p/events" "github.com/gnolang/gno/tm2/pkg/p2p/types" "github.com/gnolang/gno/tm2/pkg/service" ) @@ -46,7 +47,6 @@ type PeerSet interface { Add(peer Peer) Remove(key types.ID) bool Has(key types.ID) bool - HasIP(ip net.IP) bool Get(key types.ID) Peer List() []Peer @@ -81,6 +81,9 @@ type Switch interface { // Peers returns the latest peer set Peers() PeerSet + // Subscribe subscribes to active switch events + Subscribe(filterFn events.EventFilter) (<-chan events.Event, func()) + // StopPeerForError stops the peer with the given reason StopPeerForError(peer Peer, err error)