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 unsigned long long num_peers;
  48
  49
  50 /**
  51  * Check whether peers successfully shut down.
  52  */
  53 void
  54 shutdown_callback (void *cls, const char *emsg)
  55 {
  56   if (emsg != NULL)
  57     {
  58 #if VERBOSE
  59       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown of peers failed!\n");
  60 #endif
  61       if (ok == 0)
  62         ok = 666;
  63     }
  64   else
  65     {
  66 #if VERBOSE
  67       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  68                   "All peers successfully shut down!\n");
  69 #endif
  70     }
  71 }
  72
  73
  74 static void
  75 my_cb (void *cls,
  76        const struct GNUNET_PeerIdentity *id,
  77        const struct GNUNET_CONFIGURATION_Handle *cfg,
  78        struct GNUNET_TESTING_Daemon *d, const char *emsg)
  79 {
  80   if (emsg != NULL)
  81     {
  82       peers_failed++;
  83     }
  84
  85   peers_left--;
  86   if (peers_left == 0)
  87     {
  88       GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
  89       ok = 0;
  90     }
  91   else if (peers_failed == peers_left)
  92     {
  93       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  94                   "Too many peers failed, ending test!\n");
  95       GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
  96     }
  97 }
  98
  99
 100 static void
 101 run (void *cls,
 102      char *const *args,
 103      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 104 {
 105   struct GNUNET_TESTING_Host *hosts;
 106   struct GNUNET_TESTING_Host *hostpos;
 107   struct GNUNET_TESTING_Host *temphost;
 108   char *hostfile;
 109   struct stat frstat;
 110   char *buf;
 111   char *data;
 112   int count;
 113   int ret;
 114   ok = 1;
 115 #if VERBOSE
 116   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemons.\n");
 117 #endif
 118
 119   if (GNUNET_SYSERR ==
 120       GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
 121                                              &num_peers))
 122     num_peers = DEFAULT_NUM_PEERS;
 123
 124   GNUNET_assert (num_peers > 0 && num_peers < (unsigned long long) -1);
 125   if (GNUNET_OK !=
 126       GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "hostfile",
 127                                              &hostfile))
 128     hostfile = NULL;
 129
 130   hosts = NULL;
 131   data = NULL;
 132   if (hostfile != NULL)
 133     {
 134       if (GNUNET_OK != GNUNET_DISK_file_test (hostfile))
 135         GNUNET_DISK_fn_write (hostfile, NULL, 0, GNUNET_DISK_PERM_USER_READ
 136                               | GNUNET_DISK_PERM_USER_WRITE);
 137       if ((0 != STAT (hostfile, &frstat)) || (frstat.st_size == 0))
 138         {
 139           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 140                       "Could not open file specified for host list, ending test!");
 141           ok = 1119;
 142           GNUNET_free (hostfile);
 143           return;
 144         }
 145
 146       data = GNUNET_malloc_large (frstat.st_size);
 147       GNUNET_assert (data != NULL);
 148       if (frstat.st_size !=
 149           GNUNET_DISK_fn_read (hostfile, data, frstat.st_size))
 150         {
 151           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 152                       "Could not read file %s specified for host list, ending test!",
 153                       hostfile);
 154           GNUNET_free (hostfile);
 155           GNUNET_free (data);
 156           return;
 157         }
 158
 159       GNUNET_free_non_null (hostfile);
 160
 161       buf = data;
 162       count = 0;
 163       while (count < frstat.st_size)
 164         {
 165           count++;
 166           if (count >= frstat.st_size)
 167             break;
 168
 169           /* if (((data[count] == '\n') || (data[count] == '\0')) && (buf != &data[count])) */
 170           if (((data[count] == '\n')) && (buf != &data[count]))
 171             {
 172               data[count] = '\0';
 173               temphost = GNUNET_malloc (sizeof (struct GNUNET_TESTING_Host));
 174               ret =
 175                 sscanf (buf, "%a[a-zA-Z0-9]@%a[a-zA-Z0-9.]:%hd",
 176                         &temphost->username, &temphost->hostname,
 177                         &temphost->port);
 178               if (3 == ret)
 179                 {
 180                   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 181                               "Successfully read host %s, port %d and user %s from file\n",
 182                               temphost->hostname, temphost->port,
 183                               temphost->username);
 184                 }
 185               else
 186                 {
 187                   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 188                               "Error reading line `%s' in hostfile\n", buf);
 189                   GNUNET_free (temphost);
 190                   buf = &data[count + 1];
 191                   continue;
 192                 }
 193               /* temphost->hostname = buf; */
 194               temphost->next = hosts;
 195               hosts = temphost;
 196               buf = &data[count + 1];
 197             }
 198           else if ((data[count] == '\n') || (data[count] == '\0'))
 199             buf = &data[count + 1];
 200         }
 201     }
 202
 203   peers_left = num_peers;
 204   pg = GNUNET_TESTING_daemons_start (cfg,
 205                                      peers_left, /* Total number of peers */
 206                                      peers_left, /* Number of outstanding connections */
 207                                      peers_left, /* Number of parallel ssh connections, or peers being started at once */
 208                                      TIMEOUT,
 209                                      NULL,
 210                                      NULL, &my_cb, NULL, NULL, NULL, hosts);
 211   hostpos = hosts;
 212   while (hostpos != NULL)
 213     {
 214       temphost = hostpos->next;
 215       GNUNET_free (hostpos->hostname);
 216       GNUNET_free (hostpos->username);
 217       GNUNET_free (hostpos);
 218       hostpos = temphost;
 219     }
 220   GNUNET_free_non_null (data);
 221   GNUNET_assert (pg != NULL);
 222
 223 }
 224
 225 static int
 226 check ()
 227 {
 228   char *const argv[] = { "test-testing",
 229     "-c",
 230     "test_testing_data_remote.conf",
 231 #if VERBOSE
 232     "-L", "DEBUG",
 233 #endif
 234     NULL
 235   };
 236   struct GNUNET_GETOPT_CommandLineOption options[] = {
 237     GNUNET_GETOPT_OPTION_END
 238   };
 239   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
 240                       argv, "test-testing-group", "nohelp",
 241                       options, &run, &ok);
 242   return ok;
 243 }
 244
 245 int
 246 main (int argc, char *argv[])
 247 {
 248   int ret;
 249
 250   GNUNET_log_setup ("test-testing-group",
 251 #if VERBOSE
 252                     "DEBUG",
 253 #else
 254                     "WARNING",
 255 #endif
 256                     NULL);
 257   ret = check ();
 258   /**
 259    * Still need to remove the base testing directory here,
 260    * because group starts will create subdirectories under this
 261    * main dir.  However, we no longer need to sleep, as the
 262    * shutdown sequence won't return until everything is cleaned
 263    * up.
 264    */
 265   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
 266   return ret;
 267 }
 268
 269 /* end of test_testing_group.c */