src/testing/test_testing_group_remote.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 testing/test_testing_group_remote.c
  22  * @brief testcase for testing remote and local starting and connecting
  23  *        of hosts from the testing library.  The test_testing_data_remote.conf
  24  *        file should be modified if this testcase is intended to be used.
  25  */
  26 #include "platform.h"
  27 #include "gnunet_testing_lib.h"
  28
  29 #define VERBOSE GNUNET_YES
  30
  31
  32 /**
  33  * How long until we give up on connecting the peers?
  34  */
  35 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
  36
  37 #define DEFAULT_NUM_PEERS 8;
  38
  39 static int ok;
  40
  41 static int peers_left;
  42
  43 static int peers_failed;
  44
  45 static struct GNUNET_TESTING_PeerGroup *pg;
  46
  47 static struct GNUNET_SCHEDULER_Handle *sched;
  48
  49 static unsigned long long num_peers;
  50
  51
  52 /**
  53  * Check whether peers successfully shut down.
  54  */
  55 void shutdown_callback (void *cls,
  56                         const char *emsg)
  57 {
  58   if (emsg != NULL)
  59     {
  60 #if VERBOSE
  61       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  62                   "Shutdown of peers failed!\n");
  63 #endif
  64       if (ok == 0)
  65         ok = 666;
  66     }
  67   else
  68     {
  69 #if VERBOSE
  70       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  71                   "All peers successfully shut down!\n");
  72 #endif
  73     }
  74 }
  75
  76
  77 static void
  78 my_cb (void *cls,
  79        const struct GNUNET_PeerIdentity *id,
  80        const struct GNUNET_CONFIGURATION_Handle *cfg,
  81        struct GNUNET_TESTING_Daemon *d, const char *emsg)
  82 {
  83   if (emsg != NULL)
  84     {
  85       peers_failed++;
  86     }
  87
  88   peers_left--;
  89   if (peers_left == 0)
  90     {
  91       GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
  92       ok = 0;
  93     }
  94   else if (peers_failed == peers_left)
  95     {
  96       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Too many peers failed, ending test!\n");
  97       GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
  98     }
  99 }
 100
 101
 102 static void
 103 run (void *cls,
 104      struct GNUNET_SCHEDULER_Handle *s,
 105      char *const *args,
 106      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 107 {
 108   struct GNUNET_TESTING_Host *hosts;
 109   struct GNUNET_TESTING_Host *hostpos;
 110   struct GNUNET_TESTING_Host *temphost;
 111   char *hostfile;
 112   struct stat frstat;
 113   char *buf;
 114   char *data;
 115   int count;
 116   sched = s;
 117   ok = 1;
 118 #if VERBOSE
 119   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemons.\n");
 120 #endif
 121
 122   if (GNUNET_SYSERR ==
 123       GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
 124                                              &num_peers))
 125     num_peers = DEFAULT_NUM_PEERS;
 126
 127   GNUNET_assert(num_peers > 0 && num_peers < (unsigned long long)-1);
 128   if (GNUNET_OK !=
 129       GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "hostfile",
 130                                              &hostfile))
 131     hostfile = NULL;
 132
 133   hosts = NULL;
 134   data = NULL;
 135   if (hostfile != NULL)
 136     {
 137       if (GNUNET_OK != GNUNET_DISK_file_test (hostfile))
 138           GNUNET_DISK_fn_write (hostfile, NULL, 0, GNUNET_DISK_PERM_USER_READ
 139             | GNUNET_DISK_PERM_USER_WRITE);
 140       if ((0 != STAT (hostfile, &frstat)) || (frstat.st_size == 0))
 141         {
 142           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 143                       "Could not open file specified for host list, ending test!");
 144           ok = 1119;
 145           GNUNET_free(hostfile);
 146           return;
 147         }
 148
 149     data = GNUNET_malloc_large (frstat.st_size);
 150     GNUNET_assert(data != NULL);
 151     if (frstat.st_size !=
 152         GNUNET_DISK_fn_read (hostfile, data, frstat.st_size))
 153       {
 154         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 155                   "Could not read file %s specified for host list, ending test!", hostfile);
 156         GNUNET_free (hostfile);
 157         GNUNET_free (data);
 158         return;
 159       }
 160
 161     GNUNET_free_non_null(hostfile);
 162
 163     buf = data;
 164     count = 0;
 165     while (count < frstat.st_size)
 166       {
 167         count++;
 168         if (((data[count] == '\n') || (data[count] == '\0')) && (buf != &data[count]))
 169           {
 170             data[count] = '\0';
 171             temphost = GNUNET_malloc(sizeof(struct GNUNET_TESTING_Host));
 172             temphost->hostname = buf;
 173             temphost->next = hosts;
 174             hosts = temphost;
 175             buf = &data[count + 1];
 176           }
 177         else if ((data[count] == '\n') || (data[count] == '\0'))
 178           buf = &data[count + 1];
 179       }
 180     }
 181
 182   peers_left = num_peers;
 183   pg = GNUNET_TESTING_daemons_start (sched,
 184                                      cfg,
 185                                      peers_left,
 186                                      TIMEOUT,
 187                                      NULL,
 188                                      NULL,
 189                                      &my_cb,
 190                                      NULL,
 191                                      NULL,
 192                                      NULL,
 193                                      hosts);
 194   hostpos = hosts;
 195   while (hostpos != NULL)
 196     {
 197       temphost = hostpos->next;
 198       GNUNET_free(hostpos);
 199       hostpos = temphost;
 200     }
 201   GNUNET_free_non_null(data);
 202   GNUNET_assert (pg != NULL);
 203 }
 204
 205 static int
 206 check ()
 207 {
 208   char *const argv[] = { "test-testing",
 209     "-c",
 210     "test_testing_data_remote.conf",
 211 #if VERBOSE
 212     "-L", "DEBUG",
 213 #endif
 214     NULL
 215   };
 216   struct GNUNET_GETOPT_CommandLineOption options[] = {
 217     GNUNET_GETOPT_OPTION_END
 218   };
 219   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
 220                       argv, "test-testing-group", "nohelp",
 221                       options, &run, &ok);
 222   return ok;
 223 }
 224
 225 int
 226 main (int argc, char *argv[])
 227 {
 228   int ret;
 229
 230   GNUNET_log_setup ("test-testing-group",
 231 #if VERBOSE
 232                     "DEBUG",
 233 #else
 234                     "WARNING",
 235 #endif
 236                     NULL);
 237   ret = check ();
 238   /**
 239    * Still need to remove the base testing directory here,
 240    * because group starts will create subdirectories under this
 241    * main dir.  However, we no longer need to sleep, as the
 242    * shutdown sequence won't return until everything is cleaned
 243    * up.
 244    */
 245   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
 246   return ret;
 247 }
 248
 249 /* end of test_testing_group.c */