Struct libp2p_swarm::SwarmBuilder

pub struct SwarmBuilder<TBehaviour, TConnInfo> { /* fields omitted */ }

A SwarmBuilder provides an API for configuring and constructing a Swarm, including the underlying Network.

Implementations

impl<TBehaviour, TConnInfo> SwarmBuilder<TBehaviour, TConnInfo> where
    TBehaviour: NetworkBehaviour,
    TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static, 

pub fn new<TTrans, TMuxer>(
    transport: TTrans,
    behaviour: TBehaviour,
    local_peer_id: PeerId
) -> Self where
    TMuxer: StreamMuxer + Send + Sync + 'static,
    TMuxer::OutboundSubstream: Send + 'static,
    <TMuxer as StreamMuxer>::OutboundSubstream: Send + 'static,
    <TMuxer as StreamMuxer>::Substream: Send + 'static,
    TTrans: Transport<Output = (TConnInfo, TMuxer)> + Clone + Send + Sync + 'static,
    TTrans::Error: Send + Sync + 'static,
    TTrans::Listener: Send + 'static,
    TTrans::ListenerUpgrade: Send + 'static,
    TTrans::Dial: Send + 'static, 

Creates a new SwarmBuilder from the given transport, behaviour and local peer ID. The Swarm with its underlying Network is obtained via SwarmBuilder::build.

pub fn executor(self, e: Box<dyn Executor + Send>) -> Self

Configures the Executor to use for spawning background tasks.

By default, unless another executor has been configured, SwarmBuilder::build will try to set up a ThreadPool.

pub fn notify_handler_buffer_size(self, n: NonZeroUsize) -> Self

Configures the number of events from the NetworkBehaviour in destination to the ProtocolsHandler that can be buffered before the Swarm has to wait. An individual buffer with this number of events exists for each individual connection.

The ideal value depends on the executor used, the CPU speed, and the volume of events. If this value is too low, then the Swarm will be sleeping more often than necessary. Increasing this value increases the overall memory usage.

pub fn connection_event_buffer_size(self, n: usize) -> Self

Configures the number of extra events from the ProtocolsHandler in destination to the NetworkBehaviour that can be buffered before the ProtocolsHandler has to go to sleep.

There exists a buffer of events received from ProtocolsHandlers that the NetworkBehaviour has yet to process. This buffer is shared between all instances of ProtocolsHandler. Each instance of ProtocolsHandler is guaranteed one slot in this buffer, meaning that delivering an event for the first time is guaranteed to be instantaneous. Any extra event delivery, however, must wait for that first event to be delivered or for an "extra slot" to be available.

This option configures the number of such "extra slots" in this shared buffer. These extra slots are assigned in a first-come, first-served basis.

The ideal value depends on the executor used, the CPU speed, the average number of connections, and the volume of events. If this value is too low, then the ProtocolsHandlers will be sleeping more often than necessary. Increasing this value increases the overall memory usage, and more importantly the latency between the moment when an event is emitted and the moment when it is received by the NetworkBehaviour.

pub fn incoming_connection_limit(self, n: usize) -> Self

Configures a limit for the number of simultaneous incoming connection attempts.

pub fn outgoing_connection_limit(self, n: usize) -> Self

Configures a limit for the number of simultaneous outgoing connection attempts.

pub fn peer_connection_limit(self, n: usize) -> Self

Configures a limit for the number of simultaneous established connections per peer.

pub fn build(self) -> Swarm<TBehaviour, TConnInfo>

Builds a Swarm with the current configuration.