Trait ckb_network::CKBProtocolContext

source · 
pub trait CKBProtocolContext: Send {

Show 25 methods    fn set_notify<'life0, 'async_trait>(
        &'life0 self,
        interval: Duration,
        token: u64
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait;
    fn remove_notify<'life0, 'async_trait>(
        &'life0 self,
        token: u64
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait;
    fn async_quick_send_message<'life0, 'async_trait>(
        &'life0 self,
        proto_id: ProtocolId,
        peer_index: PeerIndex,
        data: Bytes
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait;
    fn async_quick_send_message_to<'life0, 'async_trait>(
        &'life0 self,
        peer_index: PeerIndex,
        data: Bytes
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait;
    fn async_quick_filter_broadcast<'life0, 'async_trait>(
        &'life0 self,
        target: TargetSession,
        data: Bytes
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait;
    fn async_future_task<'life0, 'async_trait>(
        &'life0 self,
        task: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
        blocking: bool
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait;
    fn async_send_message<'life0, 'async_trait>(
        &'life0 self,
        proto_id: ProtocolId,
        peer_index: PeerIndex,
        data: Bytes
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait;
    fn async_send_message_to<'life0, 'async_trait>(
        &'life0 self,
        peer_index: PeerIndex,
        data: Bytes
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait;
    fn async_filter_broadcast<'life0, 'async_trait>(
        &'life0 self,
        target: TargetSession,
        data: Bytes
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait;
    fn async_disconnect<'life0, 'life1, 'async_trait>(
        &'life0 self,
        peer_index: PeerIndex,
        message: &'life1 str
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait;
    fn quick_send_message(
        &self,
        proto_id: ProtocolId,
        peer_index: PeerIndex,
        data: Bytes
    ) -> Result<(), Error>;
    fn quick_send_message_to(
        &self,
        peer_index: PeerIndex,
        data: Bytes
    ) -> Result<(), Error>;
    fn quick_filter_broadcast(
        &self,
        target: TargetSession,
        data: Bytes
    ) -> Result<(), Error>;
    fn future_task(
        &self,
        task: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
        blocking: bool
    ) -> Result<(), Error>;
    fn send_message(
        &self,
        proto_id: ProtocolId,
        peer_index: PeerIndex,
        data: Bytes
    ) -> Result<(), Error>;
    fn send_message_to(
        &self,
        peer_index: PeerIndex,
        data: Bytes
    ) -> Result<(), Error>;
    fn filter_broadcast(
        &self,
        target: TargetSession,
        data: Bytes
    ) -> Result<(), Error>;
    fn disconnect(
        &self,
        peer_index: PeerIndex,
        message: &str
    ) -> Result<(), Error>;
    fn get_peer(&self, peer_index: PeerIndex) -> Option<Peer>;
    fn with_peer_mut(&self, peer_index: PeerIndex, f: Box<dyn FnOnce(&mut Peer)>);
    fn connected_peers(&self) -> Vec<PeerIndex> ⓘ;
    fn report_peer(&self, peer_index: PeerIndex, behaviour: Behaviour);
    fn ban_peer(&self, peer_index: PeerIndex, duration: Duration, reason: String);
    fn protocol_id(&self) -> ProtocolId;

    fn p2p_control(&self) -> Option<&ServiceControl> { ... }

}
Expand description

Abstract protocol context

Required Methods§

source

fn set_notify<'life0, 'async_trait>(
    &'life0 self,
    interval: Duration,
    token: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Set notify to tentacle

source

fn remove_notify<'life0, 'async_trait>(
    &'life0 self,
    token: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Remove notify

source

fn async_quick_send_message<'life0, 'async_trait>(
    &'life0 self,
    proto_id: ProtocolId,
    peer_index: PeerIndex,
    data: Bytes
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Send message through quick queue

source

fn async_quick_send_message_to<'life0, 'async_trait>(
    &'life0 self,
    peer_index: PeerIndex,
    data: Bytes
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Send message through quick queue

source

fn async_quick_filter_broadcast<'life0, 'async_trait>(
    &'life0 self,
    target: TargetSession,
    data: Bytes
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Filter broadcast message through quick queue

source

fn async_future_task<'life0, 'async_trait>(
    &'life0 self,
    task: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
    blocking: bool
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

spawn a future task, if blocking is true we use tokio_threadpool::blocking to handle the task.

source

fn async_send_message<'life0, 'async_trait>(
    &'life0 self,
    proto_id: ProtocolId,
    peer_index: PeerIndex,
    data: Bytes
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Send message

source

fn async_send_message_to<'life0, 'async_trait>(
    &'life0 self,
    peer_index: PeerIndex,
    data: Bytes
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Send message

source

fn async_filter_broadcast<'life0, 'async_trait>(
    &'life0 self,
    target: TargetSession,
    data: Bytes
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Filter broadcast message

source

fn async_disconnect<'life0, 'life1, 'async_trait>(
    &'life0 self,
    peer_index: PeerIndex,
    message: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Disconnect session

source

fn quick_send_message(
    &self,
    proto_id: ProtocolId,
    peer_index: PeerIndex,
    data: Bytes
) -> Result<(), Error>

Send message through quick queue

source

fn quick_send_message_to(
    &self,
    peer_index: PeerIndex,
    data: Bytes
) -> Result<(), Error>

Send message through quick queue

source

fn quick_filter_broadcast(
    &self,
    target: TargetSession,
    data: Bytes
) -> Result<(), Error>

Filter broadcast message through quick queue

source

fn future_task(
    &self,
    task: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
    blocking: bool
) -> Result<(), Error>

spawn a future task, if blocking is true we use tokio_threadpool::blocking to handle the task.

source

fn send_message(
    &self,
    proto_id: ProtocolId,
    peer_index: PeerIndex,
    data: Bytes
) -> Result<(), Error>

Send message

source

fn send_message_to(&self, peer_index: PeerIndex, data: Bytes) -> Result<(), Error>

Send message

source

fn filter_broadcast(
    &self,
    target: TargetSession,
    data: Bytes
) -> Result<(), Error>

Filter broadcast message

source

fn disconnect(&self, peer_index: PeerIndex, message: &str) -> Result<(), Error>

Disconnect session

source

fn get_peer(&self, peer_index: PeerIndex) -> Option<Peer>

Get peer info

source

fn with_peer_mut(&self, peer_index: PeerIndex, f: Box<dyn FnOnce(&mut Peer)>)

Modify peer info

source

fn connected_peers(&self) -> Vec<PeerIndex> ⓘ

Get all session id

source

fn report_peer(&self, peer_index: PeerIndex, behaviour: Behaviour)

Report peer behavior

source

fn ban_peer(&self, peer_index: PeerIndex, duration: Duration, reason: String)

Ban peer

source

fn protocol_id(&self) -> ProtocolId

current protocol id

Provided Methods§

source

fn p2p_control(&self) -> Option<&ServiceControl>

Raw tentacle controller

Implementors§