astu 0.0.0

Astu library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

use anyhow::Result;
use futures::stream::BoxStream;
use futures::StreamExt;
use ipnet::IpNet;

use crate::resolve::Resolve;
use crate::resolve::Target;

/// Expands CIDR blocks into targets.
#[derive(Debug, Default, Clone, Copy)]
pub struct CidrResolver {
    // FIXME: Use PhantomData to force usage of constructors
}

impl Resolve for CidrResolver {
    fn resolve_fallible(&self, target: Target) -> BoxStream<Result<Target>> {
        match target {
            Target::Cidr(cidr) => self.resolve_cidr(cidr),
            _unsupported => futures::stream::empty().boxed(),
        }
    }
}

impl CidrResolver {
    #[allow(clippy::unused_self)]
    fn resolve_cidr(&self, cidr: IpNet) -> BoxStream<Result<Target>> {
        let ips = cidr.hosts().map(|ip| Ok(Target::from(ip)));
        futures::stream::iter(ips).boxed()
    }
}

#[cfg(test)]
mod tests {
    use std::str::FromStr;

    use rstest::rstest;

    use super::*;
    use crate::resolve::ResolveExt;

    #[rstest]
    #[case("127.0.0.1/32", 1)]
    #[case("127.0.0.0/16", 65534)]
    #[case("::1/128", 1)]
    #[case("::1/112", 65536)]
    #[tokio::test]
    async fn resolve_works(#[case] query: &str, #[case] num: usize) {
        let target = Target::from_str(query).unwrap();
        let resolver = CidrResolver::default();
        let targets = resolver.resolve_set(target).await;
        assert_eq!(targets.len(), num);
    }
}