2023-05-18 08:24:17 +00:00
|
|
|
{.used.}
|
|
|
|
|
|
|
|
# Nim-Libp2p
|
2024-03-05 07:06:27 +00:00
|
|
|
# Copyright (c) 2023-2024 Status Research & Development GmbH
|
2023-05-18 08:24:17 +00:00
|
|
|
# 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 strformat, stew/byteutils
|
2019-08-30 05:16:55 +00:00
|
|
|
import chronos
|
2024-06-11 15:18:06 +00:00
|
|
|
import
|
|
|
|
../libp2p/multistream,
|
|
|
|
../libp2p/stream/bufferstream,
|
|
|
|
../libp2p/stream/connection,
|
|
|
|
../libp2p/multiaddress,
|
|
|
|
../libp2p/transports/transport,
|
|
|
|
../libp2p/transports/tcptransport,
|
|
|
|
../libp2p/protocols/protocol,
|
|
|
|
../libp2p/upgrademngrs/upgrade
|
2022-01-05 15:27:33 +00:00
|
|
|
|
2023-06-07 11:12:49 +00:00
|
|
|
{.push raises: [].}
|
2022-01-05 15:27:33 +00:00
|
|
|
|
2020-05-08 20:10:06 +00:00
|
|
|
import ./helpers
|
|
|
|
|
2024-06-11 15:18:06 +00:00
|
|
|
when defined(nimHasUsed):
|
|
|
|
{.used.}
|
2019-10-29 18:51:48 +00:00
|
|
|
|
2019-08-30 05:16:55 +00:00
|
|
|
## Mock stream for select test
|
2024-06-11 15:18:06 +00:00
|
|
|
type TestSelectStream = ref object of Connection
|
|
|
|
step*: int
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2024-03-05 07:06:27 +00:00
|
|
|
method readOnce*(
|
2024-06-11 15:18:06 +00:00
|
|
|
s: TestSelectStream, pbytes: pointer, nbytes: int
|
2024-03-05 07:06:27 +00:00
|
|
|
): Future[int] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
|
|
|
|
let fut = newFuture[int]()
|
2024-06-11 15:18:06 +00:00
|
|
|
case s.step
|
2024-03-05 07:06:27 +00:00
|
|
|
of 1:
|
|
|
|
var buf = newSeq[byte](1)
|
|
|
|
buf[0] = 19
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
s.step = 2
|
|
|
|
fut.complete(buf.len)
|
|
|
|
of 2:
|
|
|
|
var buf = "/multistream/1.0.0\n"
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
s.step = 3
|
|
|
|
fut.complete(buf.len)
|
|
|
|
of 3:
|
|
|
|
var buf = newSeq[byte](1)
|
|
|
|
buf[0] = 18
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
s.step = 4
|
|
|
|
fut.complete(buf.len)
|
|
|
|
of 4:
|
|
|
|
var buf = "/test/proto/1.0.0\n"
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
fut.complete(buf.len)
|
|
|
|
else:
|
2024-06-11 15:18:06 +00:00
|
|
|
copyMem(pbytes, cstring("\0x3na\n"), "\0x3na\n".len())
|
2024-03-05 07:06:27 +00:00
|
|
|
|
|
|
|
fut.complete("\0x3na\n".len())
|
|
|
|
fut
|
|
|
|
|
|
|
|
method write*(
|
2024-06-11 15:18:06 +00:00
|
|
|
s: TestSelectStream, msg: seq[byte]
|
|
|
|
): Future[void] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
|
2024-03-05 07:06:27 +00:00
|
|
|
let fut = newFuture[void]()
|
|
|
|
fut.complete()
|
|
|
|
fut
|
|
|
|
|
|
|
|
method close(s: TestSelectStream) {.async: (raises: [], raw: true).} =
|
2019-12-04 04:44:54 +00:00
|
|
|
s.isClosed = true
|
2020-08-03 05:20:11 +00:00
|
|
|
s.isEof = true
|
2024-03-05 07:06:27 +00:00
|
|
|
let fut = newFuture[void]()
|
|
|
|
fut.complete()
|
|
|
|
fut
|
2019-09-06 07:13:03 +00:00
|
|
|
|
2019-08-30 05:16:55 +00:00
|
|
|
proc newTestSelectStream(): TestSelectStream =
|
|
|
|
new result
|
|
|
|
result.step = 1
|
|
|
|
|
|
|
|
## Mock stream for handles `ls` test
|
|
|
|
type
|
2024-06-11 15:18:06 +00:00
|
|
|
LsHandler = proc(procs: seq[byte]): Future[void] {.
|
|
|
|
async: (raises: [CancelledError, LPStreamError])
|
|
|
|
.}
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2020-06-22 21:38:48 +00:00
|
|
|
TestLsStream = ref object of Connection
|
2019-08-30 05:16:55 +00:00
|
|
|
step*: int
|
|
|
|
ls*: LsHandler
|
|
|
|
|
2024-03-05 07:06:27 +00:00
|
|
|
method readOnce*(
|
2024-06-11 15:18:06 +00:00
|
|
|
s: TestLsStream, pbytes: pointer, nbytes: int
|
2024-03-05 07:06:27 +00:00
|
|
|
): Future[int] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
|
|
|
|
let fut = newFuture[int]()
|
2024-06-11 15:18:06 +00:00
|
|
|
case s.step
|
2024-03-05 07:06:27 +00:00
|
|
|
of 1:
|
|
|
|
var buf = newSeq[byte](1)
|
|
|
|
buf[0] = 19
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
s.step = 2
|
|
|
|
fut.complete(buf.len())
|
|
|
|
of 2:
|
|
|
|
var buf = "/multistream/1.0.0\n"
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
s.step = 3
|
|
|
|
fut.complete(buf.len())
|
|
|
|
of 3:
|
|
|
|
var buf = newSeq[byte](1)
|
|
|
|
buf[0] = 3
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
s.step = 4
|
|
|
|
fut.complete(buf.len())
|
|
|
|
of 4:
|
|
|
|
var buf = "ls\n"
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
fut.complete(buf.len())
|
|
|
|
else:
|
|
|
|
var buf = "na\n"
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
fut.complete(buf.len())
|
|
|
|
fut
|
|
|
|
|
|
|
|
method write*(
|
2024-06-11 15:18:06 +00:00
|
|
|
s: TestLsStream, msg: seq[byte]
|
|
|
|
): Future[void] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
|
2019-08-30 05:16:55 +00:00
|
|
|
if s.step == 4:
|
2024-03-05 07:06:27 +00:00
|
|
|
return s.ls(msg)
|
|
|
|
let fut = newFuture[void]()
|
|
|
|
fut.complete()
|
|
|
|
fut
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2024-03-05 07:06:27 +00:00
|
|
|
method close(s: TestLsStream): Future[void] {.async: (raises: [], raw: true).} =
|
2019-12-04 04:44:54 +00:00
|
|
|
s.isClosed = true
|
2020-08-03 05:20:11 +00:00
|
|
|
s.isEof = true
|
2024-03-05 07:06:27 +00:00
|
|
|
let fut = newFuture[void]()
|
|
|
|
fut.complete()
|
|
|
|
fut
|
2019-09-01 17:31:24 +00:00
|
|
|
|
2019-10-04 20:10:01 +00:00
|
|
|
proc newTestLsStream(ls: LsHandler): TestLsStream {.gcsafe.} =
|
2019-08-30 05:16:55 +00:00
|
|
|
new result
|
|
|
|
result.ls = ls
|
|
|
|
result.step = 1
|
|
|
|
|
|
|
|
## Mock stream for handles `na` test
|
|
|
|
type
|
2024-06-11 15:18:06 +00:00
|
|
|
NaHandler = proc(procs: string): Future[void] {.
|
|
|
|
async: (raises: [CancelledError, LPStreamError])
|
|
|
|
.}
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2020-06-22 21:38:48 +00:00
|
|
|
TestNaStream = ref object of Connection
|
2019-08-30 05:16:55 +00:00
|
|
|
step*: int
|
|
|
|
na*: NaHandler
|
|
|
|
|
2024-03-05 07:06:27 +00:00
|
|
|
method readOnce*(
|
2024-06-11 15:18:06 +00:00
|
|
|
s: TestNaStream, pbytes: pointer, nbytes: int
|
2024-03-05 07:06:27 +00:00
|
|
|
): Future[int] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
|
|
|
|
let fut = newFuture[int]()
|
2024-06-11 15:18:06 +00:00
|
|
|
case s.step
|
2024-03-05 07:06:27 +00:00
|
|
|
of 1:
|
|
|
|
var buf = newSeq[byte](1)
|
|
|
|
buf[0] = 19
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
s.step = 2
|
|
|
|
fut.complete(buf.len())
|
|
|
|
of 2:
|
|
|
|
var buf = "/multistream/1.0.0\n"
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
s.step = 3
|
|
|
|
fut.complete(buf.len())
|
|
|
|
of 3:
|
|
|
|
var buf = newSeq[byte](1)
|
|
|
|
buf[0] = 18
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
s.step = 4
|
|
|
|
fut.complete(buf.len())
|
|
|
|
of 4:
|
|
|
|
var buf = "/test/proto/1.0.0\n"
|
|
|
|
copyMem(pbytes, addr buf[0], buf.len())
|
|
|
|
fut.complete(buf.len())
|
|
|
|
else:
|
2024-06-11 15:18:06 +00:00
|
|
|
copyMem(pbytes, cstring("\0x3na\n"), "\0x3na\n".len())
|
2024-03-05 07:06:27 +00:00
|
|
|
|
|
|
|
fut.complete("\0x3na\n".len())
|
|
|
|
fut
|
|
|
|
|
|
|
|
method write*(
|
2024-06-11 15:18:06 +00:00
|
|
|
s: TestNaStream, msg: seq[byte]
|
|
|
|
): Future[void] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
|
2019-08-30 05:16:55 +00:00
|
|
|
if s.step == 4:
|
2024-03-05 07:06:27 +00:00
|
|
|
return s.na(string.fromBytes(msg))
|
|
|
|
let fut = newFuture[void]()
|
|
|
|
fut.complete()
|
|
|
|
fut
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2024-03-05 07:06:27 +00:00
|
|
|
method close(s: TestNaStream): Future[void] {.async: (raises: [], raw: true).} =
|
2019-12-04 04:44:54 +00:00
|
|
|
s.isClosed = true
|
2020-08-03 05:20:11 +00:00
|
|
|
s.isEof = true
|
2024-03-05 07:06:27 +00:00
|
|
|
let fut = newFuture[void]()
|
|
|
|
fut.complete()
|
|
|
|
fut
|
2019-09-01 17:31:24 +00:00
|
|
|
|
2019-08-30 05:16:55 +00:00
|
|
|
proc newTestNaStream(na: NaHandler): TestNaStream =
|
|
|
|
new result
|
|
|
|
result.na = na
|
|
|
|
result.step = 1
|
|
|
|
|
|
|
|
suite "Multistream select":
|
2020-04-21 01:24:42 +00:00
|
|
|
teardown:
|
2020-09-21 17:48:19 +00:00
|
|
|
checkTrackers()
|
2020-05-06 16:31:47 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
asyncTest "test select custom proto":
|
2021-06-07 07:32:08 +00:00
|
|
|
let ms = MultistreamSelect.new()
|
2020-11-13 03:44:02 +00:00
|
|
|
let conn = newTestSelectStream()
|
|
|
|
check (await ms.select(conn, @["/test/proto/1.0.0"])) == "/test/proto/1.0.0"
|
|
|
|
await conn.close()
|
|
|
|
|
|
|
|
asyncTest "test handle custom proto":
|
2021-06-07 07:32:08 +00:00
|
|
|
let ms = MultistreamSelect.new()
|
2020-11-13 03:44:02 +00:00
|
|
|
let conn = newTestSelectStream()
|
|
|
|
|
|
|
|
var protocol: LPProtocol = new LPProtocol
|
2024-06-11 15:18:06 +00:00
|
|
|
proc testHandler(conn: Connection, proto: string): Future[void] {.async.} =
|
2020-11-13 03:44:02 +00:00
|
|
|
check proto == "/test/proto/1.0.0"
|
2020-04-21 01:24:42 +00:00
|
|
|
await conn.close()
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
protocol.handler = testHandler
|
|
|
|
ms.addHandler("/test/proto/1.0.0", protocol)
|
|
|
|
await ms.handle(conn)
|
2020-05-06 16:31:47 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
asyncTest "test handle `ls`":
|
2021-06-07 07:32:08 +00:00
|
|
|
let ms = MultistreamSelect.new()
|
2020-04-21 01:24:42 +00:00
|
|
|
|
2022-01-05 15:27:33 +00:00
|
|
|
var conn: Connection = nil
|
2020-11-13 03:44:02 +00:00
|
|
|
let done = newFuture[void]()
|
2024-03-05 07:06:27 +00:00
|
|
|
proc testLsHandler(
|
2024-06-11 15:18:06 +00:00
|
|
|
proto: seq[byte]
|
|
|
|
) {.async: (raises: [CancelledError, LPStreamError]).} =
|
2020-11-13 03:44:02 +00:00
|
|
|
var strProto: string = string.fromBytes(proto)
|
|
|
|
check strProto == "\x26/test/proto1/1.0.0\n/test/proto2/1.0.0\n"
|
|
|
|
await conn.close()
|
|
|
|
done.complete()
|
2024-06-11 15:18:06 +00:00
|
|
|
|
2022-01-05 15:27:33 +00:00
|
|
|
conn = Connection(newTestLsStream(testLsHandler))
|
2020-11-13 03:44:02 +00:00
|
|
|
|
2024-06-11 15:18:06 +00:00
|
|
|
proc testHandler(conn: Connection, proto: string): Future[void] {.async.} =
|
|
|
|
discard
|
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
var protocol: LPProtocol = new LPProtocol
|
|
|
|
protocol.handler = testHandler
|
|
|
|
ms.addHandler("/test/proto1/1.0.0", protocol)
|
|
|
|
ms.addHandler("/test/proto2/1.0.0", protocol)
|
|
|
|
await ms.handle(conn)
|
|
|
|
await done.wait(5.seconds)
|
|
|
|
|
|
|
|
asyncTest "test handle `na`":
|
2021-06-07 07:32:08 +00:00
|
|
|
let ms = MultistreamSelect.new()
|
2020-11-13 03:44:02 +00:00
|
|
|
|
2022-01-05 15:27:33 +00:00
|
|
|
var conn: Connection = nil
|
2024-03-05 07:06:27 +00:00
|
|
|
proc testNaHandler(
|
|
|
|
msg: string
|
|
|
|
): Future[void] {.async: (raises: [CancelledError, LPStreamError]).} =
|
2023-03-08 11:30:19 +00:00
|
|
|
check msg == "\x03na\n"
|
2020-11-13 03:44:02 +00:00
|
|
|
await conn.close()
|
2024-06-11 15:18:06 +00:00
|
|
|
|
2022-01-05 15:27:33 +00:00
|
|
|
conn = newTestNaStream(testNaHandler)
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
var protocol: LPProtocol = new LPProtocol
|
2024-06-11 15:18:06 +00:00
|
|
|
proc testHandler(conn: Connection, proto: string): Future[void] {.async.} =
|
|
|
|
discard
|
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
protocol.handler = testHandler
|
|
|
|
ms.addHandler("/unabvailable/proto/1.0.0", protocol)
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
await ms.handle(conn)
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
asyncTest "e2e - handle":
|
2021-12-16 10:05:20 +00:00
|
|
|
let ma = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()]
|
2020-04-21 01:24:42 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
var protocol: LPProtocol = new LPProtocol
|
2024-06-11 15:18:06 +00:00
|
|
|
proc testHandler(conn: Connection, proto: string): Future[void] {.async.} =
|
2020-11-13 03:44:02 +00:00
|
|
|
check proto == "/test/proto/1.0.0"
|
|
|
|
await conn.writeLp("Hello!")
|
|
|
|
await conn.close()
|
2020-04-21 01:24:42 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
protocol.handler = testHandler
|
2021-06-07 07:32:08 +00:00
|
|
|
let msListen = MultistreamSelect.new()
|
2020-11-13 03:44:02 +00:00
|
|
|
msListen.addHandler("/test/proto/1.0.0", protocol)
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2021-06-30 08:59:30 +00:00
|
|
|
let transport1 = TcpTransport.new(upgrade = Upgrade())
|
2021-06-14 23:21:44 +00:00
|
|
|
asyncSpawn transport1.start(ma)
|
2020-11-19 02:06:42 +00:00
|
|
|
|
2023-12-05 07:05:32 +00:00
|
|
|
proc acceptHandler(): Future[void] {.async.} =
|
2020-11-19 02:06:42 +00:00
|
|
|
let conn = await transport1.accept()
|
2020-11-13 03:44:02 +00:00
|
|
|
await msListen.handle(conn)
|
|
|
|
await conn.close()
|
2020-04-21 01:24:42 +00:00
|
|
|
|
2020-11-19 02:06:42 +00:00
|
|
|
let handlerWait = acceptHandler()
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2021-06-07 07:32:08 +00:00
|
|
|
let msDial = MultistreamSelect.new()
|
2021-06-30 08:59:30 +00:00
|
|
|
let transport2 = TcpTransport.new(upgrade = Upgrade())
|
2021-11-24 20:01:12 +00:00
|
|
|
let conn = await transport2.dial(transport1.addrs[0])
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
check (await msDial.select(conn, "/test/proto/1.0.0")) == true
|
2020-04-21 01:24:42 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
let hello = string.fromBytes(await conn.readLp(1024))
|
|
|
|
check hello == "Hello!"
|
|
|
|
await conn.close()
|
2019-08-30 05:16:55 +00:00
|
|
|
|
2020-11-19 02:06:42 +00:00
|
|
|
await transport2.stop()
|
|
|
|
await transport1.stop()
|
2020-04-21 01:24:42 +00:00
|
|
|
|
2020-11-19 02:06:42 +00:00
|
|
|
await handlerWait.wait(30.seconds)
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2022-12-01 11:20:40 +00:00
|
|
|
asyncTest "e2e - streams limit":
|
|
|
|
let ma = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()]
|
|
|
|
let blocker = newFuture[void]()
|
|
|
|
|
|
|
|
# Start 5 streams which are blocked by `blocker`
|
|
|
|
# Try to start a new one, which should fail
|
|
|
|
# Unblock the 5 streams, check that we can open a new one
|
2024-06-11 15:18:06 +00:00
|
|
|
proc testHandler(conn: Connection, proto: string): Future[void] {.async.} =
|
2022-12-01 11:20:40 +00:00
|
|
|
await blocker
|
|
|
|
await conn.writeLp("Hello!")
|
|
|
|
await conn.close()
|
|
|
|
|
2024-06-11 15:18:06 +00:00
|
|
|
var protocol: LPProtocol =
|
|
|
|
LPProtocol.new(@["/test/proto/1.0.0"], testHandler, maxIncomingStreams = 5)
|
2022-12-01 11:20:40 +00:00
|
|
|
|
|
|
|
protocol.handler = testHandler
|
|
|
|
let msListen = MultistreamSelect.new()
|
|
|
|
msListen.addHandler("/test/proto/1.0.0", protocol)
|
|
|
|
|
|
|
|
let transport1 = TcpTransport.new(upgrade = Upgrade())
|
|
|
|
await transport1.start(ma)
|
|
|
|
|
|
|
|
proc acceptedOne(c: Connection) {.async.} =
|
|
|
|
await msListen.handle(c)
|
|
|
|
await c.close()
|
|
|
|
|
2023-12-05 07:05:32 +00:00
|
|
|
proc acceptHandler() {.async.} =
|
2022-12-01 11:20:40 +00:00
|
|
|
while true:
|
|
|
|
let conn = await transport1.accept()
|
|
|
|
asyncSpawn acceptedOne(conn)
|
|
|
|
|
|
|
|
var handlerWait = acceptHandler()
|
|
|
|
|
|
|
|
let msDial = MultistreamSelect.new()
|
|
|
|
let transport2 = TcpTransport.new(upgrade = Upgrade())
|
|
|
|
|
2024-06-11 15:18:06 +00:00
|
|
|
proc connector() {.async.} =
|
2022-12-01 11:20:40 +00:00
|
|
|
let conn = await transport2.dial(transport1.addrs[0])
|
2024-06-11 15:18:06 +00:00
|
|
|
check:
|
|
|
|
(await msDial.select(conn, "/test/proto/1.0.0")) == true
|
|
|
|
check:
|
|
|
|
string.fromBytes(await conn.readLp(1024)) == "Hello!"
|
2022-12-01 11:20:40 +00:00
|
|
|
await conn.close()
|
|
|
|
|
|
|
|
# Fill up the 5 allowed streams
|
|
|
|
var dialers: seq[Future[void]]
|
2024-06-11 15:18:06 +00:00
|
|
|
for _ in 0 ..< 5:
|
2022-12-01 11:20:40 +00:00
|
|
|
dialers.add(connector())
|
|
|
|
|
|
|
|
# This one will fail during negotiation
|
|
|
|
expect(CatchableError):
|
2024-06-11 15:18:06 +00:00
|
|
|
try:
|
|
|
|
waitFor(connector().wait(1.seconds))
|
2022-12-01 11:20:40 +00:00
|
|
|
except AsyncTimeoutError as exc:
|
|
|
|
check false
|
|
|
|
raise exc
|
|
|
|
# check that the dialers aren't finished
|
2024-06-11 15:18:06 +00:00
|
|
|
check:
|
|
|
|
(await dialers[0].withTimeout(10.milliseconds)) == false
|
2022-12-01 11:20:40 +00:00
|
|
|
|
|
|
|
# unblock the dialers
|
|
|
|
blocker.complete()
|
|
|
|
await allFutures(dialers)
|
|
|
|
|
|
|
|
# now must work
|
|
|
|
waitFor(connector())
|
|
|
|
|
|
|
|
await transport2.stop()
|
|
|
|
await transport1.stop()
|
|
|
|
|
|
|
|
await handlerWait.cancelAndWait()
|
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
asyncTest "e2e - ls":
|
2021-12-16 10:05:20 +00:00
|
|
|
let ma = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()]
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2021-06-07 07:32:08 +00:00
|
|
|
let msListen = MultistreamSelect.new()
|
2020-11-13 03:44:02 +00:00
|
|
|
var protocol: LPProtocol = new LPProtocol
|
2023-12-05 07:05:32 +00:00
|
|
|
protocol.handler = proc(conn: Connection, proto: string) {.async.} =
|
2020-11-13 03:44:02 +00:00
|
|
|
# never reached
|
|
|
|
discard
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2024-06-11 15:18:06 +00:00
|
|
|
proc testHandler(conn: Connection, proto: string): Future[void] {.async.} =
|
2020-11-13 03:44:02 +00:00
|
|
|
# never reached
|
|
|
|
discard
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
protocol.handler = testHandler
|
|
|
|
msListen.addHandler("/test/proto1/1.0.0", protocol)
|
|
|
|
msListen.addHandler("/test/proto2/1.0.0", protocol)
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2021-06-30 08:59:30 +00:00
|
|
|
let transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade())
|
2020-11-19 02:06:42 +00:00
|
|
|
let listenFut = transport1.start(ma)
|
|
|
|
|
2023-12-05 07:05:32 +00:00
|
|
|
proc acceptHandler(): Future[void] {.async.} =
|
2020-11-19 02:06:42 +00:00
|
|
|
let conn = await transport1.accept()
|
|
|
|
try:
|
|
|
|
await msListen.handle(conn)
|
|
|
|
except LPStreamEOFError:
|
|
|
|
discard
|
|
|
|
except LPStreamClosedError:
|
|
|
|
discard
|
|
|
|
finally:
|
|
|
|
await conn.close()
|
|
|
|
|
|
|
|
let acceptFut = acceptHandler()
|
2021-06-07 07:32:08 +00:00
|
|
|
let msDial = MultistreamSelect.new()
|
2021-06-30 08:59:30 +00:00
|
|
|
let transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade())
|
2021-11-24 20:01:12 +00:00
|
|
|
let conn = await transport2.dial(transport1.addrs[0])
|
2020-11-13 03:44:02 +00:00
|
|
|
|
|
|
|
let ls = await msDial.list(conn)
|
|
|
|
let protos: seq[string] = @["/test/proto1/1.0.0", "/test/proto2/1.0.0"]
|
|
|
|
|
|
|
|
check ls == protos
|
|
|
|
|
|
|
|
await conn.close()
|
2020-11-19 02:06:42 +00:00
|
|
|
await acceptFut
|
|
|
|
await transport2.stop()
|
|
|
|
await transport1.stop()
|
|
|
|
await listenFut.wait(5.seconds)
|
2020-11-13 03:44:02 +00:00
|
|
|
|
|
|
|
asyncTest "e2e - select one from a list with unsupported protos":
|
2021-12-16 10:05:20 +00:00
|
|
|
let ma = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()]
|
2020-11-19 02:06:42 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
var protocol: LPProtocol = new LPProtocol
|
2024-06-11 15:18:06 +00:00
|
|
|
proc testHandler(conn: Connection, proto: string): Future[void] {.async.} =
|
2020-11-13 03:44:02 +00:00
|
|
|
check proto == "/test/proto/1.0.0"
|
|
|
|
await conn.writeLp("Hello!")
|
|
|
|
await conn.close()
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
protocol.handler = testHandler
|
2021-06-07 07:32:08 +00:00
|
|
|
let msListen = MultistreamSelect.new()
|
2020-11-13 03:44:02 +00:00
|
|
|
msListen.addHandler("/test/proto/1.0.0", protocol)
|
2020-04-21 01:24:42 +00:00
|
|
|
|
2021-06-30 08:59:30 +00:00
|
|
|
let transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade())
|
2021-06-14 23:21:44 +00:00
|
|
|
asyncSpawn transport1.start(ma)
|
2020-11-19 02:06:42 +00:00
|
|
|
|
2023-12-05 07:05:32 +00:00
|
|
|
proc acceptHandler(): Future[void] {.async.} =
|
2020-11-19 02:06:42 +00:00
|
|
|
let conn = await transport1.accept()
|
|
|
|
await msListen.handle(conn)
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2020-11-19 02:06:42 +00:00
|
|
|
let acceptFut = acceptHandler()
|
2021-06-07 07:32:08 +00:00
|
|
|
let msDial = MultistreamSelect.new()
|
2021-06-30 08:59:30 +00:00
|
|
|
let transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade())
|
2021-11-24 20:01:12 +00:00
|
|
|
let conn = await transport2.dial(transport1.addrs[0])
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2024-06-11 15:18:06 +00:00
|
|
|
check (await msDial.select(conn, @["/test/proto/1.0.0", "/test/no/proto/1.0.0"])) ==
|
|
|
|
"/test/proto/1.0.0"
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
let hello = string.fromBytes(await conn.readLp(1024))
|
|
|
|
check hello == "Hello!"
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
await conn.close()
|
2020-11-19 02:06:42 +00:00
|
|
|
await acceptFut
|
|
|
|
await transport2.stop()
|
|
|
|
await transport1.stop()
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
asyncTest "e2e - select one with both valid":
|
2021-12-16 10:05:20 +00:00
|
|
|
let ma = @[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()]
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
var protocol: LPProtocol = new LPProtocol
|
2024-06-11 15:18:06 +00:00
|
|
|
proc testHandler(conn: Connection, proto: string): Future[void] {.async.} =
|
2020-11-13 03:44:02 +00:00
|
|
|
await conn.writeLp(&"Hello from {proto}!")
|
|
|
|
await conn.close()
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
protocol.handler = testHandler
|
2021-06-07 07:32:08 +00:00
|
|
|
let msListen = MultistreamSelect.new()
|
2020-11-13 03:44:02 +00:00
|
|
|
msListen.addHandler("/test/proto1/1.0.0", protocol)
|
|
|
|
msListen.addHandler("/test/proto2/1.0.0", protocol)
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2021-06-30 08:59:30 +00:00
|
|
|
let transport1: TcpTransport = TcpTransport.new(upgrade = Upgrade())
|
2021-06-14 23:21:44 +00:00
|
|
|
asyncSpawn transport1.start(ma)
|
2020-04-21 01:24:42 +00:00
|
|
|
|
2023-12-05 07:05:32 +00:00
|
|
|
proc acceptHandler(): Future[void] {.async.} =
|
2020-11-19 02:06:42 +00:00
|
|
|
let conn = await transport1.accept()
|
|
|
|
await msListen.handle(conn)
|
|
|
|
|
|
|
|
let acceptFut = acceptHandler()
|
2021-06-07 07:32:08 +00:00
|
|
|
let msDial = MultistreamSelect.new()
|
2021-06-30 08:59:30 +00:00
|
|
|
let transport2: TcpTransport = TcpTransport.new(upgrade = Upgrade())
|
2021-11-24 20:01:12 +00:00
|
|
|
let conn = await transport2.dial(transport1.addrs[0])
|
2020-11-13 03:44:02 +00:00
|
|
|
|
2024-06-11 15:18:06 +00:00
|
|
|
check (await msDial.select(conn, @["/test/proto2/1.0.0", "/test/proto1/1.0.0"])) ==
|
|
|
|
"/test/proto2/1.0.0"
|
2020-11-19 02:06:42 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
check string.fromBytes(await conn.readLp(1024)) == "Hello from /test/proto2/1.0.0!"
|
2019-09-04 18:31:13 +00:00
|
|
|
|
2020-11-13 03:44:02 +00:00
|
|
|
await conn.close()
|
2020-11-19 02:06:42 +00:00
|
|
|
await acceptFut
|
|
|
|
await transport2.stop()
|
|
|
|
await transport1.stop()
|