447 lines
17 KiB
Nim
447 lines
17 KiB
Nim
{.used.}
|
|
|
|
# Nim-Libp2p
|
|
# Copyright (c) 2023 Status Research & Development GmbH
|
|
# Licensed under either of
|
|
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
|
|
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
|
|
# at your option.
|
|
# This file may not be copied, modified, or distributed except according to
|
|
# those terms.
|
|
|
|
import std/[options, sequtils]
|
|
import chronos, metrics
|
|
import unittest2
|
|
import ../libp2p/[builders,
|
|
switch,
|
|
protocols/connectivity/autonat/client,
|
|
protocols/connectivity/autonat/service]
|
|
import ../libp2p/nameresolving/[nameresolver, mockresolver]
|
|
import ./helpers
|
|
import stubs/autonatclientstub
|
|
|
|
proc createSwitch(autonatSvc: Service = nil, withAutonat = true, maxConnsPerPeer = 1, maxConns = 100, nameResolver: NameResolver = nil): Switch =
|
|
var builder = SwitchBuilder.new()
|
|
.withRng(newRng())
|
|
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
|
|
.withTcpTransport()
|
|
.withMaxConnsPerPeer(maxConnsPerPeer)
|
|
.withMaxConnections(maxConns)
|
|
.withMplex()
|
|
.withNoise()
|
|
|
|
if withAutonat:
|
|
builder = builder.withAutonat()
|
|
|
|
if autonatSvc != nil:
|
|
builder = builder.withServices(@[autonatSvc])
|
|
|
|
if nameResolver != nil:
|
|
builder = builder.withNameResolver(nameResolver)
|
|
|
|
return builder.build()
|
|
|
|
suite "Autonat Service":
|
|
teardown:
|
|
checkTrackers()
|
|
|
|
asyncTest "Peer must be not reachable":
|
|
|
|
let autonatClientStub = AutonatClientStub.new(expectedDials = 3)
|
|
autonatClientStub.answer = NotReachable
|
|
|
|
let autonatService = AutonatService.new(autonatClientStub, newRng())
|
|
|
|
let switch1 = createSwitch(autonatService)
|
|
let switch2 = createSwitch()
|
|
let switch3 = createSwitch()
|
|
let switch4 = createSwitch()
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Unknown
|
|
|
|
await switch1.start()
|
|
await switch2.start()
|
|
await switch3.start()
|
|
await switch4.start()
|
|
|
|
await switch1.connect(switch2.peerInfo.peerId, switch2.peerInfo.addrs)
|
|
await switch1.connect(switch3.peerInfo.peerId, switch3.peerInfo.addrs)
|
|
await switch1.connect(switch4.peerInfo.peerId, switch4.peerInfo.addrs)
|
|
|
|
await autonatClientStub.finished
|
|
|
|
check autonatService.networkReachability == NetworkReachability.NotReachable
|
|
check libp2p_autonat_reachability_confidence.value(["NotReachable"]) == 0.3
|
|
|
|
await allFuturesThrowing(
|
|
switch1.stop(), switch2.stop(), switch3.stop(), switch4.stop())
|
|
|
|
asyncTest "Peer must be reachable":
|
|
|
|
let autonatService = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(1.seconds))
|
|
|
|
let switch1 = createSwitch(autonatService)
|
|
let switch2 = createSwitch()
|
|
let switch3 = createSwitch()
|
|
let switch4 = createSwitch()
|
|
|
|
let awaiter = newFuture[void]()
|
|
|
|
proc statusAndConfidenceHandler(networkReachability: NetworkReachability, confidence: Opt[float]) {.gcsafe, async.} =
|
|
if networkReachability == NetworkReachability.Reachable and confidence.isSome() and confidence.get() >= 0.3:
|
|
if not awaiter.finished:
|
|
awaiter.complete()
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Unknown
|
|
|
|
autonatService.statusAndConfidenceHandler(statusAndConfidenceHandler)
|
|
|
|
await switch1.start()
|
|
await switch2.start()
|
|
await switch3.start()
|
|
await switch4.start()
|
|
|
|
await switch1.connect(switch2.peerInfo.peerId, switch2.peerInfo.addrs)
|
|
await switch1.connect(switch3.peerInfo.peerId, switch3.peerInfo.addrs)
|
|
await switch1.connect(switch4.peerInfo.peerId, switch4.peerInfo.addrs)
|
|
|
|
await awaiter
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Reachable
|
|
check libp2p_autonat_reachability_confidence.value(["Reachable"]) == 0.3
|
|
|
|
check switch1.peerInfo.addrs == switch1.peerInfo.listenAddrs.mapIt(switch1.peerStore.guessDialableAddr(it))
|
|
|
|
await allFuturesThrowing(
|
|
switch1.stop(), switch2.stop(), switch3.stop(), switch4.stop())
|
|
|
|
check switch1.peerInfo.addrs == switch1.peerInfo.listenAddrs
|
|
|
|
asyncTest "Peer must be not reachable and then reachable":
|
|
|
|
let autonatClientStub = AutonatClientStub.new(expectedDials = 6)
|
|
autonatClientStub.answer = NotReachable
|
|
|
|
let autonatService = AutonatService.new(autonatClientStub, newRng(), Opt.some(1.seconds))
|
|
|
|
let switch1 = createSwitch(autonatService)
|
|
let switch2 = createSwitch()
|
|
let switch3 = createSwitch()
|
|
let switch4 = createSwitch()
|
|
|
|
let awaiter = newFuture[void]()
|
|
|
|
proc statusAndConfidenceHandler(networkReachability: NetworkReachability, confidence: Opt[float]) {.gcsafe, async.} =
|
|
if networkReachability == NetworkReachability.NotReachable and confidence.isSome() and confidence.get() >= 0.3:
|
|
if not awaiter.finished:
|
|
autonatClientStub.answer = Reachable
|
|
awaiter.complete()
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Unknown
|
|
|
|
autonatService.statusAndConfidenceHandler(statusAndConfidenceHandler)
|
|
|
|
await switch1.start()
|
|
await switch2.start()
|
|
await switch3.start()
|
|
await switch4.start()
|
|
|
|
await switch1.connect(switch2.peerInfo.peerId, switch2.peerInfo.addrs)
|
|
await switch1.connect(switch3.peerInfo.peerId, switch3.peerInfo.addrs)
|
|
await switch1.connect(switch4.peerInfo.peerId, switch4.peerInfo.addrs)
|
|
|
|
await awaiter
|
|
|
|
check autonatService.networkReachability == NetworkReachability.NotReachable
|
|
check libp2p_autonat_reachability_confidence.value(["NotReachable"]) == 0.3
|
|
|
|
await autonatClientStub.finished
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Reachable
|
|
check libp2p_autonat_reachability_confidence.value(["Reachable"]) == 0.3
|
|
|
|
await allFuturesThrowing(switch1.stop(), switch2.stop(), switch3.stop(), switch4.stop())
|
|
|
|
asyncTest "Peer must be reachable when one connected peer has autonat disabled":
|
|
|
|
let autonatService = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(1.seconds), maxQueueSize = 2)
|
|
|
|
let switch1 = createSwitch(autonatService)
|
|
let switch2 = createSwitch(withAutonat = false)
|
|
let switch3 = createSwitch()
|
|
let switch4 = createSwitch()
|
|
|
|
let awaiter = newFuture[void]()
|
|
|
|
proc statusAndConfidenceHandler(networkReachability: NetworkReachability, confidence: Opt[float]) {.gcsafe, async.} =
|
|
if networkReachability == NetworkReachability.Reachable and confidence.isSome() and confidence.get() == 1:
|
|
if not awaiter.finished:
|
|
awaiter.complete()
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Unknown
|
|
|
|
autonatService.statusAndConfidenceHandler(statusAndConfidenceHandler)
|
|
|
|
await switch1.start()
|
|
await switch2.start()
|
|
await switch3.start()
|
|
await switch4.start()
|
|
|
|
await switch1.connect(switch2.peerInfo.peerId, switch2.peerInfo.addrs)
|
|
await switch1.connect(switch3.peerInfo.peerId, switch3.peerInfo.addrs)
|
|
await switch1.connect(switch4.peerInfo.peerId, switch4.peerInfo.addrs)
|
|
|
|
await awaiter
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Reachable
|
|
check libp2p_autonat_reachability_confidence.value(["Reachable"]) == 1
|
|
|
|
await allFuturesThrowing(
|
|
switch1.stop(), switch2.stop(), switch3.stop(), switch4.stop())
|
|
|
|
asyncTest "Unknown answers must be ignored":
|
|
|
|
let autonatClientStub = AutonatClientStub.new(expectedDials = 6)
|
|
autonatClientStub.answer = NotReachable
|
|
|
|
let autonatService = AutonatService.new(autonatClientStub, newRng(), Opt.some(1.seconds), maxQueueSize = 3)
|
|
|
|
let switch1 = createSwitch(autonatService)
|
|
let switch2 = createSwitch()
|
|
let switch3 = createSwitch()
|
|
let switch4 = createSwitch()
|
|
|
|
let awaiter = newFuture[void]()
|
|
|
|
proc statusAndConfidenceHandler(networkReachability: NetworkReachability, confidence: Opt[float]) {.gcsafe, async.} =
|
|
if networkReachability == NetworkReachability.NotReachable and confidence.isSome() and confidence.get() >= 0.3:
|
|
if not awaiter.finished:
|
|
autonatClientStub.answer = Unknown
|
|
awaiter.complete()
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Unknown
|
|
|
|
autonatService.statusAndConfidenceHandler(statusAndConfidenceHandler)
|
|
|
|
await switch1.start()
|
|
await switch2.start()
|
|
await switch3.start()
|
|
await switch4.start()
|
|
|
|
await switch1.connect(switch2.peerInfo.peerId, switch2.peerInfo.addrs)
|
|
await switch1.connect(switch3.peerInfo.peerId, switch3.peerInfo.addrs)
|
|
await switch1.connect(switch4.peerInfo.peerId, switch4.peerInfo.addrs)
|
|
|
|
await awaiter
|
|
|
|
check autonatService.networkReachability == NetworkReachability.NotReachable
|
|
check libp2p_autonat_reachability_confidence.value(["NotReachable"]) == 1/3
|
|
|
|
await autonatClientStub.finished
|
|
|
|
check autonatService.networkReachability == NetworkReachability.NotReachable
|
|
check libp2p_autonat_reachability_confidence.value(["NotReachable"]) == 1/3
|
|
|
|
await allFuturesThrowing(switch1.stop(), switch2.stop(), switch3.stop(), switch4.stop())
|
|
|
|
asyncTest "Calling setup and stop twice must work":
|
|
|
|
let switch = createSwitch()
|
|
let autonatService = AutonatService.new(AutonatClientStub.new(expectedDials = 0), newRng(), Opt.some(1.seconds))
|
|
|
|
check (await autonatService.setup(switch)) == true
|
|
check (await autonatService.setup(switch)) == false
|
|
|
|
check (await autonatService.stop(switch)) == true
|
|
check (await autonatService.stop(switch)) == false
|
|
|
|
await allFuturesThrowing(switch.stop())
|
|
|
|
asyncTest "Must bypass maxConnectionsPerPeer limit":
|
|
let autonatService = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(1.seconds), maxQueueSize = 1)
|
|
|
|
let switch1 = createSwitch(autonatService, maxConnsPerPeer = 0)
|
|
await switch1.setDNSAddr()
|
|
|
|
let switch2 = createSwitch(maxConnsPerPeer = 0, nameResolver = MockResolver.default())
|
|
|
|
let awaiter = newFuture[void]()
|
|
|
|
proc statusAndConfidenceHandler(networkReachability: NetworkReachability, confidence: Opt[float]) {.gcsafe, async.} =
|
|
if networkReachability == NetworkReachability.Reachable and confidence.isSome() and confidence.get() == 1:
|
|
if not awaiter.finished:
|
|
awaiter.complete()
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Unknown
|
|
|
|
autonatService.statusAndConfidenceHandler(statusAndConfidenceHandler)
|
|
|
|
await switch1.start()
|
|
await switch2.start()
|
|
|
|
await switch1.connect(switch2.peerInfo.peerId, switch2.peerInfo.addrs)
|
|
|
|
await awaiter
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Reachable
|
|
check libp2p_autonat_reachability_confidence.value(["Reachable"]) == 1
|
|
|
|
await allFuturesThrowing(
|
|
switch1.stop(), switch2.stop())
|
|
|
|
asyncTest "Must work when peers ask each other at the same time with max 1 conn per peer":
|
|
let autonatService1 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3)
|
|
let autonatService2 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3)
|
|
let autonatService3 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3)
|
|
|
|
let switch1 = createSwitch(autonatService1, maxConnsPerPeer = 0)
|
|
let switch2 = createSwitch(autonatService2, maxConnsPerPeer = 0)
|
|
let switch3 = createSwitch(autonatService2, maxConnsPerPeer = 0)
|
|
|
|
let awaiter1 = newFuture[void]()
|
|
let awaiter2 = newFuture[void]()
|
|
let awaiter3 = newFuture[void]()
|
|
|
|
proc statusAndConfidenceHandler1(networkReachability: NetworkReachability, confidence: Opt[float]) {.gcsafe, async.} =
|
|
if networkReachability == NetworkReachability.Reachable and confidence.isSome() and confidence.get() == 1:
|
|
if not awaiter1.finished:
|
|
awaiter1.complete()
|
|
|
|
proc statusAndConfidenceHandler2(networkReachability: NetworkReachability, confidence: Opt[float]) {.gcsafe, async.} =
|
|
if networkReachability == NetworkReachability.Reachable and confidence.isSome() and confidence.get() == 1:
|
|
if not awaiter2.finished:
|
|
awaiter2.complete()
|
|
|
|
check autonatService1.networkReachability == NetworkReachability.Unknown
|
|
check autonatService2.networkReachability == NetworkReachability.Unknown
|
|
|
|
autonatService1.statusAndConfidenceHandler(statusAndConfidenceHandler1)
|
|
autonatService2.statusAndConfidenceHandler(statusAndConfidenceHandler2)
|
|
|
|
await switch1.start()
|
|
await switch2.start()
|
|
await switch3.start()
|
|
|
|
await switch1.connect(switch2.peerInfo.peerId, switch2.peerInfo.addrs)
|
|
await switch2.connect(switch1.peerInfo.peerId, switch1.peerInfo.addrs)
|
|
await switch2.connect(switch3.peerInfo.peerId, switch3.peerInfo.addrs)
|
|
|
|
await awaiter1
|
|
await awaiter2
|
|
|
|
check autonatService1.networkReachability == NetworkReachability.Reachable
|
|
check autonatService2.networkReachability == NetworkReachability.Reachable
|
|
check libp2p_autonat_reachability_confidence.value(["Reachable"]) == 1
|
|
|
|
await allFuturesThrowing(
|
|
switch1.stop(), switch2.stop(), switch3.stop())
|
|
|
|
asyncTest "Must work for one peer when two peers ask each other at the same time with max 1 conn per peer":
|
|
let autonatService1 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3)
|
|
let autonatService2 = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(500.millis), maxQueueSize = 3)
|
|
|
|
let switch1 = createSwitch(autonatService1, maxConnsPerPeer = 0)
|
|
let switch2 = createSwitch(autonatService2, maxConnsPerPeer = 0)
|
|
|
|
let awaiter1 = newFuture[void]()
|
|
|
|
proc statusAndConfidenceHandler1(networkReachability: NetworkReachability, confidence: Opt[float]) {.gcsafe, async.} =
|
|
if networkReachability == NetworkReachability.Reachable and confidence.isSome() and confidence.get() == 1:
|
|
if not awaiter1.finished:
|
|
awaiter1.complete()
|
|
|
|
check autonatService1.networkReachability == NetworkReachability.Unknown
|
|
|
|
autonatService1.statusAndConfidenceHandler(statusAndConfidenceHandler1)
|
|
|
|
await switch1.start()
|
|
await switch2.start()
|
|
|
|
await switch1.connect(switch2.peerInfo.peerId, switch2.peerInfo.addrs)
|
|
try:
|
|
# We allow a temp conn for the peer to dial us. It could use this conn to just connect to us and not dial.
|
|
# We don't care if it fails at this point or not. But this conn must be closed eventually.
|
|
# Bellow we check that there's only one connection between the peers
|
|
await switch2.connect(switch1.peerInfo.peerId, switch1.peerInfo.addrs, reuseConnection = false)
|
|
except CatchableError:
|
|
discard
|
|
|
|
await awaiter1
|
|
|
|
check autonatService1.networkReachability == NetworkReachability.Reachable
|
|
check libp2p_autonat_reachability_confidence.value(["Reachable"]) == 1
|
|
|
|
# Make sure remote peer can't create a connection to us
|
|
check switch1.connManager.connCount(switch2.peerInfo.peerId) == 1
|
|
|
|
await allFuturesThrowing(
|
|
switch1.stop(), switch2.stop())
|
|
|
|
asyncTest "Must work with low maxConnections":
|
|
let autonatService = AutonatService.new(AutonatClient.new(), newRng(), Opt.some(1.seconds), maxQueueSize = 1)
|
|
|
|
let switch1 = createSwitch(autonatService, maxConns = 4)
|
|
let switch2 = createSwitch()
|
|
let switch3 = createSwitch()
|
|
let switch4 = createSwitch()
|
|
let switch5 = createSwitch()
|
|
|
|
var awaiter = newFuture[void]()
|
|
|
|
proc statusAndConfidenceHandler(networkReachability: NetworkReachability, confidence: Opt[float]) {.gcsafe, async.} =
|
|
if networkReachability == NetworkReachability.Reachable and confidence.isSome() and confidence.get() == 1:
|
|
if not awaiter.finished:
|
|
awaiter.complete()
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Unknown
|
|
|
|
autonatService.statusAndConfidenceHandler(statusAndConfidenceHandler)
|
|
|
|
await switch1.start()
|
|
await switch2.start()
|
|
await switch3.start()
|
|
await switch4.start()
|
|
await switch5.start()
|
|
|
|
await switch1.connect(switch2.peerInfo.peerId, switch2.peerInfo.addrs)
|
|
|
|
await awaiter
|
|
|
|
await switch1.connect(switch3.peerInfo.peerId, switch3.peerInfo.addrs)
|
|
await switch1.connect(switch4.peerInfo.peerId, switch4.peerInfo.addrs)
|
|
await switch5.connect(switch1.peerInfo.peerId, switch1.peerInfo.addrs)
|
|
# switch1 is now full, should stick to last observation
|
|
awaiter = newFuture[void]()
|
|
await autonatService.run(switch1)
|
|
|
|
await sleepAsync(200.millis)
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Reachable
|
|
check libp2p_autonat_reachability_confidence.value(["Reachable"]) == 1
|
|
|
|
await allFuturesThrowing(
|
|
switch1.stop(), switch2.stop(), switch3.stop(), switch4.stop(), switch5.stop())
|
|
|
|
asyncTest "Peer must not ask an incoming peer":
|
|
let autonatService = AutonatService.new(AutonatClient.new(), newRng())
|
|
|
|
let switch1 = createSwitch(autonatService)
|
|
let switch2 = createSwitch()
|
|
|
|
proc statusAndConfidenceHandler(networkReachability: NetworkReachability, confidence: Opt[float]) {.gcsafe, async.} =
|
|
fail()
|
|
|
|
check autonatService.networkReachability == NetworkReachability.Unknown
|
|
|
|
autonatService.statusAndConfidenceHandler(statusAndConfidenceHandler)
|
|
|
|
await switch1.start()
|
|
await switch2.start()
|
|
|
|
await switch2.connect(switch1.peerInfo.peerId, switch1.peerInfo.addrs)
|
|
|
|
await sleepAsync(500.milliseconds)
|
|
|
|
await allFuturesThrowing(
|
|
switch1.stop(), switch2.stop())
|