git.meshlink.io Git - meshlink-tiny/blob - 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_set_storage_policy(mesh1, MESHLINK_STORAGE_DISABLED);
  29         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_DISABLED);
  30
  31         // Exchange data
  32
  33         char *export1 = meshlink_export(mesh1);
  34         char *export2 = meshlink_export(mesh2);
  35
  36         assert(export1);
  37         assert(export2);
  38
  39         assert(meshlink_import(mesh1, export2));
  40         assert(meshlink_import(mesh2, export1));
  41
  42         // Check that they know each other
  43
  44         assert(meshlink_get_node(mesh1, "bar"));
  45         assert(meshlink_get_node(mesh2, "foo"));
  46
  47         start_meshlink_pair(mesh1, mesh2);
  48
  49         // Close the instances and reopen them.
  50
  51         close_meshlink_pair(mesh1, mesh2);
  52
  53         mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
  54         mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
  55         assert(mesh1);
  56         assert(mesh2);
  57         meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
  58         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
  59
  60         // Check that the nodes no longer know each other
  61
  62         assert(!meshlink_get_node(mesh1, "bar"));
  63         assert(!meshlink_get_node(mesh2, "foo"));
  64
  65         // Exchange data again
  66
  67         assert(meshlink_import(mesh1, export2));
  68         assert(meshlink_import(mesh2, export1));
  69
  70         free(export1);
  71         free(export2);
  72
  73         // Close the instances and reopen them.
  74
  75         close_meshlink_pair(mesh1, mesh2);
  76
  77         mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
  78         mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
  79         assert(mesh1);
  80         assert(mesh2);
  81         meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
  82         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
  83
  84         // Check that the nodes know each other
  85
  86         assert(meshlink_get_node(mesh1, "bar"));
  87         assert(meshlink_get_node(mesh2, "foo"));
  88
  89         // Check that we update reachability
  90
  91         time_t last_reachable;
  92         time_t last_unreachable;
  93         assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
  94         assert(!last_reachable);
  95         assert(!last_unreachable);
  96
  97         start_meshlink_pair(mesh1, mesh2);
  98         stop_meshlink_pair(mesh1, mesh2);
  99
 100         assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
 101         assert(last_reachable);
 102         assert(last_unreachable);
 103
 104         // But have not stored it
 105
 106         close_meshlink_pair(mesh1, mesh2);
 107
 108         mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
 109         mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
 110         assert(mesh1);
 111         assert(mesh2);
 112         meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
 113         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
 114
 115         assert(meshlink_get_node(mesh1, "bar"));
 116         assert(meshlink_get_node(mesh2, "foo"));
 117
 118         assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
 119         assert(!last_reachable);
 120         assert(!last_unreachable);
 121
 122         // Check that if we change back to STORAGE_ENABLED right before closing, pending changes are still saved
 123
 124         start_meshlink_pair(mesh1, mesh2);
 125         stop_meshlink_pair(mesh1, mesh2);
 126
 127         meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_ENABLED);
 128         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_ENABLED);
 129
 130         close_meshlink_pair(mesh1, mesh2);
 131
 132         mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
 133         mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
 134         assert(mesh1);
 135         assert(mesh2);
 136
 137         assert(!meshlink_get_node_reachability(mesh1, meshlink_get_node(mesh1, "bar"), &last_reachable, &last_unreachable));
 138         assert(last_reachable);
 139         assert(last_unreachable);
 140
 141         // Close the instances and reopen them.
 142
 143         close_meshlink_pair(mesh1, mesh2);
 144
 145         mesh1 = meshlink_open("storage-policy_conf.1", "foo", "storage-policy", DEV_CLASS_BACKBONE);
 146         mesh2 = meshlink_open("storage-policy_conf.2", "bar", "storage-policy", DEV_CLASS_BACKBONE);
 147         assert(mesh1);
 148         assert(mesh2);
 149         meshlink_set_storage_policy(mesh1, MESHLINK_STORAGE_KEYS_ONLY);
 150         meshlink_set_storage_policy(mesh2, MESHLINK_STORAGE_KEYS_ONLY);
 151
 152         // Check that the nodes know each other
 153
 154         assert(meshlink_get_node(mesh1, "bar"));
 155         assert(meshlink_get_node(mesh2, "foo"));
 156
 157         // Done.
 158
 159         close_meshlink_pair(mesh1, mesh2);
 160 }