Struct WhitelistStrategy 

pub struct WhitelistStrategy { /* private fields */ }

Available on crate feature distributed-impl only.

Strategy that receives messages only from whitelisted peers and sends messages only to them.

Example

use tocket::{TokenBucket, DistributedStorage, WhitelistStrategy};
use std::net::ToSocketAddrs;
use std::time::Duration;

async fn make_token_bucket<I, S>(port: u16, peers: I) -> TokenBucket<DistributedStorage>
where
    I: IntoIterator<Item = S>,
    S: ToSocketAddrs,
{
    let storage = DistributedStorage::serve(
        2,
        format!("0.0.0.0:{}", port),
        WhitelistStrategy::new(peers).unwrap(),
    )
    .await
    .unwrap();

    TokenBucket::new(storage)
}

#[tokio::main]
async fn main() {
    let tb1 = make_token_bucket(49001, vec!["127.0.0.1:49002", "127.0.0.1:49003"]).await;
    let tb2 = make_token_bucket(49002, vec!["127.0.0.1:49001", "127.0.0.1:49003"]).await;
    let tb3 = make_token_bucket(49003, vec!["127.0.0.1:49001", "127.0.0.1:49002"]).await;

    assert!(tb1.try_acquire(2).is_ok());
    assert!(tb1.try_acquire_one().is_err());

    // Waiting for some time until the message reaches the rest token buckets
    tokio::time::sleep(Duration::from_millis(100)).await;

    assert!(tb2.try_acquire_one().is_err());
    assert!(tb3.try_acquire_one().is_err());

}

Implementations

impl WhitelistStrategy

pub fn new<I, S>(peers: I) -> Result<Self, DistributedStorageError>

where I: IntoIterator<Item = S>, S: ToSocketAddrs,

Creates a strategy with provided whitelist of peers.

Errors

Will return Err if failed to resolve any of address.

Trait Implementations

impl Strategy for WhitelistStrategy

fn on_acquire<'life0, 'life1, 'async_trait>( &'life0 mut self, permits: u32, framed: &'life1 mut UdpFramed<Codec>, ) -> Pin<Box<dyn Future<Output = Result<(), DistributedStorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn on_msg_recv<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, msg: Message, source: SocketAddr, storage: &'life1 InMemoryStorage, _framed: &'life2 mut UdpFramed<Codec>, ) -> Pin<Box<dyn Future<Output = Result<(), DistributedStorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,