]> git.meshlink.io Git - meshlink-tiny/blob - test/storage-policy.c
Rename the library and public header to meshlink-tiny.
[meshlink-tiny] / test / storage-policy.c
1 #ifdef NDEBUG
2 #undef NDEBUG
3 #endif
4
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <sys/time.h>
8 #include <assert.h>
9
10 #include "meshlink-tiny.h"
11 #include "utils.h"
12
13 int main(void) {
14         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
15
16         meshlink_handle_t *mesh1;
17         meshlink_handle_t *mesh2;
18
19         // Open two instances
20
21         assert(meshlink_destroy("storage-policy_conf.1"));
22         assert(meshlink_destroy("storage-policy_conf.2"));
23
24         mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
25         mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
26         assert(mesh1);
27         assert(mesh2);
28         meshlink_enable_discovery(mesh1, false);
29         meshlink_enable_discovery(mesh2, false);
30         meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_DISABLED);
31         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_DISABLED);
32
33         // Exchange data
34
35         char *export1 = meshlink_export(mesh1);
36         char *export2 = meshlink_export(mesh2);
37
38         assert(export1);
39         assert(export2);
40
41         assert(meshlink_import(mesh1, export2));
42         assert(meshlink_import(mesh2, export1));
43
44         // Check that they know each other
45
46         assert(meshlink_get_node(mesh1, "bar"));
47         assert(meshlink_get_node(mesh2, "foo"));
48
49         start_meshlink_pair(mesh1, mesh2);
50
51         // Close the instances and reopen them.
52
53         close_meshlink_pair(mesh1, mesh2);
54
55         mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
56         mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
57         assert(mesh1);
58         assert(mesh2);
59         meshlink_enable_discovery(mesh1, false);
60         meshlink_enable_discovery(mesh2, false);
61         meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
62         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
63
64         // Check that the nodes no longer know each other
65
66         assert(!meshlink_get_node(mesh1, "bar"));
67         assert(!meshlink_get_node(mesh2, "foo"));
68
69         // Exchange data again
70
71         assert(meshlink_import(mesh1, export2));
72         assert(meshlink_import(mesh2, export1));
73
74         free(export1);
75         free(export2);
76
77         // Close the instances and reopen them.
78
79         close_meshlink_pair(mesh1, mesh2);
80
81         mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
82         mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
83         assert(mesh1);
84         assert(mesh2);
85         meshlink_enable_discovery(mesh1, false);
86         meshlink_enable_discovery(mesh2, false);
87         meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
88         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
89
90         // Check that the nodes know each other
91
92         assert(meshlink_get_node(mesh1, "bar"));
93         assert(meshlink_get_node(mesh2, "foo"));
94
95         // Check that we update reachability
96
97         time_t last_reachable;
98         time_t last_unreachable;
99         assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
100         assert(!last_reachable);
101         assert(!last_unreachable);
102
103         start_meshlink_pair(mesh1, mesh2);
104         stop_meshlink_pair(mesh1, mesh2);
105
106         assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
107         assert(last_reachable);
108         assert(last_unreachable);
109
110         // But have not stored it
111
112         close_meshlink_pair(mesh1, mesh2);
113
114         mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
115         mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
116         assert(mesh1);
117         assert(mesh2);
118         meshlink_enable_discovery(mesh1, false);
119         meshlink_enable_discovery(mesh2, false);
120         meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
121         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
122
123         assert(meshlink_get_node(mesh1, "bar"));
124         assert(meshlink_get_node(mesh2, "foo"));
125
126         assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
127         assert(!last_reachable);
128         assert(!last_unreachable);
129
130         // Check that if we change back to STORAGE_ENABLED right before closing, pending changes are still saved
131
132         start_meshlink_pair(mesh1, mesh2);
133         stop_meshlink_pair(mesh1, mesh2);
134
135         meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_ENABLED);
136         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_ENABLED);
137
138         close_meshlink_pair(mesh1, mesh2);
139
140         mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
141         mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
142         assert(mesh1);
143         assert(mesh2);
144         meshlink_enable_discovery(mesh1, false);
145         meshlink_enable_discovery(mesh2, false);
146
147         assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
148         assert(last_reachable);
149         assert(last_unreachable);
150
151         // Close the instances and reopen them.
152
153         close_meshlink_pair(mesh1, mesh2);
154
155         mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
156         mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
157         assert(mesh1);
158         assert(mesh2);
159         meshlink_enable_discovery(mesh1, false);
160         meshlink_enable_discovery(mesh2, false);
161         meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
162         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
163
164         // Check that the nodes know each other
165
166         assert(meshlink_get_node(mesh1, "bar"));
167         assert(meshlink_get_node(mesh2, "foo"));
168
169         // Done.
170
171         close_meshlink_pair(mesh1, mesh2);
172 }