mirror of
https://github.com/vacp2p/nim-libp2p.git
synced 2026-01-09 14:28:11 -05:00
95 lines
3.0 KiB
Nim
95 lines
3.0 KiB
Nim
# 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.
|
|
|
|
{.push raises: [].}
|
|
|
|
import chronos
|
|
import results
|
|
import peerid, stream/connection, transports/transport, muxers/muxer
|
|
|
|
export results
|
|
|
|
type
|
|
Dial* = ref object of RootObj
|
|
DialFailedError* = object of LPError
|
|
|
|
method connect*(
|
|
self: Dial,
|
|
peerId: PeerId,
|
|
addrs: seq[MultiAddress],
|
|
forceDial = false,
|
|
reuseConnection = true,
|
|
dir = Direction.Out,
|
|
) {.base, async: (raises: [DialFailedError, CancelledError]).} =
|
|
## connect remote peer without negotiating
|
|
## a protocol
|
|
##
|
|
|
|
doAssert(false, "[Dial.connect] abstract method not implemented!")
|
|
|
|
method connect*(
|
|
self: Dial, address: MultiAddress, allowUnknownPeerId = false
|
|
): Future[PeerId] {.base, async: (raises: [DialFailedError, CancelledError]).} =
|
|
## Connects to a peer and retrieve its PeerId
|
|
|
|
doAssert(false, "[Dial.connect] abstract method not implemented!")
|
|
|
|
method dial*(
|
|
self: Dial, peerId: PeerId, protos: seq[string]
|
|
): Future[Connection] {.base, async: (raises: [DialFailedError, CancelledError]).} =
|
|
## create a protocol stream over an
|
|
## existing connection
|
|
##
|
|
|
|
doAssert(false, "[Dial.dial] abstract method not implemented!")
|
|
|
|
method dialAndUpgrade*(
|
|
self: Dial,
|
|
peerId: Opt[PeerId],
|
|
hostname: string,
|
|
addrs: MultiAddress,
|
|
dir = Direction.Out,
|
|
): Future[Muxer] {.base, async: (raises: [CancelledError]).} =
|
|
doAssert(false, "[Dial.dialAndUpgrade] abstract method not implemented!")
|
|
|
|
method dialAndUpgrade*(
|
|
self: Dial, peerId: Opt[PeerId], addrs: seq[MultiAddress], dir = Direction.Out
|
|
): Future[Muxer] {.
|
|
base, async: (raises: [CancelledError, MaError, TransportAddressError, LPError])
|
|
.} =
|
|
doAssert(false, "[Dial.dialAndUpgrade] abstract method not implemented!")
|
|
|
|
method dial*(
|
|
self: Dial,
|
|
peerId: PeerId,
|
|
addrs: seq[MultiAddress],
|
|
protos: seq[string],
|
|
forceDial = false,
|
|
): Future[Connection] {.base, async: (raises: [DialFailedError, CancelledError]).} =
|
|
## create a protocol stream and establish
|
|
## a connection if one doesn't exist already
|
|
##
|
|
|
|
doAssert(false, "[Dial.dial] abstract method not implemented!")
|
|
|
|
method addTransport*(self: Dial, transport: Transport) {.base.} =
|
|
doAssert(false, "[Dial.addTransport] abstract method not implemented!")
|
|
|
|
method negotiateStream*(
|
|
self: Dial, conn: Connection, protos: seq[string]
|
|
): Future[Connection] {.base, async: (raises: [CatchableError]).} =
|
|
doAssert(false, "[Dial.negotiateStream] abstract method not implemented!")
|
|
|
|
method tryDial*(
|
|
self: Dial, peerId: PeerId, addrs: seq[MultiAddress]
|
|
): Future[Opt[MultiAddress]] {.
|
|
base, async: (raises: [DialFailedError, CancelledError])
|
|
.} =
|
|
doAssert(false, "[Dial.tryDial] abstract method not implemented!")
|