veilid-core 0.5.3

Core library used to create a Veilid node and operate it as part of an application
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

pub mod rolling_transfers;
use super::*;

impl NetworkManager {
    pub fn setup_tasks(&self) {
        // Set rolling transfers tick task
        impl_setup_task_async!(
            self,
            Self,
            rolling_transfers_task,
            rolling_transfers_task_routine
        );

        // Set address filter task
        {
            let registry = self.registry();
            self.address_filter_task.set_routine(move |s, l, t| {
                let registry = registry.clone();
                Box::pin(async move {
                    registry
                        .network_manager()
                        .address_filter()
                        .address_filter_task_routine(s, Timestamp::new(l), Timestamp::new(t))
                        .await
                })
            });
        }
    }

    pub async fn tick_event_handler(&self, _evt: Arc<TickEvent>) {
        if let Err(e) = self.tick().await {
            error!("Error in network manager tick: {}", e);
        }
    }

    #[cfg_attr(
        feature = "instrument",
        instrument(level = "trace", name = "NetworkManager::tick", skip_all, err, fields(__VEILID_LOG_KEY = self.log_key()))
    )]
    async fn tick(&self) -> EyreResult<()> {
        let Ok(_startup_guard) = self.startup_context.startup_lock.enter() else {
            return Ok(());
        };

        let net = self.net();
        let receipt_manager = self.receipt_manager();

        // Run the rolling transfers task
        self.rolling_transfers_task.tick().await?;

        // Run the address filter task
        self.address_filter_task.tick().await?;

        // Run the low level network tick
        net.tick().await?;

        // Run the receipt manager tick
        receipt_manager.tick().await?;

        // Purge the client allowlist
        self.purge_client_allowlist();

        Ok(())
    }

    pub async fn cancel_tasks(&self) {
        veilid_log!(self debug "stopping receipt manager tasks");
        let receipt_manager = self.receipt_manager();
        receipt_manager.cancel_tasks().await;

        let net = self.net();
        net.cancel_tasks().await;

        veilid_log!(self debug "stopping rolling transfers task");
        if let Err(e) = self.rolling_transfers_task.stop().await {
            veilid_log!(self warn "rolling_transfers_task not stopped: {}", e);
        }

        veilid_log!(self debug "stopping address filter task");
        if let Err(e) = self.address_filter_task.stop().await {
            veilid_log!(self warn "address_filter_task not stopped: {}", e);
        }
    }
}