src/testing/test_testing_topology_churn.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20 /**
  21  * @file testing/test_testing_topology_churn.c
  22  * @brief base testcase for testing simple churn functionality
  23  */
  24 #include "platform.h"
  25 #include "gnunet_testing_lib.h"
  26 #include "gnunet_core_service.h"
  27
  28 #define VERBOSE GNUNET_YES
  29
  30 /**
  31  * How long until we fail the whole testcase?
  32  */
  33 #define TEST_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 600)
  34
  35 /**
  36  * How long until we give up on starting the peers? (Must be longer than the connect timeout!)
  37  */
  38 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
  39
  40 #define DEFAULT_NUM_PEERS 4
  41
  42 static int ok;
  43
  44 static unsigned long long num_peers;
  45
  46 static unsigned int expected_connections;
  47
  48 static unsigned int expected_failed_connections;
  49
  50 static unsigned long long peers_left;
  51
  52 static struct GNUNET_TESTING_PeerGroup *pg;
  53
  54 const struct GNUNET_CONFIGURATION_Handle *main_cfg;
  55
  56 GNUNET_SCHEDULER_TaskIdentifier die_task;
  57
  58 static char *test_directory;
  59
  60 #define MTYPE 12345
  61
  62 GNUNET_NETWORK_STRUCT_BEGIN
  63
  64 struct GNUNET_TestMessage
  65 {
  66   /**
  67    * Header of the message
  68    */
  69   struct GNUNET_MessageHeader header;
  70
  71   /**
  72    * Unique identifier for this message.
  73    */
  74   uint32_t uid;
  75 };
  76 GNUNET_NETWORK_STRUCT_END
  77
  78 /**
  79  * Check whether peers successfully shut down.
  80  */
  81 void
  82 shutdown_callback (void *cls, const char *emsg)
  83 {
  84   if (emsg != NULL)
  85   {
  86 #if VERBOSE
  87     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown of peers failed!\n");
  88 #endif
  89     if (ok == 0)
  90       ok = 666;
  91   }
  92   else
  93   {
  94 #if VERBOSE
  95     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All peers successfully shut down!\n");
  96 #endif
  97   }
  98 }
  99
 100 static void
 101 finish_testing ()
 102 {
 103   GNUNET_assert (pg != NULL);
 104
 105   if (die_task != GNUNET_SCHEDULER_NO_TASK)
 106     GNUNET_SCHEDULER_cancel (die_task);
 107
 108 #if VERBOSE
 109   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 110               "Called finish testing, stopping daemons.\n");
 111 #endif
 112
 113 #if VERBOSE
 114   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Calling daemons_stop\n");
 115 #endif
 116   GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 117 #if VERBOSE
 118   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "daemons_stop finished\n");
 119 #endif
 120
 121   ok = 0;
 122 }
 123
 124 static void
 125 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 126 {
 127   char *msg = cls;
 128
 129   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 130               "End badly was called (%s)... stopping daemons.\n", msg);
 131
 132   if (pg != NULL)
 133   {
 134     GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 135     ok = 7331;                  /* Opposite of leet */
 136   }
 137   else
 138     ok = 401;                   /* Never got peers started */
 139
 140 }
 141
 142 struct ChurnTestContext
 143 {
 144   GNUNET_SCHEDULER_Task next_task;
 145
 146 };
 147
 148 static struct ChurnTestContext churn_ctx;
 149
 150 /**
 151  * Churn callback, report on success or failure of churn operation.
 152  *
 153  * @param cls closure
 154  * @param emsg NULL on success
 155  */
 156 void
 157 churn_callback (void *cls, const char *emsg)
 158 {
 159   if (emsg == NULL)
 160   {
 161     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Successfully churned peers!\n",
 162                 emsg);
 163     GNUNET_SCHEDULER_add_now (churn_ctx.next_task, NULL);
 164   }
 165   else
 166   {
 167     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 168                 "Failed to churn peers with error `%s'\n", emsg);
 169     GNUNET_SCHEDULER_cancel (die_task);
 170     die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
 171   }
 172 }
 173
 174
 175 static void
 176 churn_peers_both ()
 177 {
 178   churn_ctx.next_task = &finish_testing;
 179   GNUNET_TESTING_daemons_churn (pg, NULL, 1, 1, TIMEOUT, &churn_callback, NULL);
 180 }
 181
 182 static void
 183 churn_peers_off_again ()
 184 {
 185   churn_ctx.next_task = &churn_peers_both;
 186   GNUNET_TESTING_daemons_churn (pg, NULL, 2, 0, TIMEOUT, &churn_callback, NULL);
 187 }
 188
 189 static void
 190 churn_peers_on ()
 191 {
 192   churn_ctx.next_task = &churn_peers_off_again;
 193   GNUNET_TESTING_daemons_churn (pg, NULL, 0, 2, TIMEOUT, &churn_callback, NULL);
 194 }
 195
 196 static void
 197 churn_peers_off ()
 198 {
 199   churn_ctx.next_task = &churn_peers_on;
 200   GNUNET_TESTING_daemons_churn (pg, NULL, 2, 0, TIMEOUT, &churn_callback, NULL);
 201 }
 202
 203 static void
 204 peers_started_callback (void *cls, const struct GNUNET_PeerIdentity *id,
 205                         const struct GNUNET_CONFIGURATION_Handle *cfg,
 206                         struct GNUNET_TESTING_Daemon *d, const char *emsg)
 207 {
 208   if (emsg != NULL)
 209   {
 210     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 211                 "Failed to start daemon with error: `%s'\n", emsg);
 212     return;
 213   }
 214   GNUNET_assert (id != NULL);
 215 #if VERBOSE
 216   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started daemon %llu out of %llu\n",
 217               (num_peers - peers_left) + 1, num_peers);
 218 #endif
 219   peers_left--;
 220   if (peers_left == 0)
 221   {
 222 #if VERBOSE
 223     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 224                 "All %d daemons started, now testing churn!\n", num_peers);
 225 #endif
 226     GNUNET_SCHEDULER_cancel (die_task);
 227     /* Set up task in case topology creation doesn't finish
 228      * within a reasonable amount of time */
 229     die_task =
 230         GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
 231                                       (GNUNET_TIME_UNIT_MINUTES, 5), &end_badly,
 232                                       "from peers_started_callback");
 233     churn_peers_off ();
 234     ok = 0;
 235   }
 236 }
 237
 238
 239 static void
 240 run (void *cls, char *const *args, const char *cfgfile,
 241      const struct GNUNET_CONFIGURATION_Handle *cfg)
 242 {
 243   ok = 1;
 244
 245 #if VERBOSE
 246   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 247               "Starting daemons based on config file %s\n", cfgfile);
 248 #endif
 249
 250   if (GNUNET_YES !=
 251       GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome",
 252                                              &test_directory))
 253   {
 254     ok = 404;
 255     return;
 256   }
 257
 258   if (GNUNET_SYSERR ==
 259       GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
 260                                              &num_peers))
 261     num_peers = DEFAULT_NUM_PEERS;
 262
 263   main_cfg = cfg;
 264
 265   peers_left = num_peers;
 266   GNUNET_assert (num_peers > 0 && num_peers < (unsigned int) -1);
 267
 268   /* For this specific test we only really want a CLIQUE topology as the
 269    * overlay allowed topology, and a RING topology as the underlying connection
 270    * allowed topology.  So we will expect only num_peers * 2 connections to
 271    * work, and (num_peers * (num_peers - 1)) - (num_peers * 2) to fail.
 272    */
 273   expected_connections = num_peers * (num_peers - 1);
 274   expected_failed_connections = expected_connections - (num_peers * 2);
 275
 276
 277   /* Set up a task to end testing if peer start fails */
 278   die_task =
 279       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
 280                                     (GNUNET_TIME_UNIT_MINUTES, 5), &end_badly,
 281                                     "didn't start all daemons in reasonable amount of time!!!");
 282
 283   pg = GNUNET_TESTING_daemons_start (cfg, peers_left, peers_left, peers_left,
 284                                      TIMEOUT, NULL, NULL,
 285                                      &peers_started_callback, NULL, NULL, NULL,
 286                                      NULL);
 287
 288 }
 289
 290 static int
 291 check ()
 292 {
 293   int ret;
 294
 295   char *const argv[] = { "test-testing-topology-churn",
 296     "-c",
 297     "test_testing_data_topology_churn.conf",
 298 #if VERBOSE
 299     "-L", "DEBUG",
 300 #endif
 301     NULL
 302   };
 303   struct GNUNET_GETOPT_CommandLineOption options[] = {
 304     GNUNET_GETOPT_OPTION_END
 305   };
 306   ret =
 307       GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
 308                           "test-testing-topology-churn", "nohelp", options,
 309                           &run, &ok);
 310   if (ret != GNUNET_OK)
 311   {
 312     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 313                 "`test-testing-topology-churn': Failed with error code %d\n",
 314                 ret);
 315   }
 316
 317   return ok;
 318 }
 319
 320 int
 321 main (int argc, char *argv[])
 322 {
 323   int ret;
 324
 325   GNUNET_log_setup ("test_testing_topology_churn",
 326 #if VERBOSE
 327                     "DEBUG",
 328 #else
 329                     "WARNING",
 330 #endif
 331                     NULL);
 332   ret = check ();
 333
 334   /**
 335    * Need to remove base directory, subdirectories taken care
 336    * of by the testing framework.
 337    */
 338   if (test_directory != NULL)
 339   {
 340     if (GNUNET_DISK_directory_remove (test_directory) != GNUNET_OK)
 341     {
 342       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 343                   "Failed to remove testing directory %s\n", test_directory);
 344     }
 345   }
 346
 347   return ret;
 348 }
 349
 350 /* end of test_testing_topology_churn.c */