src/testbed/test_testbed_api_barriers.c

   1 /*
   2       This file is part of GNUnet
   3       Copyright (C) 2008--2013 GNUnet e.V.
   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., 51 Franklin Street, Fifth Floor,
  18       Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * @file testbed/test_testbed_api_barriers.c
  23  * @brief testcase binary for testing testbed barriers API
  24  * @author Sree Harsha Totakura <sreeharsha@totakura.in>
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_testbed_service.h"
  30 #include "test_testbed_api_barriers.h"
  31
  32
  33 /**
  34  * logging short hand
  35  */
  36 #define LOG(type,...) \
  37   GNUNET_log (type, __VA_ARGS__);
  38
  39 /**
  40  * Number of peers we start in this test case
  41  */
  42 #define NUM_PEERS 3
  43
  44
  45 /**
  46  * Our barrier
  47  */
  48 struct GNUNET_TESTBED_Barrier *barrier;
  49
  50 /**
  51  * Identifier for the shutdown task
  52  */
  53 static struct GNUNET_SCHEDULER_Task *shutdown_task;
  54
  55 /**
  56  * Result of this test case
  57  */
  58 static int result;
  59
  60
  61 /**
  62  * Shutdown this test case when it takes too long
  63  *
  64  * @param cls NULL
  65  */
  66 static void
  67 do_shutdown (void *cls)
  68 {
  69   shutdown_task = NULL;
  70   if (NULL != barrier)
  71   {
  72     GNUNET_TESTBED_barrier_cancel (barrier);
  73     barrier = NULL;
  74   }
  75
  76   GNUNET_SCHEDULER_shutdown ();
  77 }
  78
  79
  80 /**
  81  * Functions of this type are to be given as callback argument to
  82  * GNUNET_TESTBED_barrier_init().  The callback will be called when status
  83  * information is available for the barrier.
  84  *
  85  * @param cls the closure given to GNUNET_TESTBED_barrier_init()
  86  * @param name the name of the barrier
  87  * @param barrier the barrier handle
  88  * @param status status of the barrier; #GNUNET_OK if the barrier is crossed;
  89  *   #GNUNET_SYSERR upon error
  90  * @param emsg if the status were to be #GNUNET_SYSERR, this parameter has the
  91  *   error messsage
  92  */
  93 static void
  94 barrier_cb (void *cls,
  95             const char *name,
  96             struct GNUNET_TESTBED_Barrier *_barrier,
  97             enum GNUNET_TESTBED_BarrierStatus status,
  98             const char *emsg)
  99 {
 100   static enum GNUNET_TESTBED_BarrierStatus old_status;
 101
 102   GNUNET_assert (NULL == cls);
 103   GNUNET_assert (_barrier == barrier);
 104   switch (status)
 105   {
 106   case GNUNET_TESTBED_BARRIERSTATUS_INITIALISED:
 107     LOG (GNUNET_ERROR_TYPE_INFO,
 108          "Barrier initialised\n");
 109     old_status = status;
 110     return;
 111   case GNUNET_TESTBED_BARRIERSTATUS_ERROR:
 112     LOG (GNUNET_ERROR_TYPE_ERROR,
 113          "Barrier initialisation failed: %s",
 114          (NULL == emsg) ? "unknown reason" : emsg);
 115     barrier = NULL;
 116     GNUNET_SCHEDULER_shutdown ();
 117     return;
 118   case GNUNET_TESTBED_BARRIERSTATUS_CROSSED:
 119     LOG (GNUNET_ERROR_TYPE_INFO,
 120          "Barrier crossed\n");
 121     if (old_status == GNUNET_TESTBED_BARRIERSTATUS_INITIALISED)
 122       result = GNUNET_OK;
 123     barrier = NULL;
 124     GNUNET_SCHEDULER_shutdown ();
 125     return;
 126   default:
 127     GNUNET_assert (0);
 128   }
 129 }
 130
 131
 132 /**
 133  * Signature of a main function for a testcase.
 134  *
 135  * @param cls closure
 136  * @param h the run handle
 137  * @param num_peers number of peers in 'peers'
 138  * @param peers_ handle to peers run in the testbed
 139  * @param links_succeeded the number of overlay link connection attempts that
 140  *          succeeded
 141  * @param links_failed the number of overlay link connection attempts that
 142  *          failed
 143  */
 144 static void
 145 test_master (void *cls,
 146              struct GNUNET_TESTBED_RunHandle *h,
 147              unsigned int num_peers,
 148              struct GNUNET_TESTBED_Peer **peers_,
 149              unsigned int links_succeeded,
 150              unsigned int links_failed)
 151 {
 152   struct GNUNET_TESTBED_Controller *c;
 153
 154   GNUNET_assert (NULL == cls);
 155   if (NULL == peers_)
 156   {
 157     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 158                 "Failing test due to timeout\n");
 159     return;
 160   }
 161   GNUNET_assert (NUM_PEERS == num_peers);
 162   c = GNUNET_TESTBED_run_get_controller_handle (h);
 163   barrier = GNUNET_TESTBED_barrier_init (c,
 164                                          TEST_BARRIER_NAME,
 165                                          100,
 166                                          &barrier_cb,
 167                                          NULL);
 168   shutdown_task =
 169       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
 170                                     (GNUNET_TIME_UNIT_SECONDS,
 171                                      10 * (NUM_PEERS + 1)),
 172                                     &do_shutdown, NULL);
 173 }
 174
 175
 176 #ifndef PATH_MAX
 177 /**
 178  * Assumed maximum path length (for the log file name).
 179  */
 180 #define PATH_MAX 4096
 181 #endif
 182
 183
 184 /**
 185  * Main function
 186  */
 187 int
 188 main (int argc, char **argv)
 189 {
 190   struct GNUNET_CONFIGURATION_Handle *cfg;
 191   char pwd[PATH_MAX];
 192   char *binary;
 193   uint64_t event_mask;
 194
 195   result = GNUNET_SYSERR;
 196   event_mask = 0;
 197   cfg = GNUNET_CONFIGURATION_create ();
 198   GNUNET_assert (GNUNET_YES ==
 199                  GNUNET_CONFIGURATION_parse (cfg,
 200                                              "test_testbed_api_barriers.conf.in"));
 201   if (NULL == getcwd (pwd, PATH_MAX))
 202     return 1;
 203   GNUNET_assert (0 < GNUNET_asprintf (&binary, "%s/%s", pwd,
 204                                       "gnunet-service-test-barriers"));
 205   GNUNET_CONFIGURATION_set_value_string (cfg, "test-barriers","BINARY", binary);
 206   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_write
 207                  (cfg, "test_testbed_api_barriers.conf"));
 208   GNUNET_CONFIGURATION_destroy (cfg);
 209   cfg = NULL;
 210   GNUNET_free (binary);
 211   binary = NULL;
 212   (void) GNUNET_TESTBED_test_run ("test_testbed_api_barriers",
 213                                   "test_testbed_api_barriers.conf", NUM_PEERS,
 214                                   event_mask, NULL, NULL,
 215                                   &test_master, NULL);
 216   (void) unlink ("test_testbed_api_barriers.conf");
 217   if (GNUNET_OK != result)
 218     return 1;
 219   return 0;
 220 }