ctdb/tests/src/ctdb_tool_libctdb.c

   1 /*
   2    Tests for tools/ctdb.c and libctdb stubs
   3
   4    Copyright (C) Martin Schwenke 2011
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #define CTDB_TEST_OVERRIDE_MAIN
  21 #include "ctdb_test.c"
  22
  23 static void test_read_nodemap(void)
  24 {
  25         struct ctdb_context *ctdb = talloc_zero(NULL, struct ctdb_context);
  26
  27         libctdb_test_read_nodemap(ctdb);
  28         libctdb_test_print_nodemap(ctdb);
  29
  30         talloc_free(ctdb);
  31 }
  32
  33 static void test_read_ifaces(void)
  34 {
  35         struct ctdb_context *ctdb = talloc_zero(NULL, struct ctdb_context);
  36
  37         libctdb_test_read_ifaces(ctdb);
  38         libctdb_test_print_ifaces(ctdb);
  39
  40         talloc_free(ctdb);
  41 }
  42
  43 static void test_read_vnnmap(void)
  44 {
  45         struct ctdb_context *ctdb = talloc_zero(NULL, struct ctdb_context);
  46
  47         libctdb_test_read_vnnmap(ctdb);
  48         libctdb_test_print_vnnmap(ctdb);
  49
  50         talloc_free(ctdb);
  51 }
  52
  53 static void test_fake_setup(void)
  54 {
  55         bool first = true;
  56         struct ctdb_context *ctdb = talloc_zero(NULL, struct ctdb_context);
  57
  58         libctdb_test_fake_setup(ctdb);
  59
  60         if (ctdb->nodes != NULL) {
  61                 if (!first) {
  62                         printf("\n");
  63                 }
  64                 printf("NODEMAP\n");
  65                 libctdb_test_print_nodemap(ctdb);
  66                 first = false;
  67         }
  68
  69         if (ctdb->ifaces != NULL) {
  70                 if (!first) {
  71                         printf("\n");
  72                 }
  73                 printf("IFACES\n");
  74                 libctdb_test_print_ifaces(ctdb);
  75                 first = false;
  76         }
  77
  78         if (ctdb->vnn_map != NULL) {
  79                 if (!first) {
  80                         printf("\n");
  81                 }
  82                 printf("VNNMAP\n");
  83                 libctdb_test_print_vnnmap(ctdb);
  84                 first = false;
  85         }
  86
  87         talloc_free(ctdb);
  88 }
  89
  90 static const char * decode_pnn_mode(uint32_t pnn_mode)
  91 {
  92         int i;
  93         static const struct {
  94                 uint32_t mode;
  95                 const char *name;
  96         } pnn_modes[] = {
  97                 { CTDB_CURRENT_NODE,        "CURRENT_NODE" },
  98                 { CTDB_BROADCAST_ALL,       "BROADCAST_ALL" },
  99                 { CTDB_BROADCAST_VNNMAP,    "BROADCAST_VNNMAP" },
 100                 { CTDB_BROADCAST_CONNECTED, "BROADCAST_CONNECTED" },
 101                 { CTDB_MULTICAST,           "MULTICAST" },
 102         };
 103
 104         for (i = 0; i < ARRAY_SIZE(pnn_modes); i++) {
 105                 if (pnn_mode == pnn_modes[i].mode) {
 106                         return pnn_modes[i].name;
 107                 }
 108         }
 109
 110         return "PNN";
 111 }
 112
 113 static void print_nodes(uint32_t *nodes, uint32_t pnn_mode)
 114 {
 115         int i;
 116
 117         printf("NODES:");
 118         for (i = 0; i < talloc_array_length(nodes); i++) {
 119                 printf(" %lu", (unsigned long) nodes[i]);
 120         }
 121         printf("\n");
 122
 123         printf("PNN MODE: %s (%lu)\n",
 124                decode_pnn_mode(pnn_mode), (unsigned long) pnn_mode);
 125 }
 126
 127 static void test_parse_nodestring(const char *nodestring_s,
 128                                   const char *dd_ok_s)
 129 {
 130         const char *nodestring;
 131         bool dd_ok;
 132         struct ctdb_context *ctdb;
 133         uint32_t *nodes;
 134         uint32_t pnn_mode;
 135
 136         nodestring = strcmp("", nodestring_s) == 0 ? NULL : nodestring_s;
 137
 138         if (strcasecmp(dd_ok_s, "yes") == 0 ||
 139             strcmp(dd_ok_s, "true") == 0) {
 140                 dd_ok = true;
 141         } else {
 142                 dd_ok = false;
 143         }
 144
 145         ctdb  = talloc_zero(NULL, struct ctdb_context);
 146
 147         libctdb_test_read_nodemap(ctdb);
 148
 149         if (parse_nodestring(ctdb, NULL, nodestring, CTDB_CURRENT_NODE, dd_ok,
 150                              &nodes, &pnn_mode)) {
 151                 print_nodes(nodes, pnn_mode);
 152         }
 153
 154         talloc_free(ctdb);
 155 }
 156
 157 static void usage(void)
 158 {
 159         fprintf(stderr, "usage: ctdb_tool_libctdb <op>\n");
 160         exit(1);
 161 }
 162
 163 int main(int argc, const char *argv[])
 164 {
 165         LogLevel = DEBUG_DEBUG;
 166         if (getenv("CTDB_TEST_LOGLEVEL")) {
 167                 LogLevel = atoi(getenv("CTDB_TEST_LOGLEVEL"));
 168         }
 169
 170         if (argc < 2) {
 171                 usage();
 172         }
 173
 174         if (argc == 2 && strcmp(argv[1], "read_nodemap") == 0) {
 175                 test_read_nodemap();
 176         } else if (argc == 2 && strcmp(argv[1], "read_ifaces") == 0) {
 177                 test_read_ifaces();
 178         } else if (argc == 2 && strcmp(argv[1], "read_vnnmap") == 0) {
 179                 test_read_vnnmap();
 180         } else if (argc == 2 && strcmp(argv[1], "fake_setup") == 0) {
 181                 test_fake_setup();
 182         } else if (argc == 4 && strcmp(argv[1], "parse_nodestring") == 0) {
 183                 test_parse_nodestring(argv[2], argv[3]);
 184         } else {
 185                 usage();
 186         }
 187
 188         return 0;
 189 }