mirror of https://github.com/vacp2p/nim-libp2p.git
116 lines
4.1 KiB
Nim
116 lines
4.1 KiB
Nim
import std/[os, options, strformat]
|
|
import redis
|
|
import chronos, chronicles
|
|
import ../../libp2p/[builders,
|
|
switch,
|
|
observedaddrmanager,
|
|
services/hpservice,
|
|
services/autorelayservice,
|
|
protocols/connectivity/autonat/client as aclient,
|
|
protocols/connectivity/relay/client as rclient,
|
|
protocols/connectivity/relay/relay,
|
|
protocols/connectivity/autonat/service,
|
|
protocols/ping]
|
|
import ../stubs/autonatclientstub
|
|
import ../errorhelpers
|
|
|
|
proc createSwitch(r: Relay = nil, hpService: Service = nil): Switch =
|
|
let rng = newRng()
|
|
var builder = SwitchBuilder.new()
|
|
.withRng(rng)
|
|
.withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
|
|
.withObservedAddrManager(ObservedAddrManager.new(maxSize = 1, minCount = 1))
|
|
.withTcpTransport({ServerFlags.TcpNoDelay})
|
|
.withYamux()
|
|
.withAutonat()
|
|
.withNoise()
|
|
|
|
if hpService != nil:
|
|
builder = builder.withServices(@[hpService])
|
|
|
|
if r != nil:
|
|
builder = builder.withCircuitRelay(r)
|
|
|
|
let s = builder.build()
|
|
s.mount(Ping.new(rng=rng))
|
|
return s
|
|
|
|
proc main() {.async.} =
|
|
try:
|
|
let relayClient = RelayClient.new()
|
|
let autoRelayService = AutoRelayService.new(1, relayClient, nil, newRng())
|
|
let autonatClientStub = AutonatClientStub.new(expectedDials = 1)
|
|
autonatClientStub.answer = NotReachable
|
|
let autonatService = AutonatService.new(autonatClientStub, newRng(), maxQueueSize = 1)
|
|
let hpservice = HPService.new(autonatService, autoRelayService)
|
|
|
|
let
|
|
isListener = getEnv("MODE") == "listen"
|
|
switch = createSwitch(relayClient, hpservice)
|
|
auxSwitch = createSwitch()
|
|
redisClient = open("redis", 6379.Port)
|
|
|
|
debug "Connected to redis"
|
|
|
|
await switch.start()
|
|
await auxSwitch.start()
|
|
|
|
let relayAddr =
|
|
try:
|
|
redisClient.bLPop(@["RELAY_TCP_ADDRESS"], 0)
|
|
except Exception as e:
|
|
raise newException(CatchableError, e.msg)
|
|
|
|
# This is necessary to make the autonat service work. It will ask this peer for our reachability which the autonat
|
|
# client stub will answer NotReachable.
|
|
await switch.connect(auxSwitch.peerInfo.peerId, auxSwitch.peerInfo.addrs)
|
|
|
|
# Wait for autonat to be NotReachable
|
|
while autonatService.networkReachability != NetworkReachability.NotReachable:
|
|
await sleepAsync(100.milliseconds)
|
|
|
|
# This will trigger the autonat relay service to make a reservation.
|
|
let relayMA = MultiAddress.init(relayAddr[1]).tryGet()
|
|
debug "Got relay address", relayMA
|
|
let relayId = await switch.connect(relayMA)
|
|
debug "Connected to relay", relayId
|
|
|
|
# Wait for our relay address to be published
|
|
while switch.peerInfo.addrs.len == 0:
|
|
await sleepAsync(100.milliseconds)
|
|
|
|
if isListener:
|
|
let listenerPeerId = switch.peerInfo.peerId
|
|
discard redisClient.rPush("LISTEN_CLIENT_PEER_ID", $listenerPeerId)
|
|
debug "Pushed listener client peer id to redis", listenerPeerId
|
|
|
|
# Nothing to do anymore, wait to be killed
|
|
await sleepAsync(2.minutes)
|
|
else:
|
|
let listenerId =
|
|
try:
|
|
PeerId.init(redisClient.bLPop(@["LISTEN_CLIENT_PEER_ID"], 0)[1]).tryGet()
|
|
except Exception as e:
|
|
raise newException(CatchableError, e.msg)
|
|
|
|
debug "Got listener peer id", listenerId
|
|
let listenerRelayAddr = MultiAddress.init($relayMA & "/p2p-circuit").tryGet()
|
|
|
|
debug "Dialing listener relay address", listenerRelayAddr
|
|
await switch.connect(listenerId, @[listenerRelayAddr])
|
|
|
|
# wait for hole-punching to complete in the background
|
|
await sleepAsync(5000.milliseconds)
|
|
|
|
let conn = switch.connManager.selectMuxer(listenerId).connection
|
|
let channel = await switch.dial(listenerId, @[listenerRelayAddr], PingCodec)
|
|
let delay = await Ping.new().ping(channel)
|
|
await allFuturesThrowing(channel.close(), conn.close(), switch.stop(), auxSwitch.stop())
|
|
echo &"""{{"rtt_to_holepunched_peer_millis":{delay.millis}}}"""
|
|
quit(0)
|
|
except CatchableError as e:
|
|
error "Unexpected error", msg = e.msg
|
|
|
|
discard waitFor(main().withTimeout(4.minutes))
|
|
quit(1)
|