src/dht/test_dht_twopeer.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 dht/test_dht_twopeer.c
  22  * @brief base testcase for testing DHT service with
  23  *        two running peers
  24  */
  25 #include "platform.h"
  26 #include "gnunet_testing_lib.h"
  27 #include "gnunet_core_service.h"
  28 #include "gnunet_dht_service.h"
  29
  30 /* DEFINES */
  31 #define VERBOSE GNUNET_NO
  32
  33 #define MAX_GET_ATTEMPTS 10
  34
  35 #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5)
  36
  37 #define DEFAULT_NUM_PEERS 2
  38
  39 /* Structs */
  40
  41 struct PeerGetContext
  42 {
  43   struct GNUNET_PeerIdentity *peer;
  44
  45   struct GNUNET_DHT_Handle *dht_handle;
  46
  47   struct GNUNET_DHT_GetHandle *get_handle;
  48
  49   unsigned int get_attempts;
  50
  51   GNUNET_SCHEDULER_TaskIdentifier retry_task;
  52 };
  53
  54 /* Globals */
  55 static char *test_directory;
  56
  57 static struct PeerGetContext curr_get_ctx;
  58
  59 static unsigned int expected_connections;
  60
  61 static unsigned long long peers_left;
  62
  63 static struct GNUNET_TESTING_PeerGroup *pg;
  64
  65 static struct GNUNET_SCHEDULER_Handle *sched;
  66
  67 static unsigned long long num_peers;
  68
  69 static unsigned int total_gets;
  70
  71 static unsigned int gets_succeeded;
  72
  73 static unsigned int total_connections;
  74
  75 static unsigned int failed_connections;
  76
  77 GNUNET_SCHEDULER_TaskIdentifier die_task;
  78
  79 static int ok;
  80
  81 static struct GNUNET_PeerIdentity peer1id;
  82
  83 static struct GNUNET_PeerIdentity peer2id;
  84
  85 static struct GNUNET_DHT_Handle *peer1dht;
  86
  87 static struct GNUNET_DHT_Handle *peer2dht;
  88
  89 /**
  90  * Check whether peers successfully shut down.
  91  */
  92 void shutdown_callback (void *cls,
  93                         const char *emsg)
  94 {
  95   if (emsg != NULL)
  96     {
  97       if (ok == 0)
  98         ok = 2;
  99     }
 100 }
 101
 102 static void
 103 finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 104 {
 105   GNUNET_assert (pg != NULL);
 106   GNUNET_assert (peer1dht != NULL);
 107   GNUNET_assert (peer2dht != NULL);
 108   GNUNET_DHT_disconnect(peer1dht);
 109   GNUNET_DHT_disconnect(peer2dht);
 110   GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 111   ok = 0;
 112 }
 113
 114 static void
 115 end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 116 {
 117   if (peer1dht != NULL)
 118       GNUNET_DHT_disconnect(peer1dht);
 119
 120   if (peer2dht != NULL)
 121     GNUNET_DHT_disconnect(peer2dht);
 122
 123   if (pg != NULL)
 124     GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 125
 126   if (curr_get_ctx.retry_task != GNUNET_SCHEDULER_NO_TASK)
 127     GNUNET_SCHEDULER_cancel(sched, curr_get_ctx.retry_task);
 128 }
 129
 130 static void
 131 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 132 {
 133   if (curr_get_ctx.retry_task != GNUNET_SCHEDULER_NO_TASK)
 134     GNUNET_SCHEDULER_cancel(sched, curr_get_ctx.retry_task);
 135
 136   if (curr_get_ctx.get_handle != NULL)
 137   {
 138     GNUNET_DHT_get_stop(curr_get_ctx.get_handle);
 139     GNUNET_SCHEDULER_add_now (sched, &end_badly_cont, NULL);
 140   }
 141
 142   ok = 1;
 143 }
 144
 145 /* Forward declaration */
 146 static void
 147 do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc);
 148
 149 /**
 150  * Iterator called on each result obtained for a DHT
 151  * operation that expects a reply
 152  *
 153  * @param cls closure
 154  * @param exp when will this value expire
 155  * @param key key of the result
 156  * @param type type of the result
 157  * @param size number of bytes in data
 158  * @param data pointer to the result data
 159  */
 160 void get_result_iterator (void *cls,
 161                           struct GNUNET_TIME_Absolute exp,
 162                           const GNUNET_HashCode * key,
 163                           const struct GNUNET_PeerIdentity * const *get_path,
 164                           const struct GNUNET_PeerIdentity * const *put_path,
 165                           enum GNUNET_BLOCK_Type type,
 166                           size_t size,
 167                           const void *data)
 168 {
 169   struct PeerGetContext *get_context = cls;
 170
 171   if (0 != memcmp(&get_context->peer->hashPubKey, key, sizeof (GNUNET_HashCode)))
 172   {
 173     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Key returned is not the same key as was searched for!\n");
 174     GNUNET_SCHEDULER_cancel(sched, die_task);
 175     GNUNET_SCHEDULER_add_now(sched, &end_badly, "key mismatch in get response!\n");
 176     return;
 177   }
 178
 179   if (get_context->retry_task != GNUNET_SCHEDULER_NO_TASK)
 180     {
 181       GNUNET_SCHEDULER_cancel(sched, get_context->retry_task);
 182       get_context->retry_task = GNUNET_SCHEDULER_NO_TASK;
 183     }
 184
 185   if (get_context->peer == &peer2id)
 186   {
 187     get_context->peer = &peer1id;
 188     get_context->dht_handle = peer2dht;
 189     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received first correct GET request response!\n");
 190     GNUNET_DHT_get_stop(get_context->get_handle);
 191     GNUNET_SCHEDULER_add_now (sched, &do_get, get_context);
 192   }
 193   else
 194   {
 195     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received second correct GET request response!\n");
 196     GNUNET_SCHEDULER_cancel(sched, die_task);
 197     GNUNET_DHT_get_stop(get_context->get_handle);
 198     GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
 199   }
 200
 201 }
 202
 203 static void
 204 stop_retry_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc);
 205
 206 static void
 207 get_stop_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 208 {
 209   struct PeerGetContext *get_context = cls;
 210
 211   if (get_context->get_attempts < MAX_GET_ATTEMPTS)
 212     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Get attempt %u failed, retrying request!\n", get_context->get_attempts);
 213   else
 214     {
 215       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Too many attempts failed, ending test!\n", get_context->get_attempts);
 216       GNUNET_SCHEDULER_cancel(sched, die_task);
 217       GNUNET_SCHEDULER_add_now(sched, &end_badly, "key mismatch in get response!\n");
 218       return;
 219     }
 220   get_context->get_attempts++;
 221   get_context->retry_task = GNUNET_SCHEDULER_add_delayed(sched,
 222                                                          GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10),
 223                                                           &stop_retry_get, get_context);
 224   get_context->get_handle = GNUNET_DHT_get_start(get_context->dht_handle,
 225                                                  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5),
 226                                                  0 /* fixme: use real type */, &get_context->peer->hashPubKey,
 227                                                  GNUNET_DHT_RO_NONE,
 228                                                  NULL, 0,
 229                                                  NULL, 0,
 230                                                  &get_result_iterator, get_context);
 231 }
 232
 233 static void
 234 stop_retry_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 235 {
 236   struct PeerGetContext *get_context = cls;
 237   get_context->retry_task = GNUNET_SCHEDULER_NO_TASK;
 238   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Get attempt %u failed, canceling request!\n", get_context->get_attempts);
 239   GNUNET_DHT_get_stop(get_context->get_handle);
 240   GNUNET_SCHEDULER_add_now(sched, &get_stop_finished, get_context);
 241 }
 242
 243 static void
 244 do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 245 {
 246   struct PeerGetContext *get_context = cls;
 247
 248   get_context->retry_task = GNUNET_SCHEDULER_add_delayed(sched,
 249                                                          GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10),
 250                                                           &stop_retry_get, get_context);
 251
 252   get_context->get_handle = GNUNET_DHT_get_start(get_context->dht_handle,
 253                                                  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5),
 254                                                  GNUNET_BLOCK_TYPE_DHT_HELLO,
 255                                                  &get_context->peer->hashPubKey,
 256                                                  GNUNET_DHT_RO_NONE,
 257                                                  NULL, 0,
 258                                                  NULL, 0,
 259                                                  &get_result_iterator, get_context);
 260 }
 261
 262
 263 void
 264 topology_callback (void *cls,
 265                    const struct GNUNET_PeerIdentity *first,
 266                    const struct GNUNET_PeerIdentity *second,
 267                    uint32_t distance,
 268                    const struct GNUNET_CONFIGURATION_Handle *first_cfg,
 269                    const struct GNUNET_CONFIGURATION_Handle *second_cfg,
 270                    struct GNUNET_TESTING_Daemon *first_daemon,
 271                    struct GNUNET_TESTING_Daemon *second_daemon,
 272                    const char *emsg)
 273 {
 274   if (emsg == NULL)
 275     {
 276       total_connections++;
 277 #if VERBOSE
 278       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "connected peer %s to peer %s, distance %u\n",
 279                  first_daemon->shortname,
 280                  second_daemon->shortname,
 281                  distance);
 282 #endif
 283     }
 284 #if VERBOSE
 285   else
 286     {
 287       failed_connections++;
 288       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to connect peer %s to peer %s with error :\n%s\n",
 289                   first_daemon->shortname,
 290                   second_daemon->shortname, emsg);
 291     }
 292 #endif
 293
 294   if (total_connections == expected_connections)
 295     {
 296 #if VERBOSE
 297       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 298                   "Created %d total connections, which is our target number!  Starting next phase of testing.\n",
 299                   total_connections);
 300 #endif
 301       GNUNET_SCHEDULER_cancel (sched, die_task);
 302       die_task = GNUNET_SCHEDULER_add_delayed (sched, TIMEOUT,
 303                                                &end_badly, "from test gets");
 304
 305       curr_get_ctx.dht_handle = peer1dht;
 306       curr_get_ctx.peer = &peer2id;
 307       //GNUNET_SCHEDULER_add_now (sched, &do_get, &curr_get_ctx);
 308       GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &do_get, &curr_get_ctx);
 309     }
 310   else if (total_connections + failed_connections == expected_connections)
 311     {
 312       GNUNET_SCHEDULER_cancel (sched, die_task);
 313       die_task = GNUNET_SCHEDULER_add_now (sched,
 314                                            &end_badly, "from topology_callback (too many failed connections)");
 315     }
 316 }
 317
 318 static void
 319 connect_topology (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 320 {
 321   expected_connections = -1;
 322   if ((pg != NULL) && (peers_left == 0))
 323     expected_connections = GNUNET_TESTING_connect_topology (pg, GNUNET_TESTING_TOPOLOGY_CLIQUE, GNUNET_TESTING_TOPOLOGY_OPTION_ALL, 0.0, NULL, NULL);
 324
 325   GNUNET_SCHEDULER_cancel (sched, die_task);
 326   if (expected_connections == GNUNET_SYSERR)
 327     die_task = GNUNET_SCHEDULER_add_now (sched,
 328                                          &end_badly, "from connect topology (bad return)");
 329
 330
 331   die_task = GNUNET_SCHEDULER_add_delayed (sched,
 332                                            TIMEOUT,
 333                                            &end_badly, "from connect topology (timeout)");
 334 }
 335
 336 static void
 337 peers_started_callback (void *cls,
 338        const struct GNUNET_PeerIdentity *id,
 339        const struct GNUNET_CONFIGURATION_Handle *cfg,
 340        struct GNUNET_TESTING_Daemon *d, const char *emsg)
 341 {
 342   if (emsg != NULL)
 343     {
 344       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failed to start daemon with error: `%s'\n",
 345                   emsg);
 346       return;
 347     }
 348   GNUNET_assert (id != NULL);
 349   if (peers_left == num_peers)
 350   {
 351     memcpy(&peer1id, id, sizeof(struct GNUNET_PeerIdentity));
 352     peer1dht = GNUNET_DHT_connect(sched, cfg, 100);
 353     if (peer1dht == NULL)
 354     {
 355       GNUNET_SCHEDULER_cancel (sched, die_task);
 356       GNUNET_SCHEDULER_add_now(sched, &end_badly, "Failed to get dht handle!\n");
 357     }
 358   }
 359   else
 360   {
 361     memcpy(&peer2id, id, sizeof(struct GNUNET_PeerIdentity));
 362     peer2dht = GNUNET_DHT_connect(sched, cfg, 100);
 363     if (peer2dht == NULL)
 364     {
 365       GNUNET_SCHEDULER_cancel (sched, die_task);
 366       GNUNET_SCHEDULER_add_now(sched, &end_badly, "Failed to get dht handle!\n");
 367     }
 368   }
 369
 370
 371   peers_left--;
 372
 373   if (peers_left == 0)
 374     {
 375 #if VERBOSE
 376       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 377                   "All %d daemons started, now connecting peers!\n",
 378                   num_peers);
 379 #endif
 380       GNUNET_SCHEDULER_cancel (sched, die_task);
 381       /* Set up task in case topology creation doesn't finish
 382        * within a reasonable amount of time */
 383       die_task = GNUNET_SCHEDULER_add_delayed (sched,
 384                                                TIMEOUT,
 385                                                &end_badly, "from peers_started_callback");
 386
 387       GNUNET_SCHEDULER_add_now(sched, &connect_topology, NULL);
 388       ok = 0;
 389     }
 390 }
 391
 392 static void
 393 run (void *cls,
 394      struct GNUNET_SCHEDULER_Handle *s,
 395      char *const *args,
 396      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 397 {
 398   sched = s;
 399
 400   if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string(cfg, "paths", "servicehome", &test_directory))
 401     {
 402       ok = 404;
 403       return;
 404     }
 405
 406   if (GNUNET_SYSERR ==
 407       GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
 408                                              &num_peers))
 409     num_peers = DEFAULT_NUM_PEERS;
 410
 411   peers_left = num_peers;
 412   total_gets = num_peers;
 413   gets_succeeded = 0;
 414   /* Set up a task to end testing if peer start fails */
 415   die_task = GNUNET_SCHEDULER_add_delayed (sched,
 416                                            TIMEOUT,
 417                                            &end_badly, "didn't start all daemons in reasonable amount of time!!!");
 418
 419   pg = GNUNET_TESTING_daemons_start (sched, cfg,
 420                                      num_peers, TIMEOUT, NULL, NULL, &peers_started_callback, NULL,
 421                                      &topology_callback, NULL, NULL);
 422
 423 }
 424
 425 static int
 426 check ()
 427 {
 428   int ret;
 429   char *const argv[] = {"test-dht-twopeer",
 430     "-c",
 431     "test_dht_twopeer_data.conf",
 432 #if VERBOSE
 433     "-L", "DEBUG",
 434 #endif
 435     NULL
 436   };
 437   struct GNUNET_GETOPT_CommandLineOption options[] = {
 438     GNUNET_GETOPT_OPTION_END
 439   };
 440   ret = GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
 441                       argv, "test-dht-twopeer", "nohelp",
 442                       options, &run, &ok);
 443   if (ret != GNUNET_OK)
 444     {
 445       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "`test-dht-twopeer': Failed with error code %d\n", ret);
 446     }
 447   return ok;
 448 }
 449
 450 int
 451 main (int argc, char *argv[])
 452 {
 453   int ret;
 454
 455   GNUNET_log_setup ("test-dht-twopeer",
 456 #if VERBOSE
 457                     "DEBUG",
 458 #else
 459                     "WARNING",
 460 #endif
 461                     NULL);
 462   ret = check ();
 463   /**
 464    * Need to remove base directory, subdirectories taken care
 465    * of by the testing framework.
 466    */
 467   if (GNUNET_DISK_directory_remove (test_directory) != GNUNET_OK)
 468     {
 469       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to remove testing directory %s\n", test_directory);
 470     }
 471   return ret;
 472 }
 473
 474 /* end of test_dht_twopeer.c */