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