]> git.meshlink.io Git - meshlink/blob - test/metering-tcponly.c
Add missing metering testcases.
[meshlink] / test / metering-tcponly.c
1 #ifdef NDEBUG
2 #undef NDEBUG
3 #endif
4
5 #include <assert.h>
6 #include <inttypes.h>
7 #include <stdlib.h>
8 #include <stdio.h>
9 #include <string.h>
10
11 #include "meshlink.h"
12 #include "devtools.h"
13 #include "netns_utils.h"
14 #include "utils.h"
15
16 static struct sync_flag peer_reachable;
17 static struct sync_flag aio_done;
18 static const size_t size = 10000000;
19 static char *buffer;
20
21 static void nut_status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable) {
22         (void)mesh;
23
24         if(reachable && !strcmp(node->name, "peer")) {
25                 set_sync_flag(&peer_reachable, true);
26         }
27 }
28
29 static void aio_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len, void *priv) {
30         (void)mesh;
31         (void)channel;
32         (void)data;
33         (void)len;
34         (void)priv;
35
36         set_sync_flag(&aio_done, true);
37 }
38
39 static void peer_aio_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len, void *priv) {
40         (void)mesh;
41         (void)channel;
42         (void)data;
43         (void)len;
44         (void)priv;
45
46         meshlink_channel_close(mesh, channel);
47 }
48
49 static bool accept_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len) {
50         (void)port;
51         (void)data;
52         (void)len;
53
54         assert(buffer);
55         assert(meshlink_channel_aio_receive(mesh, channel, buffer, size, peer_aio_cb, NULL));
56         return true;
57 }
58
59 static void print_counters(peer_config_t *peers, const char *description) {
60         printf("%s:\n", description);
61         printf("        %9s %9s %9s %9s %9s %9s\n",
62                "in data",
63                "forward",
64                "meta",
65                "out data",
66                "forward",
67                "meta");
68
69         for(int i = 0; i < 3; i++) {
70                 meshlink_node_t *node = meshlink_get_node(peers[0].mesh, peers[i].name);
71                 assert(node);
72                 struct devtool_node_status status;
73                 devtool_reset_node_counters(peers[0].mesh, node, &status);
74                 printf(" %5s: %9" PRIu64 " %9" PRIu64 " %9" PRIu64 " %9" PRIu64 " %9" PRIu64 " %9" PRIu64 "\n",
75                        node->name,
76                        status.in_data,
77                        status.in_forward,
78                        status.in_meta,
79                        status.out_data,
80                        status.out_forward,
81                        status.out_meta);
82         }
83 }
84
85
86 int main(void) {
87         meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
88
89         init_sync_flag(&peer_reachable);
90         init_sync_flag(&aio_done);
91
92         // Set up relay, peer and NUT
93         peer_config_t *peers = setup_relay_peer_nut("metering-tcponly");
94         set_peers_tcponly(peers, 3);
95
96         meshlink_set_node_status_cb(peers[2].mesh, nut_status_cb);
97
98         for(int i = 0; i < 3; i++) {
99                 assert(meshlink_start(peers[i].mesh));
100         }
101
102         // Measure traffic after 1 minute of PMTU probing
103         sleep(60);
104         print_counters(peers, "PMTU probing (1 min)");
105
106         // Measure traffic after 1 minute of idle
107         for(int i = 0; i < 10; i++) {
108                 sleep(60);
109                 print_counters(peers, "Idle (1 min)");
110         }
111
112         // Measure channel traffic between relay and peer
113         buffer = calloc(1, size);
114         assert(buffer);
115         meshlink_node_t *peer = meshlink_get_node(peers[0].mesh, peers[1].name);
116         assert(peer);
117         meshlink_set_channel_accept_cb(peers[1].mesh, accept_cb);
118         meshlink_channel_t *channel = meshlink_channel_open(peers[0].mesh, peer, 1, NULL, NULL, 0);
119         assert(channel);
120         assert(meshlink_channel_aio_send(peers[0].mesh, channel, buffer, size, aio_cb, NULL));
121         assert(wait_sync_flag(&aio_done, 15));
122         meshlink_channel_close(peers[0].mesh, channel);
123         sleep(1);
124         print_counters(peers, "relay->peer channel traffic");
125
126         // Measure channel traffic between NUT and peer
127         assert(wait_sync_flag(&peer_reachable, 5));
128         meshlink_node_t *nut = meshlink_get_node(peers[0].mesh, peers[2].name);
129         assert(nut);
130         peer = meshlink_get_node(peers[2].mesh, peers[1].name);
131         assert(peer);
132         channel = meshlink_channel_open(peers[2].mesh, peer, 1, NULL, NULL, 0);
133         assert(channel);
134         init_sync_flag(&aio_done);
135         assert(meshlink_channel_aio_send(peers[2].mesh, channel, buffer, size, aio_cb, NULL));
136         assert(wait_sync_flag(&aio_done, 15));
137         meshlink_channel_close(peers[2].mesh, channel);
138         sleep(1);
139         print_counters(peers, "NUT->peer channel traffic");
140
141         close_relay_peer_nut(peers);
142 }