src/hostlist/test_gnunet_daemon_hostlist_learning.c

   1 /*
   2      This file is part of GNUnet
   3      (C) 2009, 2010, 2011 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 hostlist/test_gnunet_daemon_hostlist.c
  22  * @brief test for gnunet_daemon_hostslist.c
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27 #include "gnunet_arm_service.h"
  28 #include "gnunet_core_service.h"
  29 #include "gnunet_transport_service.h"
  30 #include "gnunet_resolver_service.h"
  31 #include "gnunet_statistics_service.h"
  32
  33 #define VERBOSE GNUNET_NO
  34
  35 #define START_ARM GNUNET_YES
  36
  37 #define MAX_URL_LEN 1000
  38
  39 /**
  40  * How long until wait until testcases fails
  41  */
  42 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 180)
  43
  44 #define CHECK_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
  45
  46
  47 struct PeerContext
  48 {
  49   struct GNUNET_CONFIGURATION_Handle *cfg;
  50   struct GNUNET_TRANSPORT_Handle *th;
  51   struct GNUNET_MessageHeader *hello;
  52   struct GNUNET_CORE_Handle *core;
  53   struct GNUNET_STATISTICS_Handle *stats;
  54 #if START_ARM
  55   struct GNUNET_OS_Process *arm_proc;
  56 #endif
  57 };
  58
  59 static int timeout;
  60
  61 static int adv_sent;
  62
  63 static int adv_arrived;
  64
  65 static int learned_hostlist_saved;
  66
  67 static int learned_hostlist_downloaded;
  68
  69 static char *current_adv_uri;
  70
  71 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  72
  73 static GNUNET_SCHEDULER_TaskIdentifier timeout_task;
  74
  75 static GNUNET_SCHEDULER_TaskIdentifier check_task;
  76
  77 static struct PeerContext adv_peer;
  78
  79 static struct PeerContext learn_peer;
  80
  81 static struct GNUNET_STATISTICS_GetHandle *download_stats;
  82
  83 static struct GNUNET_STATISTICS_GetHandle *urisrecv_stat;
  84
  85 static struct GNUNET_STATISTICS_GetHandle *advsent_stat;
  86
  87
  88 static void
  89 shutdown_testcase ()
  90 {
  91   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown testcase....\n");
  92   if (timeout_task != GNUNET_SCHEDULER_NO_TASK)
  93   {
  94     GNUNET_SCHEDULER_cancel (timeout_task);
  95     timeout_task = GNUNET_SCHEDULER_NO_TASK;
  96   }
  97   if (NULL != download_stats)
  98   {
  99     GNUNET_STATISTICS_get_cancel (download_stats);
 100     download_stats = NULL;
 101   }
 102   if (NULL != urisrecv_stat)
 103   {
 104     GNUNET_STATISTICS_get_cancel (urisrecv_stat);
 105     urisrecv_stat = NULL;
 106   }
 107   if (NULL != advsent_stat)
 108   {
 109     GNUNET_STATISTICS_get_cancel (advsent_stat);
 110     advsent_stat = NULL;
 111   }
 112   if (NULL != adv_peer.stats)
 113   {
 114     GNUNET_STATISTICS_destroy (adv_peer.stats);
 115     adv_peer.stats = NULL;
 116   }
 117   if (NULL != learn_peer.stats)
 118   {
 119     GNUNET_STATISTICS_destroy (learn_peer.stats);
 120     learn_peer.stats = NULL;
 121   }
 122   if (check_task != GNUNET_SCHEDULER_NO_TASK)
 123   {
 124     GNUNET_SCHEDULER_cancel (check_task);
 125     check_task = GNUNET_SCHEDULER_NO_TASK;
 126   }
 127   if (NULL != current_adv_uri)
 128   {
 129     GNUNET_free (current_adv_uri);
 130     current_adv_uri = NULL;
 131   }
 132   if (adv_peer.th != NULL)
 133   {
 134     GNUNET_TRANSPORT_disconnect (adv_peer.th);
 135     adv_peer.th = NULL;
 136   }
 137   if (learn_peer.th != NULL)
 138   {
 139     GNUNET_TRANSPORT_disconnect (learn_peer.th);
 140     learn_peer.th = NULL;
 141   }
 142   if (adv_peer.core != NULL)
 143   {
 144     GNUNET_CORE_disconnect (adv_peer.core);
 145     adv_peer.core = NULL;
 146   }
 147   if (learn_peer.core != NULL)
 148   {
 149     GNUNET_CORE_disconnect (learn_peer.core);
 150     learn_peer.core = NULL;
 151   }
 152 #if START_ARM
 153   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 154               "Killing hostlist server ARM process.\n");
 155   if (0 != GNUNET_OS_process_kill (adv_peer.arm_proc, SIGTERM))
 156     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
 157   if (GNUNET_OS_process_wait (adv_peer.arm_proc) != GNUNET_OK)
 158     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
 159   GNUNET_OS_process_close (adv_peer.arm_proc);
 160   adv_peer.arm_proc = NULL;
 161   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 162               "Killing hostlist client ARM process.\n");
 163   if (0 != GNUNET_OS_process_kill (learn_peer.arm_proc, SIGTERM))
 164     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
 165   if (GNUNET_OS_process_wait (learn_peer.arm_proc) != GNUNET_OK)
 166     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
 167   GNUNET_OS_process_close (learn_peer.arm_proc);
 168   learn_peer.arm_proc = NULL;
 169 #endif
 170   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown complete....\n");
 171 }
 172
 173 /**
 174  * Timeout, give up.
 175  */
 176 static void
 177 timeout_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 178 {
 179   timeout_task = GNUNET_SCHEDULER_NO_TASK;
 180   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 181               "Timeout while executing testcase, test failed.\n");
 182   timeout = GNUNET_YES;
 183   shutdown_testcase ();
 184 }
 185
 186
 187 static void
 188 process_downloads_done (void *cls, int success)
 189 {
 190   download_stats = NULL;
 191 }
 192
 193
 194 static int
 195 process_downloads (void *cls, const char *subsystem, const char *name,
 196                    uint64_t value, int is_persistent)
 197 {
 198   if ((value >= 2) && (learned_hostlist_downloaded == GNUNET_NO))
 199   {
 200     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 201                 "Peer has successfully downloaded advertised URI\n");
 202     learned_hostlist_downloaded = GNUNET_YES;
 203     if ((learned_hostlist_saved == GNUNET_YES) && (adv_sent == GNUNET_YES))
 204       shutdown_testcase ();
 205   }
 206   return GNUNET_OK;
 207 }
 208
 209
 210 static void
 211 process_uris_recv_done (void *cls, int success)
 212 {
 213   urisrecv_stat = NULL;
 214 }
 215
 216
 217 static int
 218 process_uris_recv (void *cls, const char *subsystem, const char *name,
 219                    uint64_t value, int is_persistent)
 220 {
 221   if (((struct PeerContext *) cls == &learn_peer) && (value == 1) &&
 222       (learned_hostlist_saved == GNUNET_NO))
 223   {
 224     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 225                 "Peer has successfully saved advertised URI\n");
 226     learned_hostlist_saved = GNUNET_YES;
 227     if ((learned_hostlist_downloaded == GNUNET_YES) && (adv_sent == GNUNET_YES))
 228       shutdown_testcase ();
 229   }
 230   return GNUNET_OK;
 231 }
 232
 233
 234 static void
 235 process_adv_sent_done (void *cls, int success)
 236 {
 237   advsent_stat = NULL;
 238 }
 239
 240
 241 static int
 242 process_adv_sent (void *cls, const char *subsystem, const char *name,
 243                   uint64_t value, int is_persistent)
 244 {
 245   if ((value >= 1) && (adv_sent == GNUNET_NO))
 246   {
 247     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 248                 "Server has successfully sent advertisement\n");
 249     adv_sent = GNUNET_YES;
 250     if ((learned_hostlist_downloaded == GNUNET_YES) &&
 251         (learned_hostlist_saved == GNUNET_YES))
 252       shutdown_testcase ();
 253   }
 254   return GNUNET_OK;
 255 }
 256
 257
 258 /**
 259  * Check the server statistics regularly
 260  */
 261 static void
 262 check_statistics (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 263 {
 264   char *stat;
 265
 266   check_task = GNUNET_SCHEDULER_NO_TASK;
 267   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 268     return;
 269   GNUNET_asprintf (&stat, gettext_noop ("# advertised URI `%s' downloaded"),
 270                    current_adv_uri);
 271   if (NULL != learn_peer.stats)
 272   {
 273     if (NULL != download_stats)
 274       GNUNET_STATISTICS_get_cancel (download_stats);
 275     download_stats =
 276         GNUNET_STATISTICS_get (learn_peer.stats, "hostlist", stat,
 277                                GNUNET_TIME_UNIT_MINUTES,
 278                                &process_downloads_done, &process_downloads,
 279                                &learn_peer);
 280     if (NULL != urisrecv_stat)
 281       GNUNET_STATISTICS_get_cancel (urisrecv_stat);
 282     urisrecv_stat =
 283         GNUNET_STATISTICS_get (learn_peer.stats, "hostlist",
 284                                gettext_noop ("# advertised hostlist URIs"),
 285                                GNUNET_TIME_UNIT_MINUTES,
 286                                &process_uris_recv_done, &process_uris_recv,
 287                                &learn_peer);
 288   }
 289   GNUNET_free (stat);
 290   if (NULL != adv_peer.stats)
 291   {
 292     if (NULL != advsent_stat)
 293       GNUNET_STATISTICS_get_cancel (advsent_stat);
 294     advsent_stat =
 295         GNUNET_STATISTICS_get (adv_peer.stats, "hostlist",
 296                                gettext_noop ("# hostlist advertisements send"),
 297                                GNUNET_TIME_UNIT_MINUTES, &process_adv_sent_done,
 298                                &process_adv_sent, NULL);
 299   }
 300   check_task =
 301       GNUNET_SCHEDULER_add_delayed (CHECK_INTERVALL, &check_statistics, NULL);
 302 }
 303
 304
 305 /**
 306  * Core handler for p2p hostlist advertisements
 307  */
 308 static int
 309 ad_arrive_handler (void *cls, const struct GNUNET_PeerIdentity *peer,
 310                    const struct GNUNET_MessageHeader *message,
 311                    const struct GNUNET_ATS_Information *atsi,
 312                    unsigned int atsi_count)
 313 {
 314   char *hostname;
 315   char *expected_uri;
 316   unsigned long long port;
 317   const struct GNUNET_MessageHeader *incoming;
 318   const char *end;
 319
 320   if (-1 ==
 321       GNUNET_CONFIGURATION_get_value_number (adv_peer.cfg, "HOSTLIST",
 322                                              "HTTPPORT", &port))
 323   {
 324     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 325                 "Could not read advertising server's configuration\n");
 326     return GNUNET_SYSERR;
 327   }
 328
 329   if (GNUNET_SYSERR ==
 330       GNUNET_CONFIGURATION_get_value_string (adv_peer.cfg, "HOSTLIST",
 331                                              "EXTERNAL_DNS_NAME", &hostname))
 332     hostname = GNUNET_RESOLVER_local_fqdn_get ();
 333   GNUNET_asprintf (&expected_uri, "http://%s:%u/",
 334                    hostname != NULL ? hostname : "localhost",
 335                    (unsigned int) port);
 336   incoming = (const struct GNUNET_MessageHeader *) message;
 337   end = (const char *) &incoming[1];
 338   if ('\0' !=
 339       end[ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) - 1])
 340   {
 341     GNUNET_break (0);
 342     GNUNET_free (expected_uri);
 343     GNUNET_free_non_null (hostname);
 344     return GNUNET_SYSERR;
 345   }
 346   current_adv_uri = GNUNET_strdup (end);
 347   if (0 == strcmp (expected_uri, current_adv_uri))
 348   {
 349     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 350                 "Received hostlist advertisement with URI `%s' as expected\n",
 351                 current_adv_uri);
 352     adv_arrived = GNUNET_YES;
 353     adv_sent = GNUNET_YES;
 354   }
 355   else
 356     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 357                 "Expected URI `%s' and recieved URI `%s' differ\n",
 358                 expected_uri, current_adv_uri);
 359   GNUNET_free (expected_uri);
 360   GNUNET_free_non_null (hostname);
 361   return GNUNET_OK;
 362 }
 363
 364
 365 /**
 366  * List of handlers if we are learning.
 367  */
 368 static struct GNUNET_CORE_MessageHandler learn_handlers[] = {
 369   {&ad_arrive_handler, GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, 0},
 370   {NULL, 0, 0}
 371 };
 372
 373
 374 static void
 375 setup_learn_peer (struct PeerContext *p, const char *cfgname)
 376 {
 377   char *filename;
 378   unsigned int result;
 379
 380   p->cfg = GNUNET_CONFIGURATION_create ();
 381 #if START_ARM
 382   p->arm_proc =
 383     GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
 384                                "gnunet-service-arm",
 385 #if VERBOSE
 386                                "-L", "DEBUG",
 387 #endif
 388                                "-c", cfgname, NULL);
 389 #endif
 390   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 391   if (GNUNET_OK ==
 392       GNUNET_CONFIGURATION_get_value_string (p->cfg, "HOSTLIST", "HOSTLISTFILE",
 393                                              &filename))
 394   {
 395     if (GNUNET_YES == GNUNET_DISK_file_test (filename))
 396     {
 397       result = UNLINK (filename);
 398       if (result == 0)
 399         GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 400                     _("Hostlist file `%s' was removed\n"), filename);
 401     }
 402     GNUNET_free (filename);
 403   }
 404   p->core =
 405       GNUNET_CORE_connect (p->cfg, 1, NULL, NULL, NULL, NULL, NULL, GNUNET_NO,
 406                            NULL, GNUNET_NO, learn_handlers);
 407   GNUNET_assert (NULL != p->core);
 408   p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
 409   GNUNET_assert (NULL != p->stats);
 410 }
 411
 412
 413 static void
 414 setup_adv_peer (struct PeerContext *p, const char *cfgname)
 415 {
 416   p->cfg = GNUNET_CONFIGURATION_create ();
 417 #if START_ARM
 418   p->arm_proc =
 419     GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
 420                                "gnunet-service-arm",
 421 #if VERBOSE
 422                                "-L", "DEBUG",
 423 #endif
 424                                "-c", cfgname, NULL);
 425 #endif
 426   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 427   p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
 428   GNUNET_assert (NULL != p->stats);
 429 }
 430
 431
 432 static void
 433 run (void *cls, char *const *args, const char *cfgfile,
 434      const struct GNUNET_CONFIGURATION_Handle *c)
 435 {
 436   timeout = GNUNET_NO;
 437   adv_sent = GNUNET_NO;
 438
 439   adv_arrived = 0;
 440   learned_hostlist_saved = GNUNET_NO;
 441   learned_hostlist_downloaded = GNUNET_NO;
 442
 443   cfg = c;
 444
 445   setup_adv_peer (&adv_peer, "test_learning_adv_peer.conf");
 446   setup_learn_peer (&learn_peer, "test_learning_learn_peer.conf");
 447   timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_error, NULL);
 448
 449   check_task =
 450       GNUNET_SCHEDULER_add_delayed (CHECK_INTERVALL, &check_statistics, NULL);
 451 }
 452
 453
 454 static int
 455 check ()
 456 {
 457   unsigned int failed;
 458
 459   char *const argv[] = {
 460     "test-gnunet-daemon-hostlist-learning",
 461     "-c", "learning_data.conf",
 462 #if VERBOSE
 463     "-L", "DEBUG",
 464 #endif
 465     NULL
 466   };
 467   struct GNUNET_GETOPT_CommandLineOption options[] = {
 468     GNUNET_GETOPT_OPTION_END
 469   };
 470
 471   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
 472                       "test-gnunet-daemon-hostlist-learning", "nohelp", options,
 473                       &run, NULL);
 474   failed = GNUNET_NO;
 475   if (timeout == GNUNET_YES)
 476   {
 477     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Testcase timeout\n");
 478     failed = GNUNET_YES;
 479   }
 480   if (adv_arrived != GNUNET_YES)
 481   {
 482     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 483                 "Learning peer did not receive advertisement from server\n");
 484     failed = GNUNET_YES;
 485   }
 486   if (learned_hostlist_saved == GNUNET_NO)
 487   {
 488     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 489                 "Advertised hostlist was not saved in datastore\n");
 490     failed = GNUNET_YES;
 491   }
 492   if (learned_hostlist_downloaded == GNUNET_NO)
 493   {
 494     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 495                 "Advertised hostlist could not be downloaded from server\n");
 496     failed = GNUNET_YES;
 497   }
 498   if (adv_sent == GNUNET_NO)
 499   {
 500     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 501                 "Advertised was not sent from server to client\n");
 502     failed = GNUNET_YES;
 503   }
 504   if (GNUNET_YES == failed)
 505     return GNUNET_YES;
 506   return GNUNET_NO;
 507 }
 508
 509
 510 int
 511 main (int argc, char *argv[])
 512 {
 513   int ret;
 514
 515   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
 516   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");
 517   GNUNET_log_setup ("test-gnunet-daemon-hostlist",
 518 #if VERBOSE
 519                     "DEBUG",
 520 #else
 521                     "WARNING",
 522 #endif
 523                     NULL);
 524 #if !WINDOWS
 525   system ("gnunet-peerinfo -s -c test_learning_adv_peer.conf > /dev/null");
 526   system ("gnunet-peerinfo -s -c test_learning_learn_peer.conf > /dev/null");
 527 #else
 528   system ("gnunet-peerinfo -s -c test_learning_adv_peer.conf > NUL");
 529   system ("gnunet-peerinfo -s -c test_learning_learn_peer.conf > NUL");
 530 #endif
 531   ret = check ();
 532   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
 533   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");
 534   if (GNUNET_YES == GNUNET_DISK_file_test ("hostlists_learn_peer.file"))
 535   {
 536     if (0 == UNLINK ("hostlists_learn_peer.file"))
 537       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 538                   "Hostlist file hostlists_learn_peer.file was removed\n");
 539   }
 540   return ret;
 541 }
 542
 543 /* end of test_gnunet_daemon_hostlist.c */