src/datastore/test_datastore_api_management.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2004, 2005, 2006, 2007, 2009, 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 datastore/test_datastore_api_management.c
  22  * @brief Test for the space management functions of the datastore implementation.
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27 #include "gnunet_protocols.h"
  28 #include "gnunet_datastore_service.h"
  29 #include "gnunet_testing_lib.h"
  30
  31
  32 /**
  33  * How long until we give up on transmitting the message?
  34  */
  35 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
  36
  37 /**
  38  * Number of iterations to run; must be large enough
  39  * so that the quota will be exceeded!
  40  */
  41 #define ITERATIONS 5000
  42
  43 enum RunPhase
  44 {
  45   RP_PUT,
  46   RP_GET,
  47   RP_DONE,
  48   RP_GET_FAIL
  49 };
  50
  51
  52 struct CpsRunContext
  53 {
  54   struct GNUNET_HashCode key;
  55   int i;
  56   int found;
  57   const struct GNUNET_CONFIGURATION_Handle *cfg;
  58   void *data;
  59   enum RunPhase phase;
  60   uint64_t offset;
  61 };
  62
  63
  64 static struct GNUNET_DATASTORE_Handle *datastore;
  65
  66 static struct GNUNET_TIME_Absolute now;
  67
  68 static int ok;
  69
  70 static const char *plugin_name;
  71
  72
  73 static size_t
  74 get_size (int i)
  75 {
  76   return 8 + 8 * (i % 256);
  77 }
  78
  79
  80 static const void *
  81 get_data (int i)
  82 {
  83   static char buf[60000];
  84
  85   memset (buf, i, 8 + 8 * (i % 256));
  86   return buf;
  87 }
  88
  89
  90 static int
  91 get_type (int i)
  92 {
  93   return 1;
  94 }
  95
  96
  97 static int
  98 get_priority (int i)
  99 {
 100   return i + 1;
 101 }
 102
 103
 104 static int
 105 get_anonymity (int i)
 106 {
 107   return i;
 108 }
 109
 110
 111 static struct GNUNET_TIME_Absolute
 112 get_expiration (int i)
 113 {
 114   struct GNUNET_TIME_Absolute av;
 115
 116   av.abs_value_us = now.abs_value_us + i * 1000 * 1000LL;
 117   return av;
 118 }
 119
 120
 121 static void
 122 run_continuation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 123
 124
 125 static void
 126 check_success (void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
 127 {
 128   struct CpsRunContext *crc = cls;
 129
 130   if (GNUNET_OK != success)
 131     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n", msg);
 132   GNUNET_assert (GNUNET_OK == success);
 133   GNUNET_free_non_null (crc->data);
 134   crc->data = NULL;
 135   GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
 136                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 137 }
 138
 139
 140 static void
 141 check_value (void *cls, const struct GNUNET_HashCode * key, size_t size,
 142              const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority,
 143              uint32_t anonymity, struct GNUNET_TIME_Absolute expiration,
 144              uint64_t uid)
 145 {
 146   struct CpsRunContext *crc = cls;
 147   int i;
 148
 149   if (NULL == key)
 150   {
 151     crc->phase = RP_GET_FAIL;
 152     GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
 153                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 154     return;
 155   }
 156   i = crc->i;
 157   GNUNET_assert (size == get_size (i));
 158   GNUNET_assert (0 == memcmp (data, get_data (i), size));
 159   GNUNET_assert (type == get_type (i));
 160   GNUNET_assert (priority == get_priority (i));
 161   GNUNET_assert (anonymity == get_anonymity (i));
 162   GNUNET_assert (expiration.abs_value_us == get_expiration (i).abs_value_us);
 163   crc->offset++;
 164   crc->i--;
 165   if (crc->i == 0)
 166     crc->phase = RP_DONE;
 167   GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
 168                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 169 }
 170
 171
 172 static void
 173 check_nothing (void *cls, const struct GNUNET_HashCode * key, size_t size,
 174                const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority,
 175                uint32_t anonymity, struct GNUNET_TIME_Absolute expiration,
 176                uint64_t uid)
 177 {
 178   struct CpsRunContext *crc = cls;
 179
 180   GNUNET_assert (key == NULL);
 181   if (0 == --crc->i)
 182     crc->phase = RP_DONE;
 183   GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
 184                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 185 }
 186
 187
 188 static void
 189 run_continuation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 190 {
 191   struct CpsRunContext *crc = cls;
 192
 193   ok = (int) crc->phase;
 194   switch (crc->phase)
 195   {
 196   case RP_PUT:
 197     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing `%s' number %u\n", "PUT",
 198                 crc->i);
 199     GNUNET_CRYPTO_hash (&crc->i, sizeof (int), &crc->key);
 200     GNUNET_DATASTORE_put (datastore, 0, &crc->key, get_size (crc->i),
 201                           get_data (crc->i), get_type (crc->i),
 202                           get_priority (crc->i), get_anonymity (crc->i), 0,
 203                           get_expiration (crc->i), 1, 1, TIMEOUT,
 204                           &check_success, crc);
 205     crc->i++;
 206     if (crc->i == ITERATIONS)
 207     {
 208       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 209                   "Sleeping to give datastore time to clean up\n");
 210       sleep (1);
 211       crc->phase = RP_GET;
 212       crc->i--;
 213     }
 214     break;
 215   case RP_GET:
 216     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing `%s' number %u\n", "GET",
 217                 crc->i);
 218     GNUNET_CRYPTO_hash (&crc->i, sizeof (int), &crc->key);
 219     GNUNET_DATASTORE_get_key (datastore, crc->offset++, &crc->key,
 220                               get_type (crc->i), 1, 1, TIMEOUT, &check_value,
 221                               crc);
 222     break;
 223   case RP_GET_FAIL:
 224     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing `%s' number %u\n", "GET(f)",
 225                 crc->i);
 226     GNUNET_CRYPTO_hash (&crc->i, sizeof (int), &crc->key);
 227     GNUNET_DATASTORE_get_key (datastore, crc->offset++, &crc->key,
 228                               get_type (crc->i), 1, 1, TIMEOUT, &check_nothing,
 229                               crc);
 230     break;
 231   case RP_DONE:
 232     GNUNET_assert (0 == crc->i);
 233     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished, disconnecting\n");
 234     GNUNET_DATASTORE_disconnect (datastore, GNUNET_YES);
 235     GNUNET_free (crc);
 236     ok = 0;
 237   }
 238 }
 239
 240
 241 static void
 242 run_tests (void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
 243 {
 244   struct CpsRunContext *crc = cls;
 245
 246   if (success != GNUNET_YES)
 247   {
 248     FPRINTF (stderr,
 249              "Test 'put' operation failed with error `%s' database likely not setup, skipping test.\n",
 250              msg);
 251     GNUNET_DATASTORE_disconnect (datastore, GNUNET_YES);
 252     GNUNET_free (crc);
 253     return;
 254   }
 255   GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
 256                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 257 }
 258
 259
 260 static void
 261 run (void *cls,
 262      const struct GNUNET_CONFIGURATION_Handle *cfg,
 263      struct GNUNET_TESTING_Peer *peer)
 264 {
 265   struct CpsRunContext *crc;
 266   static struct GNUNET_HashCode zkey;
 267
 268   crc = GNUNET_malloc (sizeof (struct CpsRunContext));
 269   crc->cfg = cfg;
 270   crc->phase = RP_PUT;
 271   now = GNUNET_TIME_absolute_get ();
 272   datastore = GNUNET_DATASTORE_connect (cfg);
 273   if (NULL ==
 274       GNUNET_DATASTORE_put (datastore, 0, &zkey, 4, "TEST",
 275                             GNUNET_BLOCK_TYPE_TEST, 0, 0, 0,
 276                             GNUNET_TIME_relative_to_absolute
 277                             (GNUNET_TIME_UNIT_SECONDS), 0, 1,
 278                             GNUNET_TIME_UNIT_MINUTES, &run_tests, crc))
 279   {
 280     FPRINTF (stderr, "%s",  "Test 'put' operation failed.\n");
 281     GNUNET_free (crc);
 282     ok = 1;
 283   }
 284 }
 285
 286
 287 int
 288 main (int argc, char *argv[])
 289 {
 290   char cfg_name[128];
 291
 292   plugin_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]);
 293   GNUNET_snprintf (cfg_name, sizeof (cfg_name),
 294                    "test_datastore_api_data_%s.conf", plugin_name);
 295   if (0 !=
 296       GNUNET_TESTING_peer_run ("test-gnunet-datastore-management",
 297                                cfg_name,
 298                                &run,
 299                                NULL))
 300     return 1;
 301   return ok;
 302 }
 303
 304 /* end of test_datastore_api_management.c */