Struct Connection 

pub struct Connection<PK>
where
    PK: PublicKey,
{ /* private fields */ }

A bidirectional, encrypted and authenticated connection with a peer

the connection can be conveniently split into its halves (ConnectionWriter and ConnectionReader) for more convenient handling of that the protocol may be available to write data and receive data at different time.

Implementations

impl<PK> Connection<PK>

where PK: PublicKey + Debug + Display,

pub fn remote_public_identity(&self) -> &PK

retrieve the public identity of the peer

pub fn remote_address(&self) -> SocketAddr

the remote address we are sending/receiving messages to/from

beware that this may not reflect the peer’s actual address as they may be behind routers. Also this is not the same as the address that may be advertised by the peer in the gossip as they might use a different port number or a different routes for inbounds or outbound connections depending on their IT configuration.

pub fn session_id(&self) -> &SessionId

retrieve the unique identifier of the established session

this is derived from the NOISE handshake and is the same on both sides of the stream (here and for the remote).

pub async fn connect_to<RNG, K>( rng: RNG, k: &K, peer_addr: SocketAddr, rs: K::Public, ) -> Result<Self>

where RNG: CryptoRng + RngCore, K: Dh<Public = PK>,

connect to the given socket address, expecting the remote to identify with the PublicKey rs.

The function will use the given RNG to generate an ephemeral private keys that will be used only for this connection and the given key k to authenticate ourself to the remote.

pub async fn connect<RNG, K, A>( rng: RNG, k: &K, peer_addr: A, rs: K::Public, ) -> Result<Self>

where RNG: RngCore + CryptoRng, A: ToSocketAddrs + Display + Debug, K: Dh<Public = PK>,

attempt to connect to any resolved lookup_host result of the given ToSocketAddrs.

The function will returns at the first successful attempt or once all the possible options have been tried and failed.

pub fn into_parts(self) -> (ConnectionReader<PK>, ConnectionWriter<PK>)

split the connections into 2 parts

this allows to have 2 different independent objects to read or write to/from the remote peer.

Trait Implementations

impl<PK> Debug for Connection<PK>

where PK: PublicKey + Debug + Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<PK> FusedStream for Connection<PK>

where PK: PublicKey,

fn is_terminated(&self) -> bool

Returns true if the stream should no longer be polled.

impl<PK> Sink<Bytes> for Connection<PK>

where PK: PublicKey,

type Error = Error

The type of value produced by the sink when an error occurs.

fn start_send(self: Pin<&mut Self>, item: Bytes) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

impl<PK> Stream for Connection<PK>

where PK: PublicKey,

type Item = Result<Bytes, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.