nftables-async 0.4.1

An async version of the helper to run nftables, providing full compatibility with the rest of the nftables crate
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use std::future::Future;

use nftables::{
    batch::Batch,
    helper::NftablesError,
    schema::{NfListObject, NfObject, Nftables, Table},
    types::NfFamily,
};
use nftables_async::{
    driver::{AsyncProcessDriver, TokioDriver},
    helper::Helper,
};

#[test]
fn can_apply_ruleset() {
    run_test(|is_tokio| async move {
        let mut batch = Batch::new();
        batch.add_obj(NfListObject::Table(Table {
            family: NfFamily::INet,
            name: format!("table{}", fastrand::u32(1..=10000)).into(),
            handle: None,
        }));

        wrapped_apply_ruleset(batch.to_nftables(), is_tokio)
            .await
            .unwrap();
    });
}

#[test]
fn can_get_current_ruleset() {
    run_test(|is_tokio| async move {
        let mut batch = Batch::new();
        let table_name = format!("table{}", fastrand::u32(1..=10000));
        batch.add_obj(NfListObject::Table(Table {
            family: NfFamily::INet,
            name: table_name.clone().into(),
            handle: None,
        }));

        wrapped_apply_ruleset(batch.to_nftables(), is_tokio)
            .await
            .unwrap();

        let current_ruleset = wrapped_get_current_ruleset(is_tokio).await.unwrap();
        let mut valid = false;

        for object in current_ruleset.objects.iter() {
            match object {
                NfObject::ListObject(object) => match object {
                    NfListObject::Table(table) if table.name == table_name => {
                        valid = true;
                    }
                    _ => {}
                },
                _ => {}
            }
        }

        if !valid {
            panic!("Current ruleset did not contain expected table: {table_name}");
        }
    });
}

async fn wrapped_apply_ruleset(
    nftables: Nftables<'_>,
    is_tokio: bool,
) -> Result<(), NftablesError> {
    if is_tokio {
        TokioDriver::apply_ruleset(&nftables).await
    } else {
        AsyncProcessDriver::apply_ruleset(&nftables).await
    }
}

async fn wrapped_get_current_ruleset(is_tokio: bool) -> Result<Nftables<'static>, NftablesError> {
    if is_tokio {
        TokioDriver::get_current_ruleset().await
    } else {
        AsyncProcessDriver::get_current_ruleset().await
    }
}

fn run_test<F, Fut>(function: F)
where
    F: Fn(bool) -> Fut,
    Fut: Future<Output = ()> + Send,
{
    tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap()
        .block_on(function(true));

    async_io::block_on(function(false));
}