Struct NetworkBuilder

pub struct NetworkBuilder<T, I>(/* private fields */);

Convenient network layer builder

Implementations

impl NetworkBuilder<HNil, (Here, Here)>

pub fn with_adnl<T>( addr: T, keystore: Keystore, options: NodeOptions, ) -> NetworkBuilder<HCons<Result<Arc<Node>>, HNil>, (Here, Here)>

where T: ToSocketAddrs,

Creates a basic network layer that is an ADNL node

See with_adnl_ext if you need a node with a peer filter

Examples

#[tokio::main]
async fn main() -> Result<()> {
    let keystore = adnl::Keystore::builder()
        .with_tagged_key([0; 32], 0)?
        .build();

    let options = adnl::NodeOptions::default();

    let adnl = NetworkBuilder::with_adnl("127.0.0.1:10000", keystore, options).build()?;

    Ok(())
}

pub fn with_adnl_ext<T>( addr: T, keystore: Keystore, options: NodeOptions, peer_filter: Arc<dyn PeerFilter>, ) -> NetworkBuilder<HCons<Result<Arc<Node>>, HNil>, (Here, Here)>

where T: ToSocketAddrs,

Creates a basic network layer that is an ADNL node with additional filter

Examples

struct MyFilter;

impl adnl::PeerFilter for MyFilter {
    fn check(
        &self,
        ctx: adnl::NewPeerContext,
        addr: SocketAddrV4,
        peer_id: &adnl::NodeIdShort,
    ) -> bool {
        // Allow only non-loopback IPs
        !addr.ip().is_loopback()
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let keystore = adnl::Keystore::builder()
        .with_tagged_key([0; 32], 0)?
        .build();

    let options = adnl::NodeOptions::default();

    let peer_filter = Arc::new(MyFilter);

    let adnl = NetworkBuilder::with_adnl_ext("127.0.0.1:10000", keystore, options, peer_filter)
        .build()?;

    Ok(())
}

impl<L, A, R> NetworkBuilder<L, (A, R)>

where L: HList + Selector<Result<Arc<Node>>, A>,

pub fn with_query_subscriber(self, subscriber: Arc<dyn QuerySubscriber>) -> Self

Adds query subscriber if ADNL was successfully initialized.

Examples

struct Service;

#[async_trait::async_trait]
impl QuerySubscriber for Service {
    async fn try_consume_query<'a>(
        &self,
        _ctx: SubscriberContext<'a>,
        _constructor: u32,
        _query: Cow<'a, [u8]>,
    ) -> Result<QueryConsumingResult<'a>> {
        Ok(QueryConsumingResult::Consumed(None))
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let keystore = adnl::Keystore::builder()
        .with_tagged_key([0; 32], 0)?
        .build();

    let options = adnl::NodeOptions::default();

    let adnl = NetworkBuilder::with_adnl("127.0.0.1:10000", keystore, options)
        .with_query_subscriber(Arc::new(Service))
        .build()?;

    Ok(())
}

pub fn with_message_subscriber( self, subscriber: Arc<dyn MessageSubscriber>, ) -> Self

Adds custom message subscriber if ADNL was successfully initialized.

Examples

struct Service;

#[async_trait::async_trait]
impl MessageSubscriber for Service {
    async fn try_consume_custom<'a>(
        &self,
        _ctx: SubscriberContext<'a>,
        _constructor: u32,
        _data: &'a [u8],
    ) -> Result<bool> {
        Ok(true)
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let keystore = adnl::Keystore::builder()
        .with_tagged_key([0; 32], 0)?
        .build();

    let options = adnl::NodeOptions::default();

    let adnl = NetworkBuilder::with_adnl("127.0.0.1:10000", keystore, options)
        .with_message_subscriber(Arc::new(Service))
        .build()?;

    Ok(())
}

impl<L, A, R> NetworkBuilder<L, (A, R)>

where L: HList + Selector<Result<Arc<Node>>, A>, HCons<Result<(Arc<Node>, usize, NodeOptions)>, L>: IntoTuple2,

pub fn with_dht( self, key_tag: usize, options: NodeOptions, ) -> NetworkBuilder<HCons<Result<(Arc<Node>, usize, NodeOptions)>, L>, (There<A>, There<R>)>

Creates DHT network layer

Examples

