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
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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

use super::*;

async fn test_startup_shutdown() {
    info!("test_startup_shutdown: starting");
    let (update_callback, config) = fixture_veilid_core();
    let api = api_startup(update_callback, config)
        .await
        .expect_or_log("startup failed");

    // Test initial state
    assert!(!api.is_shutdown(), "API should not be shut down initially");

    info!("test_startup_shutdown: shutting down");
    let api_clone = api.clone();
    api.shutdown().await;

    // Test state after shutdown
    assert!(
        api_clone.is_shutdown(),
        "API should be shut down after shutdown()"
    );

    info!("test_startup_shutdown: finished");
}

async fn test_startup_shutdown_from_config() {
    info!("test_startup_from_config: starting");
    let (update_callback, config) = fixture_veilid_core();
    let config_json = serialize_json(config);
    let api = api_startup_json(update_callback, config_json)
        .await
        .expect("startup failed");
    info!("test_startup_from_config: shutting down");
    api.shutdown().await;
    info!("test_startup_from_config: finished");
}

async fn test_attach_detach() {
    info!("test_attach_detach: --- test normal order ---");
    let (update_callback, config) = fixture_veilid_core();
    let api = api_startup(update_callback, config)
        .await
        .expect("startup failed");
    api.attach().await.unwrap();
    sleep(5000).await;
    api.detach().await.unwrap();
    sleep(2000).await;
    api.shutdown().await;

    info!("test_attach_detach: --- test auto detach ---");
    let (update_callback, config) = fixture_veilid_core();
    let api = api_startup(update_callback, config)
        .await
        .expect("startup failed");
    api.attach().await.unwrap();
    sleep(5000).await;
    api.shutdown().await;

    info!("test_attach_detach: --- test detach without attach ---");
    let (update_callback, config) = fixture_veilid_core();
    let api = api_startup(update_callback, config)
        .await
        .expect("startup failed");
    assert!(api.detach().await.is_err());
    api.shutdown().await;
}

async fn test_startup_shutdown_multiple() {
    info!("test_startup_shutdown_multiple: starting");
    let namespaces = (0..3).map(|x| format!("ns_{}", x)).collect::<Vec<_>>();
    let mut apis = vec![];
    for ns in &namespaces {
        let (update_callback, config) = fixture_veilid_core_with_namespace(ns);
        let api = api_startup(update_callback, config)
            .await
            .expect("startup failed");
        apis.push(api);
    }
    info!("test_startup_shutdown_multiple: shutting down");
    for api in apis {
        api.shutdown().await;
    }
    info!("test_startup_shutdown_multiple: finished");
}

async fn test_startup_shutdown_from_config_multiple() {
    info!("test_startup_from_config_multiple: starting");

    let namespaces = (0..3).map(|x| format!("ns_{}", x)).collect::<Vec<_>>();
    let mut apis = vec![];
    for ns in &namespaces {
        let (update_callback, config) = fixture_veilid_core_with_namespace(ns);
        let api = api_startup(update_callback, config)
            .await
            .expect("startup failed");
        apis.push(api);
    }
    info!("test_startup_from_config_multiple: shutting down");
    for api in apis {
        api.shutdown().await;
    }
    info!("test_startup_from_config_multiple: finished");
}

async fn test_attach_detach_multiple() {
    info!("test_attach_detach_multiple: --- test normal order ---");
    let namespaces = (0..3).map(|x| format!("ns_{}", x)).collect::<Vec<_>>();
    let mut apis = vec![];
    for ns in &namespaces {
        let (update_callback, config) = fixture_veilid_core_with_namespace(ns);
        let api = api_startup(update_callback, config)
            .await
            .expect("startup failed");
        apis.push(api);
    }
    for api in &apis {
        api.attach().await.unwrap();
    }
    sleep(5000).await;
    for api in &apis {
        api.detach().await.unwrap();
    }
    sleep(2000).await;
    for api in apis {
        api.shutdown().await;
    }

    info!("test_attach_detach_multiple: --- test auto detach ---");
    let mut apis = vec![];
    for ns in &namespaces {
        let (update_callback, config) = fixture_veilid_core_with_namespace(ns);
        let api = api_startup(update_callback, config)
            .await
            .expect("startup failed");
        apis.push(api);
    }

    for api in &apis {
        api.attach().await.unwrap();
    }
    sleep(5000).await;
    for api in apis {
        api.shutdown().await;
    }

    info!("test_attach_detach_multiple: --- test detach without attach ---");
    let mut apis = vec![];
    for ns in &namespaces {
        let (update_callback, config) = fixture_veilid_core_with_namespace(ns);
        let api = api_startup(update_callback, config)
            .await
            .expect("startup failed");
        apis.push(api);
    }
    for api in &apis {
        assert!(api.detach().await.is_err());
    }
    for api in apis {
        api.shutdown().await;
    }
}

pub async fn test_all() {
    test_startup_shutdown().await;
    test_startup_shutdown_from_config().await;
    test_attach_detach().await;
    test_startup_shutdown_multiple().await;
    test_startup_shutdown_from_config_multiple().await;
    test_attach_detach_multiple().await;
}