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_ATS_Information *atsi,
 302                    unsigned int atsi_count)
 303 {
 304   char *hostname;
 305   char *expected_uri;
 306   unsigned long long port;
 307   const struct GNUNET_MessageHeader *incoming;
 308   const char *end;
 309
 310   if (-1 ==
 311       GNUNET_CONFIGURATION_get_value_number (adv_peer.cfg, "HOSTLIST",
 312                                              "HTTPPORT", &port))
 313   {
 314     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 315                 "Could not read advertising server's configuration\n");
 316     return GNUNET_SYSERR;
 317   }
 318
 319   if (GNUNET_SYSERR ==
 320       GNUNET_CONFIGURATION_get_value_string (adv_peer.cfg, "HOSTLIST",
 321                                              "EXTERNAL_DNS_NAME", &hostname))
 322     hostname = GNUNET_RESOLVER_local_fqdn_get ();
 323   GNUNET_asprintf (&expected_uri, "http://%s:%u/",
 324                    hostname != NULL ? hostname : "localhost",
 325                    (unsigned int) port);
 326   incoming = (const struct GNUNET_MessageHeader *) message;
 327   end = (const char *) &incoming[1];
 328   if ('\0' !=
 329       end[ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) - 1])
 330   {
 331     GNUNET_break (0);
 332     GNUNET_free (expected_uri);
 333     GNUNET_free_non_null (hostname);
 334     return GNUNET_SYSERR;
 335   }
 336   current_adv_uri = GNUNET_strdup (end);
 337   if (0 == strcmp (expected_uri, current_adv_uri))
 338   {
 339     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 340                 "Received hostlist advertisement with URI `%s' as expected\n",
 341                 current_adv_uri);
 342     adv_arrived = GNUNET_YES;
 343     adv_sent = GNUNET_YES;
 344   }
 345   else
 346     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 347                 "Expected URI `%s' and recieved URI `%s' differ\n",
 348                 expected_uri, current_adv_uri);
 349   GNUNET_free (expected_uri);
 350   GNUNET_free_non_null (hostname);
 351   return GNUNET_OK;
 352 }
 353
 354
 355 /**
 356  * List of handlers if we are learning.
 357  */
 358 static struct GNUNET_CORE_MessageHandler learn_handlers[] = {
 359   {&ad_arrive_handler, GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, 0},
 360   {NULL, 0, 0}
 361 };
 362
 363
 364 static void
 365 setup_learn_peer (struct PeerContext *p, const char *cfgname)
 366 {
 367   char *filename;
 368   unsigned int result;
 369
 370   p->cfg = GNUNET_CONFIGURATION_create ();
 371 #if START_ARM
 372   p->arm_proc =
 373       GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
 374                                "gnunet-service-arm",
 375 #if VERBOSE
 376                                "-L", "DEBUG",
 377 #endif
 378                                "-c", cfgname, NULL);
 379 #endif
 380   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 381   if (GNUNET_OK ==
 382       GNUNET_CONFIGURATION_get_value_string (p->cfg, "HOSTLIST", "HOSTLISTFILE",
 383                                              &filename))
 384   {
 385     if (GNUNET_YES == GNUNET_DISK_file_test (filename))
 386     {
 387       result = UNLINK (filename);
 388       if (result == 0)
 389         GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 390                     _("Hostlist file `%s' was removed\n"), filename);
 391     }
 392     GNUNET_free (filename);
 393   }
 394   p->core =
 395       GNUNET_CORE_connect (p->cfg, 1, NULL, NULL, NULL, NULL, NULL, GNUNET_NO,
 396                            NULL, GNUNET_NO, learn_handlers);
 397   GNUNET_assert (NULL != p->core);
 398   p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
 399   GNUNET_assert (NULL != p->stats);
 400 }
 401
 402
 403 static void
 404 setup_adv_peer (struct PeerContext *p, const char *cfgname)
 405 {
 406   p->cfg = GNUNET_CONFIGURATION_create ();
 407 #if START_ARM
 408   p->arm_proc =
 409       GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
 410                                "gnunet-service-arm",
 411 #if VERBOSE
 412                                "-L", "DEBUG",
 413 #endif
 414                                "-c", cfgname, NULL);
 415 #endif
 416   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 417   p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
 418   GNUNET_assert (NULL != p->stats);
 419 }
 420
 421
 422 static void
 423 run (void *cls, char *const *args, const char *cfgfile,
 424      const struct GNUNET_CONFIGURATION_Handle *c)
 425 {
 426   timeout = GNUNET_NO;
 427   adv_sent = GNUNET_NO;
 428
 429   adv_arrived = 0;
 430   learned_hostlist_saved = GNUNET_NO;
 431   learned_hostlist_downloaded = GNUNET_NO;
 432
 433   cfg = c;
 434
 435   setup_adv_peer (&adv_peer, "test_learning_adv_peer.conf");
 436   setup_learn_peer (&learn_peer, "test_learning_learn_peer.conf");
 437   timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_error, NULL);
 438
 439   check_task =
 440       GNUNET_SCHEDULER_add_delayed (CHECK_INTERVALL, &check_statistics, NULL);
 441 }
 442
 443
 444 static int
 445 check ()
 446 {
 447   unsigned int failed;
 448
 449   char *const argv[] = {
 450     "test-gnunet-daemon-hostlist-learning",
 451     "-c", "learning_data.conf",
 452 #if VERBOSE
 453     "-L", "DEBUG",
 454 #endif
 455     NULL
 456   };
 457   struct GNUNET_GETOPT_CommandLineOption options[] = {
 458     GNUNET_GETOPT_OPTION_END
 459   };
 460
 461   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
 462                       "test-gnunet-daemon-hostlist-learning", "nohelp", options,
 463                       &run, NULL);
 464   failed = GNUNET_NO;
 465   if (timeout == GNUNET_YES)
 466   {
 467     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Testcase timeout\n");
 468     failed = GNUNET_YES;
 469   }
 470   if (adv_arrived != GNUNET_YES)
 471   {
 472     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 473                 "Learning peer did not receive advertisement from server\n");
 474     failed = GNUNET_YES;
 475   }
 476   if (learned_hostlist_saved == GNUNET_NO)
 477   {
 478     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 479                 "Advertised hostlist was not saved in datastore\n");
 480     failed = GNUNET_YES;
 481   }
 482   if (learned_hostlist_downloaded == GNUNET_NO)
 483   {
 484     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 485                 "Advertised hostlist could not be downloaded from server\n");
 486     failed = GNUNET_YES;
 487   }
 488   if (adv_sent == GNUNET_NO)
 489   {
 490     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 491                 "Advertised was not sent from server to client\n");
 492     failed = GNUNET_YES;
 493   }
 494   if (GNUNET_YES == failed)
 495     return GNUNET_YES;
 496   return GNUNET_NO;
 497 }
 498
 499
 500 int
 501 main (int argc, char *argv[])
 502 {
 503   int ret;
 504
 505   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
 506   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");
 507   GNUNET_log_setup ("test-gnunet-daemon-hostlist",
 508 #if VERBOSE
 509                     "DEBUG",
 510 #else
 511                     "WARNING",
 512 #endif
 513                     NULL);
 514 #if !WINDOWS
 515   system ("gnunet-peerinfo -s -c test_learning_adv_peer.conf > /dev/null");
 516   system ("gnunet-peerinfo -s -c test_learning_learn_peer.conf > /dev/null");
 517 #else
 518   system ("gnunet-peerinfo -s -c test_learning_adv_peer.conf > NUL");
 519   system ("gnunet-peerinfo -s -c test_learning_learn_peer.conf > NUL");
 520 #endif
 521   ret = check ();
 522   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
 523   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");
 524   if (GNUNET_YES == GNUNET_DISK_file_test ("hostlists_learn_peer.file"))
 525   {
 526     if (0 == UNLINK ("hostlists_learn_peer.file"))
 527       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 528                   "Hostlist file hostlists_learn_peer.file was removed\n");
 529   }
 530   return ret;
 531 }
 532
 533 /* end of test_gnunet_daemon_hostlist.c */