Select Git revision
protocol_test.go
Wolfgang Welz
authored and
GitHub
committed
*GetNextCandidate selection added * Recompile salt.proto * Refactor peer IDs completely * Recompile proto sources * WIP * renamed to sort * Return requested peers on request * Kepp track how ofter a managed peer was verified * sort adapted to the new peer * Query verified peers for new peers * WIP * Add manager tests * Add peering messages to protobuf * Make Salt methods consistent with Peer * Handle peering messages * WIP * Add To filed to PeersRequest * Add PeersRequest test * Adding PeersRequest benchmark * Move mpeer and helper functions to own file * Bump peer only once on reverification * WIP * * WIP * Increase buffer to prevent deadlocks * Remove unnecessary lock * Add peering request test * Make tests deterministic by triggering reverify * WIP * fixing concurrency issues * testManager improved * Don't send PeeringResponse for invalid salt * WIP * WIP * removed commented code * WIP * WIP * Neighbourhood manager (#11) * GetNextCandidate selection added * fixing concurrency issues * testManager improved * removed commented code * WIP * WIP * WIP * WIP * Make TestAdd pass in neighborhood_test `Add` should do nothing if the neighborhood list is full. * Improve TestSrvVerifyBoot * Upgrade to go 1.13 * Use testify instead of magiconair/properties * * WIP * WIP * WIP * WIP * Simulation (#14) * clear rejection filter after refreshing the public salt * clean rejection filter * Add mpeer test * gofmt test * Remove ineffactual assignments * Trigger panic when index is out of bound in deletePeer * Add selection test * Add TestGetFurtherest and TestGetPeerIndex * both salt updated at the same time and neighborhood dropped * Add node peering history for simulation * WIP * added sim visualization * removed root handler * added README * updated README * removed unused dependencies * Tidy go.mod * Work in progress * WIP * WIP * WIP * improved start button * WIP * added keyboard support for start * WIP * WIP * WIP * WIP * WIP * WIP * added input parameters * README updated * gif updated * figure updated * updated * updated gif * removed simulation metrics * updated * updated * Extract server from discovery and peering * Use golang/protobuf * Update README.md * Rename PeersRequest to DiscoveryRequest * Fixing typos * Move unused function to tests * The selection protocol depends on the discovery * Make tests more robust when using -race * Improve logging * Remove unnecessary arguments * Fix data races * added timeout for simulated network * added loop to animation * rename neighborhood to selection * adds initial salt and fixes simulation end * visualizer enabled by default * new parameter dropAll and improved python script * updated README * updated README * fix salt initialization * added blogpost link * Add badges to README * Add Travis CI for tests * Correct formating * Running golangci on Travis * Ignore return value of 'logger.Sync' * Remove unused functions * Add link to license * Move simnetwork to transport * Use the complete network protocol in simulations * Do not export selection/manager * Remove gRPC transport layer * Add UDP connection transport test * Implement the peer DB using Goshimmer database * Use the local GoShimmer version * Add support for a persistent database * Persist private key of local peer in database * Set TTL for bootstrap peers * Use GoShimmer events * Store the supported services in the local peer * Use most current GoShimmer git version as a dep * Switch to hive.go event package * Use correct module iotaledger/autopeering-sim * Provide dummy service in autopeering simulation * adds service support in the selection * adds peer discovered events * adds GetIncomingNeighbors and GetOutgoingNeighbors * fixes out of bound error in splitNodeKey * adds public IP support * fixes localhost * fixes localhost parsing * changes selection loop to 1s * switches from fmt.Println to log.Debug * increases maxKnown to 1000 and always triggers discovered peer * adds PeerDeleted event * moves PeerDeleted event into deletePeer * adds config paramters for the peer discovery * adds config parameters to neighbor selection * enable/disable inbound/outbound selection * Improve Godoc comments * modifies disabled outbound selection * fixes bug with disabling the selection * removes getMyIP() from server * removes some debugging logs * 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 * fixes GetVerifiedPeer * adds gossip key to the service * removes debugging logs * Add test for GetVerifiedPeer * Fix main * Add localNetwork to Protocol * Add new but verified peers to the manager * changes configurable parameters * fixes DiscoveryRequest field sequence * Regenerate proto files * Cleanup parameters * Fix potential race condition * Reduce logging verbosity * Add test for selection+discover * Return net.Addr in Transport * Remove inbound/outbound switches completely * Improve logging * Fix peerdb logs * Fix peer updating * Make TestProtFull more robust * Make queryInterval a parameter * Improve loggind during querying * Trigger PeerDiscovered only for active peers * Cleanup protocol tests * Add discovery test on protocol level * Rename maxVerified to maxManaged * Increase default query interval * Improve discover benchmarks * Fix manager tests * Do not use bugged assert.Eventually * Fix linter warnings in server * Remove unused parameters * Make transport work on slices of bytes * Fix typo in comments * Fix linter warnings * UpdateService accepts two strings * Add test that services are received in discover * adds required services * Handle closed connections consistently * Code cleanup * fixes DropPeer * improves debug messages * Log errors during reverification * Log packet size * refactor: remove unused files * refactor: use internal autopeering package Co-authored-by: Angelo Capossele <angelocapossele@gmail.com> Co-authored-by:
jkrvivian <jkrvivian@gmail.com>
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()
}