Struct darkfi::net::channel::Channel

pub struct Channel {
    reader: Mutex<ReadHalf<Box<dyn PtStream>>>,
    writer: Mutex<WriteHalf<Box<dyn PtStream>>>,
    message_subsystem: MessageSubsystem,
    stop_publisher: PublisherPtr<Error>,
    receive_task: StoppableTaskPtr,
    stopped: AtomicBool,
    pub(super) session: SessionWeakPtr,
    version: Mutex<Option<Arc<VersionMessage>>>,
    pub info: ChannelInfo,
}

Async channel for communication between nodes.

Fields

reader: Mutex<ReadHalf<Box<dyn PtStream>>>

The reading half of the transport stream

writer: Mutex<WriteHalf<Box<dyn PtStream>>>

The writing half of the transport stream

message_subsystem: MessageSubsystem

The message subsystem instance for this channel

stop_publisher: PublisherPtr<Error>

Publisher listening for stop signal for closing this channel

receive_task: StoppableTaskPtr

Task that is listening for the stop signal

stopped: AtomicBool

A boolean marking if this channel is stopped

session: SessionWeakPtr

Weak pointer to respective session

version: Mutex<Option<Arc<VersionMessage>>>

The version message of the node we are connected to. Some if the version exchange has already occurred, None otherwise.

info: ChannelInfo

Channel debug info

Implementations

impl Channel

pub async fn new( stream: Box<dyn PtStream>, resolve_addr: Option<Url>, connect_addr: Url, session: SessionWeakPtr, ) -> Arc<Self>

Sets up a new channel. Creates a reader and writer PtStream and the message publisher subsystem. Performs a network handshake on the subsystem dispatchers.

async fn setup_dispatchers(subsystem: &MessageSubsystem)

Perform network handshake for message subsystem dispatchers.

pub fn start(self: Arc<Self>, executor: Arc<Executor<'_>>)

Starts the channel. Runs a receive loop to start receiving messages or handles a network failure.

pub async fn stop(&self)

Stops the channel. Notifies all publishers that the channel has been closed in handle_stop().

pub async fn subscribe_stop(&self) -> Result<Subscription<Error>>

Creates a subscription to a stopped signal. If the channel is stopped then this will return a ChannelStopped error.

pub fn is_stopped(&self) -> bool

pub async fn send<M: Message>(&self, message: &M) -> Result<()>

Sends a message across a channel. First it converts the message into a SerializedMessage and then calls send_serialized to send it. Returns an error if something goes wrong.

pub async fn send_serialized(&self, message: &SerializedMessage) -> Result<()>

Sends the encoded payload of provided SerializedMessage across the channel. Calls send_message that creates a new payload and sends it over the network transport as a packet. Returns an error if something goes wrong.

async fn send_message(&self, message: &SerializedMessage) -> Result<()>

Sends the encoded payload of provided SerializedMessage by writing the data to the channel async stream.

pub async fn read_command<R: AsyncRead + Unpin + Send + Sized>( &self, stream: &mut R, ) -> Result<String>

Returns a decoded Message command. We start by extracting the length from the stream, then allocate the precise buffer for this length using stream.take(). This manual deserialization provides a basic DDOS protection, since it prevents nodes from sending an arbitarily large payload.

pub async fn subscribe_msg<M: Message>(&self) -> Result<MessageSubscription<M>>

Subscribe to a message on the message subsystem.

async fn handle_stop(self: Arc<Self>, result: Result<()>)

Handle network errors. Panic if error passes silently, otherwise broadcast the error.

async fn main_receive_loop(self: Arc<Self>) -> Result<()>

Run the receive loop. Start receiving messages or handle network failure.

pub async fn ban(&self, peer: &Url)

Ban a malicious peer and stop the channel.

pub fn address(&self) -> &Url

Returns the relevant socket address for this connection. If this is an outbound connection, the transport-processed resolve_addr will be returned. Otherwise for inbound connections it will default to connect_addr.

pub fn resolve_addr(&self) -> Option<Url>

Returns the socket address that has undergone transport processing, if it exists. Returns None otherwise.

pub fn connect_addr(&self) -> &Url

Return the socket address without transport processing.

pub(crate) async fn set_version(&self, version: Arc<VersionMessage>)

Set the VersionMessage of the node this channel is connected to. Called on receiving a version message in ProtocolVersion.

pub fn message_subsystem(&self) -> &MessageSubsystem

Returns the inner MessageSubsystem reference

fn session(&self) -> Arc<dyn Session>

pub fn session_type_id(&self) -> SessionBitFlag

fn p2p(&self) -> P2pPtr

fn is_eof_error(err: &Error) -> bool

Trait Implementations

impl Debug for Channel

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

Formats the value using the given formatter.