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