Skip to content
Snippets Groups Projects
Select Git revision
  • 8fde09bf5b40f82559c2cf7333b182acde468d02
  • develop default protected
  • congestioncontrol
  • merge-v-data-collection-spammer-0.8.2
  • WIP-merge-v-data-collection-spammer-0.8.2
  • merge-v-data-collection-spammer-0.7.7
  • tmp
  • test-masterpow-fixing
  • test-masterpow
  • test-echo
  • v-data-collection
  • v-data-collection-spammer
  • tmp-dump-spam-info
  • dump-msg-info-0.3.1
  • test-dump-message-info
  • spammer-exprandom
  • extra/tutorial
  • without_tipselection
  • hacking-docker-network
  • hacking-docker-network-0.2.3
  • master
  • v0.2.3
22 results

protocol_test.go

Blame
  • user avatar
    Wolfgang Welz authored and GitHub committed
    * :sparkles: GetNextCandidate selection added
    
    * :bug: Recompile salt.proto
    
    * :recycle: Refactor peer IDs completely
    
    * :bug: Recompile proto sources
    
    * :construction: WIP
    
    * :ok_hand: renamed to sort
    
    * :construction: Return requested peers on request
    
    * :sparkles: Kepp track how ofter a managed peer was verified
    
    * :wrench: sort adapted to the new peer
    
    * :construction: Query verified peers for new peers
    
    * :construction: WIP
    
    * :white_check_mark: Add manager tests
    
    * :bento: Add peering messages to protobuf
    
    * :art: Make Salt methods consistent with Peer
    
    * :sparkles: Handle peering messages
    
    * :construction: WIP
    
    * :bug: Add To filed to PeersRequest
    
    * :white_check_mark: Add PeersRequest test
    
    * :zap: Adding PeersRequest benchmark
    
    * :art: Move mpeer and helper functions to own file
    
    * :bug: Bump peer only once on reverification
    
    * :construction: WIP
    
    * :bug:
    
    * :construction: WIP
    
    * :bug: Increase buffer to prevent deadlocks
    
    * :zap: Remove unnecessary lock
    
    * :white_check_mark: Add peering request test
    
    * :white_check_mark: Make tests deterministic by triggering reverify
    
    * :construction: WIP
    
    * :lock: fixing concurrency issues
    
    * :white_check_mark: testManager improved
    
    * :bug: Don't send PeeringResponse for invalid salt
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :pencil: removed commented code
    
    * :construction: WIP
    
    * :construction: WIP
    
    * Neighbourhood manager (#11)
    
    * :sparkles: GetNextCandidate selection added
    
    * :lock: fixing concurrency issues
    
    * :white_check_mark: testManager improved
    
    * :pencil: removed commented code
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :heavy_check_mark: Make TestAdd pass in neighborhood_test
    
    `Add` should do nothing if the neighborhood list is full.
    
    * :white_check_mark: Improve TestSrvVerifyBoot
    
    * :arrow_up: Upgrade to go 1.13
    
    * :heavy_minus_sign: Use testify instead of magiconair/properties
    
    * :construction:
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :construction: WIP
    
    * Simulation (#14)
    
    * :sparkles: clear rejection filter after refreshing the public salt
    
    * :sparkles: clean rejection filter
    
    * :white_check_mark: Add mpeer test
    
    * :art: gofmt test
    
    * :art: Remove ineffactual assignments
    
    * :hammer: Trigger panic when index is out of bound in deletePeer
    
    * :white_check_mark: Add selection test
    
    * :white_check_mark: Add TestGetFurtherest and TestGetPeerIndex
    
    * :sparkles: both salt updated at the same time and neighborhood dropped
    
    * :art: Add node peering history for simulation
    
    * :construction: WIP
    
    * :sparkles: added sim visualization
    
    * :fire: removed root handler
    
    * :pencil: added README
    
    * :pencil: updated README
    
    * :heavy_minus_sign: removed unused dependencies
    
    * :art: Tidy go.mod
    
    * :construction: Work in progress
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :lipstick: improved start button
    
    * :construction: WIP
    
    * :sparkles: added keyboard support for start
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :construction: WIP
    
    * :sparkles: added input parameters
    
    * :pencil: README updated
    
    * :lipstick: gif updated
    
    * :lipstick: figure updated
    
    * :pencil: updated
    
    * :lipstick: updated gif
    
    * removed simulation metrics
    
    * :pencil: updated
    
    * :pencil: updated
    
    * :recycle: Extract server from discovery and peering
    
    * :bug: Use golang/protobuf
    
    * Update README.md
    
    * :recycle: Rename PeersRequest to DiscoveryRequest
    
    * :pencil2: Fixing typos
    
    * :art: Move unused function to tests
    
    * :recycle: The selection protocol depends on the discovery
    
    * :white_check_mark: Make tests more robust when using -race
    
    * :loud_sound: Improve logging
    
    * :art: Remove unnecessary arguments
    
    * :bug: Fix data races
    
    * :bug: added timeout for simulated network
    
    * :art: added loop to animation
    
    * :recycle: rename neighborhood to selection
    
    * :sparkles: adds initial salt and fixes simulation end
    
    * :pencil: visualizer enabled by default
    
    * :sparkles: new parameter dropAll and improved python script
    
    * :pencil: updated README
    
    * :pencil: updated README
    
    * :bug: fix salt initialization
    
    * :pencil: added blogpost link
    
    * :pencil: Add badges to README
    
    * :construction_worker: Add Travis CI for tests
    
    * :rotating_light: Correct formating
    
    * :construction_worker: Running golangci on Travis
    
    * :rotating_light: Ignore return value of 'logger.Sync'
    
    * :rotating_light: Remove unused functions
    
    * :pencil: Add link to license
    
    * :art: Move simnetwork to transport
    
    * :art: Use the complete network protocol in simulations
    
    * :recycle: Do not export selection/manager
    
    * :fire: Remove gRPC transport layer
    
    * :white_check_mark: Add UDP connection transport test
    
    * :construction: Implement the peer DB using Goshimmer database
    
    * :heavy_plus_sign: Use the local GoShimmer version
    
    * :sparkles: Add support for a persistent database
    
    * :sparkles: Persist private key of local peer in database
    
    * :bug: Set TTL for bootstrap peers
    
    * :construction: Use GoShimmer events
    
    * :sparkles: Store the supported services in the local peer
    
    * :pushpin: Use most current GoShimmer git version as a dep
    
    * :heavy_plus_sign: Switch to hive.go event package
    
    * :art: Use correct module iotaledger/autopeering-sim
    
    * :bug: Provide dummy service in autopeering simulation
    
    * :sparkles: adds service support in the selection
    
    * :sparkles: adds peer discovered events
    
    * :sparkles: adds GetIncomingNeighbors and GetOutgoingNeighbors
    
    * :bug: fixes out of bound error in splitNodeKey
    
    * :sparkles: adds public IP support
    
    * :bug: fixes localhost
    
    * :bug: fixes localhost parsing
    
    * :wrench: changes selection loop to 1s
    
    * :loud_sound: switches from fmt.Println to log.Debug
    
    * :wrench: increases maxKnown to 1000 and always triggers discovered peer
    
    * :sparkles: adds PeerDeleted event
    
    * :construction: moves PeerDeleted event into deletePeer
    
    * :sparkles: adds config paramters for the peer discovery
    
    * :sparkles: adds config parameters to neighbor selection
    
    * :sparkles: enable/disable inbound/outbound selection
    
    * :bulb: Improve Godoc comments
    
    * :sparkles: modifies disabled outbound selection
    
    * :bug: fixes bug with disabling the selection
    
    * :heavy_minus_sign: removes getMyIP() from server
    
    * :mute: removes some debugging logs
    
    * :construction: Introduce services
    
    - Each peer now comes with a set of services
    - Local peer is a proper peer
    - Services are exchanged during Pong and are available for all verified
    peers
    
    * :bug: fixes GetVerifiedPeer
    
    * :sparkles: adds gossip key to the service
    
    * :mute: removes debugging logs
    
    * :white_check_mark: Add test for GetVerifiedPeer
    
    * :bug: Fix main
    
    * :art: Add localNetwork to Protocol
    
    * :bug: Add new but verified peers to the manager
    
    * :wrench: changes configurable parameters
    
    * :bug: fixes DiscoveryRequest field sequence
    
    * :bento: Regenerate proto files
    
    * :art: Cleanup parameters
    
    * :bug: Fix potential race condition
    
    * :mute: Reduce logging verbosity
    
    * :white_check_mark: Add test for selection+discover
    
    * :sparkles: Return net.Addr in Transport
    
    * :bug: Remove inbound/outbound switches completely
    
    * :loud_sound: Improve logging
    
    * :loud_sound: Fix peerdb logs
    
    * :bug: Fix peer updating
    
    * :white_check_mark: Make TestProtFull more robust
    
    * :art: Make queryInterval a parameter
    
    * :loud_sound: Improve loggind during querying
    
    * :bug: Trigger PeerDiscovered only for active peers
    
    * :art: Cleanup protocol tests
    
    * :white_check_mark: Add discovery test on protocol level
    
    * :art: Rename maxVerified to maxManaged
    
    * :wrench: Increase default query interval
    
    * :art: Improve discover benchmarks
    
    * :white_check_mark: Fix manager tests
    
    * :art: Do not use bugged assert.Eventually
    
    * :rotating_light: Fix linter warnings in server
    
    * :rotating_light: Remove unused parameters
    
    * :art: Make transport work on slices of bytes
    
    * :pencil2: Fix typo in comments
    
    * :rotating_light: Fix linter warnings
    
    * :art: UpdateService accepts two strings
    
    * :white_check_mark: Add test that services are received in discover
    
    * :sparkles: adds required services
    
    * :art: Handle closed connections consistently
    
    * :art: Code cleanup
    
    * :bug: fixes DropPeer
    
    * :art: improves debug messages
    
    * :loud_sound: Log errors during reverification
    
    * :loud_sound:
    
     Log packet size
    
    * refactor: remove unused files
    
    * refactor: use internal autopeering package
    
    Co-authored-by: default avatarAngelo Capossele <angelocapossele@gmail.com>
    Co-authored-by: default avatarjkrvivian <jkrvivian@gmail.com>
    8fde09bf
    History
    protocol_test.go 7.89 KiB
    package discover
    
    import (
    	"log"
    	"testing"
    	"time"
    
    	"github.com/iotaledger/goshimmer/packages/autopeering/peer"
    	"github.com/iotaledger/goshimmer/packages/autopeering/peer/service"
    	"github.com/iotaledger/goshimmer/packages/autopeering/server"
    	"github.com/iotaledger/goshimmer/packages/autopeering/transport"
    	"github.com/stretchr/testify/assert"
    	"github.com/stretchr/testify/require"
    	"go.uber.org/zap"
    )
    
    const graceTime = 100 * time.Millisecond
    
    var logger *zap.SugaredLogger
    
    func init() {
    	l, err := zap.NewDevelopment()
    	if err != nil {
    		log.Fatalf("cannot initialize logger: %v", err)
    	}
    	logger = l.Sugar()
    
    	// decrease parameters to simplify and speed up tests
    	reverifyInterval = 500 * time.Millisecond
    	queryInterval = 1000 * time.Millisecond
    	maxManaged = 10
    	maxReplacements = 2
    }
    
    // newTest creates a new discovery server and also returns the teardown.
    func newTest(t require.TestingT, trans transport.Transport, logger *zap.SugaredLogger, masters ...*peer.Peer) (*server.Server, *Protocol, func()) {
    	log := logger.Named(trans.LocalAddr().String())
    	db := peer.NewMemoryDB(log.Named("db"))
    	local, err := peer.NewLocal(trans.LocalAddr().Network(), trans.LocalAddr().String(), db)
    	require.NoError(t, err)
    
    	cfg := Config{
    		Log:         log,
    		MasterPeers: masters,
    	}
    	prot := New(local, cfg)
    	srv := server.Listen(local, trans, log.Named("srv"), prot)
    	prot.Start(srv)
    
    	teardown := func() {
    		srv.Close()
    		prot.Close()
    		db.Close()
    	}
    	return srv, prot, teardown
    }
    
    func getPeer(s *server.Server) *peer.Peer {
    	return &s.Local().Peer
    }
    
    func TestProtVerifyMaster(t *testing.T) {
    	p2p := transport.P2P()
    	defer p2p.Close()
    
    	srvA, _, closeA := newTest(t, p2p.A, logger)
    	defer closeA()
    	peerA := getPeer(srvA)
    
    	// use peerA as masters peer
    	_, protB, closeB := newTest(t, p2p.B, logger, peerA)
    
    	time.Sleep(graceTime) // wait for the packages to ripple through the network
    	closeB()              // close srvB to avoid race conditions, when asserting
    
    	if assert.EqualValues(t, 1, len(protB.mgr.active)) {
    		assert.EqualValues(t, peerA, &protB.mgr.active[0].Peer)
    		assert.EqualValues(t, 1, protB.mgr.active[0].verifiedCount)
    	}
    }
    
    func TestProtPingPong(t *testing.T) {
    	p2p := transport.P2P()
    	defer p2p.Close()
    
    	srvA, protA, closeA := newTest(t, p2p.A, logger)
    	defer closeA()
    	srvB, protB, closeB := newTest(t, p2p.B, logger)
    	defer closeB()
    
    	peerA := getPeer(srvA)
    	peerB := getPeer(srvB)
    
    	// send a ping from node A to B
    	t.Run("A->B", func(t *testing.T) { assert.NoError(t, protA.ping(peerB)) })
    	time.Sleep(graceTime)
    
    	// send a ping from node B to A
    	t.Run("B->A", func(t *testing.T) { assert.NoError(t, protB.ping(peerA)) })
    	time.Sleep(graceTime)
    }
    
    func TestProtPingTimeout(t *testing.T) {
    	p2p := transport.P2P()
    	defer p2p.Close()
    
    	_, protA, closeA := newTest(t, p2p.A, logger)
    	defer closeA()
    	srvB, _, closeB := newTest(t, p2p.B, logger)
    	closeB() // close the connection right away to prevent any replies
    
    	peerB := getPeer(srvB)
    
    	// send a ping from node A to B
    	err := protA.ping(peerB)
    	assert.EqualError(t, err, server.ErrTimeout.Error())
    }
    
    func TestProtVerifiedPeers(t *testing.T) {
    	p2p := transport.P2P()
    	defer p2p.Close()
    
    	_, protA, closeA := newTest(t, p2p.A, logger)
    	defer closeA()
    	srvB, _, closeB := newTest(t, p2p.B, logger)
    	defer closeB()
    
    	peerB := getPeer(srvB)
    
    	// send a ping from node A to B
    	assert.NoError(t, protA.ping(peerB))
    	time.Sleep(graceTime)
    
    	// protA should have peerB as the single verified peer
    	assert.ElementsMatch(t, []*peer.Peer{peerB}, protA.GetVerifiedPeers())
    	for _, p := range protA.GetVerifiedPeers() {
    		assert.Equal(t, p, protA.GetVerifiedPeer(p.ID(), p.Address()))
    	}
    }
    
    func TestProtVerifiedPeer(t *testing.T) {
    	p2p := transport.P2P()
    	defer p2p.Close()
    
    	srvA, protA, closeA := newTest(t, p2p.A, logger)
    	defer closeA()
    	srvB, _, closeB := newTest(t, p2p.B, logger)
    	defer closeB()
    
    	peerA := getPeer(srvA)
    	peerB := getPeer(srvB)
    
    	// send a ping from node A to B
    	assert.NoError(t, protA.ping(peerB))
    	time.Sleep(graceTime)
    
    	// we should have peerB as a verified peer
    	assert.Equal(t, peerB, protA.GetVerifiedPeer(peerB.ID(), peerB.Address()))
    	// we should not have ourself as a verified peer
    	assert.Nil(t, protA.GetVerifiedPeer(peerA.ID(), peerA.Address()))
    	// the address of peerB should match
    	assert.Nil(t, protA.GetVerifiedPeer(peerB.ID(), ""))
    }
    
    func TestProtDiscoveryRequest(t *testing.T) {
    	p2p := transport.P2P()
    	defer p2p.Close()
    
    	srvA, protA, closeA := newTest(t, p2p.A, logger)
    	defer closeA()
    	srvB, protB, closeB := newTest(t, p2p.B, logger)
    	defer closeB()
    
    	peerA := getPeer(srvA)
    	peerB := getPeer(srvB)
    
    	// request peers from node A
    	t.Run("A->B", func(t *testing.T) {
    		if ps, err := protA.discoveryRequest(peerB); assert.NoError(t, err) {
    			assert.ElementsMatch(t, []*peer.Peer{peerA}, ps)
    		}
    	})
    	// request peers from node B
    	t.Run("B->A", func(t *testing.T) {
    		if ps, err := protB.discoveryRequest(peerA); assert.NoError(t, err) {
    			assert.ElementsMatch(t, []*peer.Peer{peerB}, ps)
    		}
    	})
    }
    
    func TestProtServices(t *testing.T) {
    	p2p := transport.P2P()
    	defer p2p.Close()
    
    	srvA, _, closeA := newTest(t, p2p.A, logger)
    	defer closeA()
    	err := srvA.Local().UpdateService(service.FPCKey, "fpc", p2p.A.LocalAddr().String())
    	require.NoError(t, err)
    
    	// use peerA as masters peer
    	_, protB, closeB := newTest(t, p2p.B, logger, getPeer(srvA))
    	defer closeB()
    
    	time.Sleep(graceTime) // wait for the packages to ripple through the network
    	ps := protB.GetVerifiedPeers()
    
    	if assert.ElementsMatch(t, []*peer.Peer{getPeer(srvA)}, ps) {
    		assert.Equal(t, srvA.Local().Services(), ps[0].Services())
    	}
    }
    
    func TestProtDiscovery(t *testing.T) {
    	net := transport.NewNetwork("M", "A", "B", "C")
    	defer net.Close()
    
    	srvM, protM, closeM := newTest(t, net.GetTransport("M"), logger)
    	defer closeM()
    	time.Sleep(graceTime) // wait for the master to initialize
    
    	srvA, protA, closeA := newTest(t, net.GetTransport("A"), logger, getPeer(srvM))
    	defer closeA()
    	srvB, protB, closeB := newTest(t, net.GetTransport("B"), logger, getPeer(srvM))
    	defer closeB()
    	srvC, protC, closeC := newTest(t, net.GetTransport("C"), logger, getPeer(srvM))
    	defer closeC()
    
    	time.Sleep(queryInterval + graceTime)    // wait for the next discovery cycle
    	time.Sleep(reverifyInterval + graceTime) // wait for the next verification cycle
    
    	// now the full network should be discovered
    	assert.ElementsMatch(t, []*peer.Peer{getPeer(srvA), getPeer(srvB), getPeer(srvC)}, protM.GetVerifiedPeers())
    	assert.ElementsMatch(t, []*peer.Peer{getPeer(srvM), getPeer(srvB), getPeer(srvC)}, protA.GetVerifiedPeers())
    	assert.ElementsMatch(t, []*peer.Peer{getPeer(srvM), getPeer(srvA), getPeer(srvC)}, protB.GetVerifiedPeers())
    	assert.ElementsMatch(t, []*peer.Peer{getPeer(srvM), getPeer(srvA), getPeer(srvB)}, protC.GetVerifiedPeers())
    }
    
    func BenchmarkPingPong(b *testing.B) {
    	p2p := transport.P2P()
    	defer p2p.Close()
    	log := zap.NewNop().Sugar() // disable logging
    
    	// disable query/reverify
    	reverifyInterval = time.Hour
    	queryInterval = time.Hour
    
    	_, protA, closeA := newTest(b, p2p.A, log)
    	defer closeA()
    	srvB, _, closeB := newTest(b, p2p.B, log)
    	defer closeB()
    
    	peerB := getPeer(srvB)
    
    	// send initial ping to ensure that every peer is verified
    	err := protA.ping(peerB)
    	require.NoError(b, err)
    	time.Sleep(graceTime)
    
    	b.ResetTimer()
    	for n := 0; n < b.N; n++ {
    		// send a ping from node A to B
    		_ = protA.ping(peerB)
    	}
    
    	b.StopTimer()
    }
    
    func BenchmarkDiscoveryRequest(b *testing.B) {
    	p2p := transport.P2P()
    	defer p2p.Close()
    	log := zap.NewNop().Sugar() // disable logging
    
    	// disable query/reverify
    	reverifyInterval = time.Hour
    	queryInterval = time.Hour
    
    	_, protA, closeA := newTest(b, p2p.A, log)
    	defer closeA()
    	srvB, _, closeB := newTest(b, p2p.B, log)
    	defer closeB()
    
    	peerB := getPeer(srvB)
    
    	// send initial request to ensure that every peer is verified
    	_, err := protA.discoveryRequest(peerB)
    	require.NoError(b, err)
    	time.Sleep(graceTime)
    
    	b.ResetTimer()
    	for n := 0; n < b.N; n++ {
    		_, _ = protA.discoveryRequest(peerB)
    	}
    
    	b.StopTimer()
    }