Struct IrohPlugin 

pub struct IrohPlugin {
    pub identity: Identity,
    pub relays: Relays,
    pub display_name: String,
    pub heartbeat: Duration,
    pub replicate_transform: bool,
    pub autostart: bool,
    /* private fields */
}

The plugin. IrohPlugin::default() is an ephemeral identity on n0’s relays.

Fields

identity: Identity

relays: Relays

display_name: String

What peers see of you in Peer::name.

heartbeat: Duration

How often presence is announced; silence for three of these reaps a peer.

replicate_transform: bool

Replicate Transform at 20 Hz with smoothing. Off, register your own transform codec.

autostart: bool

Start the node as soon as the plugin is added. Off, the plugin only registers its systems and nothing touches the network until StartIroh is queued: an app that connects only when its user asks.

Implementations

impl IrohPlugin

pub fn with_identity(self, identity: Identity) -> Self

pub fn with_relays(self, relays: Relays) -> Self

pub fn with_display_name(self, name: impl Into<String>) -> Self

pub fn with_autostart(self, autostart: bool) -> Self

pub fn with_protocol( self, alpn: impl AsRef<[u8]>, handler: impl Into<Box<dyn DynProtocolHandler>>, ) -> Self

Accept connections on another ALPN, on the same endpoint. How media, or anything else that is a stream rather than a message, rides along.

The handler serves the first node only: a node started again after StopIroh goes without it. IrohPlugin::with_protocol_factory serves every one.

pub fn with_protocol_factory( self, alpn: impl AsRef<[u8]>, make: impl Fn() -> Box<dyn DynProtocolHandler> + Send + Sync + 'static, ) -> Self

IrohPlugin::with_protocol with a fresh handler for each node, so the protocol survives stopping and starting again.

Trait Implementations

impl Default for IrohPlugin

fn default() -> Self

Returns the “default value” for a type.

impl Plugin for IrohPlugin

fn build(&self, app: &mut App)

Configures the App to which this plugin is added.

fn ready(&self, _app: &App) -> bool

Has the plugin finished its setup? This can be useful for plugins that need something asynchronous to happen before they can finish their setup, like the initialization of a renderer. Once the plugin is ready, finish should be called.

fn finish(&self, _app: &mut App)

Finish adding this plugin to the App, once all plugins registered are ready. This can be useful for plugins that depends on another plugin asynchronous setup, like the renderer.

fn cleanup(&self, _app: &mut App)

Runs after all plugins are built and finished, but before the app schedule is executed. This can be useful if you have some resource that other plugins need during their build step, but after build you want to remove it and send it to another thread.

fn name(&self) -> &str

Configures a name for the Plugin which is primarily used for checking plugin uniqueness and debugging.

fn is_unique(&self) -> bool

If the plugin can be meaningfully instantiated several times in an App, override this method to return false.