mirror of
https://github.com/logos-storage/nim-libp2p.git
synced 2026-02-18 12:33:07 +00:00
0959877b29
* master merge * wip * avoid deadlocks * tcp limits * expose client field in chronosstream * limit incoming connections * update with new listen api * fix release * don't override peerinfo in connection * rework transport with accept * use semaphore to track resource ussage * rework with new transport accept api * move events to conn manager (#373) * use semaphore to track resource ussage * merge master * expose api to acquire conn slots * don't fail expensive metrics * allow tracking and updating connections * set global connection limits to 80 * add per peer connection limits * make sure conn is closed if tracking failed * more descriptive naming for handle * rework with new transport accept api * add `getStream` hide `selectConn` * add TransportClosedError * make nil explicit * don't make unnecessary copies of message * logging * error handling * cleanup semaphore * track connections properly * throw `TooManyConnections` when tracking outgoing * use proper exception and handle conventions * check onCloseHandle for nil * revert internalConnect changes * adding upgraded flag * await stream before closing * simplify tracking * wip * logging * split connection limits into incoming and outgoing * further streamline connection limits split counts * don't use closeWithEOF * move peer and conn event triggers from switch * wip * wip * wip * merge master * handle nil connections properly * add clarifying comment * don't raise exc on nil * no finally * add proper min/max connections logic * rebase master * merge master * master merge * remove request timeout should be addressed in separate PR * merge master * share semaphore when in/out limits arent enforced * merge master * use import * pass semaphore to trackConn * don't close last conn * use storeConn * merge master * use storeConn
242 lines
6.6 KiB
Nim
242 lines
6.6 KiB
Nim
import unittest, sequtils
|
|
import chronos
|
|
import ../libp2p/[connmanager,
|
|
stream/connection,
|
|
crypto/crypto,
|
|
muxers/muxer,
|
|
peerinfo,
|
|
errors]
|
|
|
|
import helpers
|
|
|
|
type
|
|
TestMuxer = ref object of Muxer
|
|
peerInfo: PeerInfo
|
|
|
|
method newStream*(
|
|
m: TestMuxer,
|
|
name: string = "",
|
|
lazy: bool = false):
|
|
Future[Connection] {.async, gcsafe.} =
|
|
result = Connection.init(m.peerInfo, Direction.Out)
|
|
|
|
suite "Connection Manager":
|
|
teardown:
|
|
checkTrackers()
|
|
|
|
asyncTest "add and retrieve a connection":
|
|
let connMngr = ConnManager.init()
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
let conn = Connection.init(peer, Direction.In)
|
|
|
|
connMngr.storeConn(conn)
|
|
check conn in connMngr
|
|
|
|
let peerConn = connMngr.selectConn(peer.peerId)
|
|
check peerConn == conn
|
|
check peerConn.dir == Direction.In
|
|
|
|
await connMngr.close()
|
|
|
|
asyncTest "shouldn't allow a closed connection":
|
|
let connMngr = ConnManager.init()
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
let conn = Connection.init(peer, Direction.In)
|
|
await conn.close()
|
|
|
|
expect CatchableError:
|
|
connMngr.storeConn(conn)
|
|
|
|
await connMngr.close()
|
|
|
|
asyncTest "shouldn't allow an EOFed connection":
|
|
let connMngr = ConnManager.init()
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
let conn = Connection.init(peer, Direction.In)
|
|
conn.isEof = true
|
|
|
|
expect CatchableError:
|
|
connMngr.storeConn(conn)
|
|
|
|
await conn.close()
|
|
await connMngr.close()
|
|
|
|
asyncTest "add and retrieve a muxer":
|
|
let connMngr = ConnManager.init()
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
let conn = Connection.init(peer, Direction.In)
|
|
let muxer = new Muxer
|
|
muxer.connection = conn
|
|
|
|
connMngr.storeConn(conn)
|
|
connMngr.storeMuxer(muxer)
|
|
check muxer in connMngr
|
|
|
|
let peerMuxer = connMngr.selectMuxer(conn)
|
|
check peerMuxer == muxer
|
|
|
|
await connMngr.close()
|
|
|
|
asyncTest "shouldn't allow a muxer for an untracked connection":
|
|
let connMngr = ConnManager.init()
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
let conn = Connection.init(peer, Direction.In)
|
|
let muxer = new Muxer
|
|
muxer.connection = conn
|
|
|
|
expect CatchableError:
|
|
connMngr.storeMuxer(muxer)
|
|
|
|
await conn.close()
|
|
await muxer.close()
|
|
await connMngr.close()
|
|
|
|
asyncTest "get conn with direction":
|
|
let connMngr = ConnManager.init()
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
let conn1 = Connection.init(peer, Direction.Out)
|
|
let conn2 = Connection.init(peer, Direction.In)
|
|
|
|
connMngr.storeConn(conn1)
|
|
connMngr.storeConn(conn2)
|
|
check conn1 in connMngr
|
|
check conn2 in connMngr
|
|
|
|
let outConn = connMngr.selectConn(peer.peerId, Direction.Out)
|
|
let inConn = connMngr.selectConn(peer.peerId, Direction.In)
|
|
|
|
check outConn != inConn
|
|
check outConn.dir == Direction.Out
|
|
check inConn.dir == Direction.In
|
|
|
|
await connMngr.close()
|
|
|
|
asyncTest "get muxed stream for peer":
|
|
let connMngr = ConnManager.init()
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
let conn = Connection.init(peer, Direction.In)
|
|
|
|
let muxer = new TestMuxer
|
|
muxer.peerInfo = peer
|
|
muxer.connection = conn
|
|
|
|
connMngr.storeConn(conn)
|
|
connMngr.storeMuxer(muxer)
|
|
check muxer in connMngr
|
|
|
|
let stream = await connMngr.getStream(peer.peerId)
|
|
check not(isNil(stream))
|
|
check stream.peerInfo == peer
|
|
|
|
await connMngr.close()
|
|
await stream.close()
|
|
|
|
asyncTest "get stream from directed connection":
|
|
let connMngr = ConnManager.init()
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
let conn = Connection.init(peer, Direction.In)
|
|
|
|
let muxer = new TestMuxer
|
|
muxer.peerInfo = peer
|
|
muxer.connection = conn
|
|
|
|
connMngr.storeConn(conn)
|
|
connMngr.storeMuxer(muxer)
|
|
check muxer in connMngr
|
|
|
|
let stream1 = await connMngr.getStream(peer.peerId, Direction.In)
|
|
check not(isNil(stream1))
|
|
let stream2 = await connMngr.getStream(peer.peerId, Direction.Out)
|
|
check isNil(stream2)
|
|
|
|
await connMngr.close()
|
|
await stream1.close()
|
|
|
|
asyncTest "get stream from any connection":
|
|
let connMngr = ConnManager.init()
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
let conn = Connection.init(peer, Direction.In)
|
|
|
|
let muxer = new TestMuxer
|
|
muxer.peerInfo = peer
|
|
muxer.connection = conn
|
|
|
|
connMngr.storeConn(conn)
|
|
connMngr.storeMuxer(muxer)
|
|
check muxer in connMngr
|
|
|
|
let stream = await connMngr.getStream(conn)
|
|
check not(isNil(stream))
|
|
|
|
await connMngr.close()
|
|
await stream.close()
|
|
|
|
asyncTest "should raise on too many connections":
|
|
let connMngr = ConnManager.init(maxConnsPerPeer = 1)
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
|
|
connMngr.storeConn(Connection.init(peer, Direction.In))
|
|
|
|
let conns = @[
|
|
Connection.init(peer, Direction.In),
|
|
Connection.init(peer, Direction.In)]
|
|
|
|
expect TooManyConnectionsError:
|
|
connMngr.storeConn(conns[0])
|
|
connMngr.storeConn(conns[1])
|
|
|
|
await connMngr.close()
|
|
|
|
await allFuturesThrowing(
|
|
allFutures(conns.mapIt( it.close() )))
|
|
|
|
asyncTest "cleanup on connection close":
|
|
let connMngr = ConnManager.init()
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
let conn = Connection.init(peer, Direction.In)
|
|
let muxer = new Muxer
|
|
|
|
muxer.connection = conn
|
|
connMngr.storeConn(conn)
|
|
connMngr.storeMuxer(muxer)
|
|
|
|
check conn in connMngr
|
|
check muxer in connMngr
|
|
|
|
await conn.close()
|
|
await sleepAsync(10.millis)
|
|
|
|
check conn notin connMngr
|
|
check muxer notin connMngr
|
|
|
|
await connMngr.close()
|
|
|
|
asyncTest "drop connections for peer":
|
|
let connMngr = ConnManager.init()
|
|
let peer = PeerInfo.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet())
|
|
|
|
for i in 0..<2:
|
|
let dir = if i mod 2 == 0:
|
|
Direction.In else:
|
|
Direction.Out
|
|
|
|
let conn = Connection.init(peer, dir)
|
|
let muxer = new Muxer
|
|
muxer.connection = conn
|
|
|
|
connMngr.storeConn(conn)
|
|
connMngr.storeMuxer(muxer)
|
|
|
|
check conn in connMngr
|
|
check muxer in connMngr
|
|
check not(isNil(connMngr.selectConn(peer.peerId, dir)))
|
|
|
|
check peer.peerId in connMngr
|
|
await connMngr.dropPeer(peer.peerId)
|
|
|
|
check peer.peerId notin connMngr
|
|
check isNil(connMngr.selectConn(peer.peerId, Direction.In))
|
|
check isNil(connMngr.selectConn(peer.peerId, Direction.Out))
|
|
|
|
await connMngr.close()
|