#[tokio::main]
async fn main() -> Result<()> {
    const DHT_KEY_TAG: usize = 0;

    let keystore = adnl::Keystore::builder()
        .with_tagged_key([0; 32], DHT_KEY_TAG)?
        .build();

    let adnl_options = adnl::NodeOptions::default();
    let dht_options = dht::NodeOptions::default();

    let (adnl, dht) = NetworkBuilder::with_adnl("127.0.0.1:10000", keystore, adnl_options)
        .with_dht(DHT_KEY_TAG, dht_options)
        .build()?;
    Ok(())
}

impl<L, A, R> NetworkBuilder<L, (A, R)>

where L: HList + Selector<Result<(Arc<Node>, Vec<Arc<dyn QuerySubscriber>>, NodeOptions)>, R>, HCons<Result<Arc<Node>>, L>: IntoTuple2,

pub fn with_overlay( self, key_tag: usize, ) -> NetworkBuilder<HCons<Result<Arc<Node>>, L>, (There<A>, There<R>)>

Creates overlay network layer.

NOTE: RLDP network layer must be present before calling this method.

Examples

#[tokio::main]
async fn main() -> Result<()> {
    const OVERLAY_KEY_TAG: usize = 0;

    let keystore = adnl::Keystore::builder()
        .with_tagged_key([0; 32], OVERLAY_KEY_TAG)?
        .build();

    let adnl_options = adnl::NodeOptions::default();
    let rldp_options = rldp::NodeOptions::default();

    let (adnl, rldp, overlay) =
        NetworkBuilder::with_adnl("127.0.0.1:10000", keystore, adnl_options)
            .with_rldp(rldp_options)
            .with_overlay(OVERLAY_KEY_TAG)
            .build()?;
    Ok(())
}

impl<L, A, R> NetworkBuilder<L, (A, R)>

where L: HList + Selector<Result<Arc<Node>>, A>, HCons<Result<(Arc<Node>, Vec<Arc<dyn QuerySubscriber>>, NodeOptions)>, L>: IntoTuple2,

pub fn with_rldp( self, options: NodeOptions, ) -> NetworkBuilder<HCons<Result<(Arc<Node>, Vec<Arc<dyn QuerySubscriber>>, NodeOptions)>, L>, (There<A>, Here)>

Creates RLDP network layer

See with_rldp_ext if you need an RLDP node with additional subscribers

Examples

#[tokio::main]
async fn main() -> Result<()> {
    let keystore = adnl::Keystore::builder()
        .with_tagged_key([0; 32], 0)?
        .build();

    let adnl_options = adnl::NodeOptions::default();
    let rldp_options = rldp::NodeOptions::default();

    let (adnl, rldp) = NetworkBuilder::with_adnl("127.0.0.1:10000", keystore, adnl_options)
        .with_rldp(rldp_options)
        .build()?;
    Ok(())
}

pub fn with_rldp_ext( self, options: NodeOptions, subscribers: Vec<Arc<dyn QuerySubscriber>>, ) -> NetworkBuilder<HCons<Result<(Arc<Node>, Vec<Arc<dyn QuerySubscriber>>, NodeOptions)>, L>, (There<A>, Here)>

Creates RLDP network layer with additional RLDP query subscribers

Examples

struct LoggerSubscriber;

#[async_trait::async_trait]
impl QuerySubscriber for LoggerSubscriber {
    async fn try_consume_query<'a>(
        &self,
        ctx: SubscriberContext<'a>,
        constructor: u32,
        query: Cow<'a, [u8]>,
    ) -> Result<QueryConsumingResult<'a>> {
        println!("received {constructor}");
        Ok(QueryConsumingResult::Rejected(query))
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let keystore = adnl::Keystore::builder()
        .with_tagged_key([0; 32], 0)?
        .build();

    let adnl_options = adnl::NodeOptions::default();
    let rldp_options = rldp::NodeOptions::default();

    let subscriber = Arc::new(LoggerSubscriber);

    let (adnl, rldp) = NetworkBuilder::with_adnl("127.0.0.1:10000", keystore, adnl_options)
        .with_rldp_ext(rldp_options, vec![subscriber])
        .build()?;
    Ok(())
}

impl<T, I> NetworkBuilder<T, I>

where T: DeferredInitializationList,

pub fn build(self) -> Result<T::Output>

Initializes all layers into a tuple of components