zeronsd 0.5.0

Unicast DNS resolver for ZeroTier networks
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use std::time::Duration;

use tracing::warn;
use zeronsd::utils::{authtoken_path, get_listen_ips};
use zerotier_central_api::types::{Member, MemberConfig, Network};
use zerotier_one_api::types::{NetworkSubtype0, NetworkSubtype1};

use super::{context::TestContext, member::MemberConfigUtil, utils::network_definition};

// TestNetwork creates a testnetwork in central and joins it. When this data is destroyed/dropped
// it will remove the network and leave it like nothing ever happened.
#[derive(Clone)]
pub struct TestNetwork {
    pub network: Network,
    context: TestContext,
    member: Member,
}

impl TestNetwork {
    // new_multi_ip covers situations where zeronsd is using more than one listening ip.
    pub async fn new_multi_ip(
        network_def: &str,
        tc: &mut TestContext,
        ips: Vec<&str>,
    ) -> Result<Self, anyhow::Error> {
        let mut mc = MemberConfig::new(tc.identity.clone());
        mc.set_ip_assignments(ips);
        tc.member_config = Some(mc);
        Self::new(network_def, tc).await
    }

    // constructor.
    pub async fn new(network_def: &str, tc: &mut TestContext) -> Result<Self, anyhow::Error> {
        let network = tc
            .central
            .new_network(&network_definition(network_def.to_string())?)
            .await
            .unwrap();

        let member = tc.get_member(network.clone().id.unwrap());

        tc.central
            .update_network_member(&network.clone().id.unwrap(), &tc.identity, &member)
            .await
            .unwrap();

        let s = Self {
            network: network.to_owned(),
            member,
            context: tc.clone(),
        };

        s.join().await.unwrap();

        Ok(s)
    }

    // join zerotier-one to the test network
    pub async fn join(&self) -> Result<(), anyhow::Error> {
        let network = zerotier_one_api::types::Network {
            subtype_0: NetworkSubtype0 {
                allow_dns: Some(true),
                allow_global: Some(false),
                allow_default: Some(false),
                allow_managed: Some(true),
            },
            subtype_1: NetworkSubtype1 {
                status: None,
                type_: None,
                routes: Vec::new(),
                port_error: None,
                port_device_name: None,
                netconf_revision: None,
                name: None,
                multicast_subscriptions: Vec::new(),
                mtu: None,
                mac: None,
                id: None,
                dns: None,
                broadcast_enabled: None,
                bridge: None,
                assigned_addresses: Vec::new(),
                allow_dns: Some(true),
                allow_global: Some(false),
                allow_default: Some(false),
                allow_managed: Some(true),
            },
        };

        self.context
            .zerotier
            .update_network(&self.network.id.clone().unwrap(), &network)
            .await?;

        let id = self.network.id.clone().unwrap();
        let mut count = 0;

        while let Err(e) = get_listen_ips(&authtoken_path(None), &id).await {
            tokio::time::sleep(Duration::new(1, 0)).await;
            count += 1;
            if count >= 5 {
                warn!("5 attempts: While joining network: {:?}", e);
                count = 0;
            }
        }
        Ok(())
    }

    // leave the test network
    pub async fn leave(&self) -> Result<(), anyhow::Error> {
        Ok(self
            .context
            .zerotier
            .delete_network(&self.network.id.clone().unwrap())
            .await?
            .to_owned())
    }

    pub fn identity(&self) -> String {
        self.context.identity.clone()
    }

    pub fn central(&self) -> zerotier_central_api::Client {
        self.context.central.clone()
    }

    pub fn member(&self) -> Member {
        self.member.clone()
    }

    pub fn teardown(&mut self) {
        tokio::task::block_in_place(move || {
            tokio::runtime::Handle::current().block_on(async {
                self.leave().await.unwrap();
                let central = self.central();
                central
                    .delete_network(&self.network.id.clone().unwrap())
                    .await
                    .unwrap();
            })
        })
    }
}

// drop just removes the network from central and leaves it. it tries to recover, not get more
// angry, in the face of errors.
impl Drop for TestNetwork {
    fn drop(&mut self) {
        self.teardown()
    }
}