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