use enum GNUNET_ATS_Network_Type instead of uint32_t where appropriate
[oweals/gnunet.git] / src / datastore / test_datastore_api.c
1 /*
2      This file is part of GNUnet.
3      (C) 2004, 2005, 2006, 2007, 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 datastore/test_datastore_api.c
22  * @brief Test for the basic datastore API.
23  * @author Christian Grothoff
24  *
25  * TODO:
26  * - test reservation failure
27  */
28
29 #include "platform.h"
30 #include "gnunet_util_lib.h"
31 #include "gnunet_protocols.h"
32 #include "gnunet_datastore_service.h"
33 #include "gnunet_testing_lib.h"
34
35
36 /**
37  * How long until we give up on transmitting the message?
38  */
39 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
40
41 #define ITERATIONS 256
42
43 static struct GNUNET_DATASTORE_Handle *datastore;
44
45 static struct GNUNET_TIME_Absolute now;
46
47 static int ok;
48
49 /**
50  * Name of plugin under test.
51  */
52 static const char *plugin_name;
53
54 static size_t
55 get_size (int i)
56 {
57   return 8 * i;
58 }
59
60
61 static const void *
62 get_data (int i)
63 {
64   static char buf[60000];
65
66   memset (buf, i, 8 * i);
67   return buf;
68 }
69
70
71 static int
72 get_type (int i)
73 {
74   return i + 1;
75 }
76
77
78 static int
79 get_priority (int i)
80 {
81   return i + 1;
82 }
83
84
85 static int
86 get_anonymity (int i)
87 {
88   return i;
89 }
90
91
92 static struct GNUNET_TIME_Absolute
93 get_expiration (int i)
94 {
95   struct GNUNET_TIME_Absolute av;
96
97   av.abs_value_us = now.abs_value_us + 20000000000LL - i * 1000 * 1000LL;
98   return av;
99 }
100
101 enum RunPhase
102 {
103   RP_DONE = 0,
104   RP_PUT = 1,
105   RP_GET = 2,
106   RP_DEL = 3,
107   RP_DO_DEL = 4,
108   RP_DELVALIDATE = 5,
109   RP_RESERVE = 6,
110   RP_PUT_MULTIPLE = 7,
111   RP_PUT_MULTIPLE_NEXT = 8,
112   RP_GET_MULTIPLE = 9,
113   RP_GET_MULTIPLE_NEXT = 10,
114   RP_UPDATE = 11,
115   RP_UPDATE_VALIDATE = 12,
116   RP_ERROR
117 };
118
119
120 struct CpsRunContext
121 {
122   struct GNUNET_HashCode key;
123   int i;
124   int rid;
125   const struct GNUNET_CONFIGURATION_Handle *cfg;
126   void *data;
127   size_t size;
128   enum RunPhase phase;
129   uint64_t uid;
130   uint64_t offset;
131   uint64_t first_uid;
132 };
133
134
135 static void
136 run_continuation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
137
138
139 static void
140 check_success (void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
141 {
142   struct CpsRunContext *crc = cls;
143
144   if (GNUNET_OK != success)
145   {
146     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
147                 "Operation %d/%d not successfull: `%s'\n", crc->phase, crc->i,
148                 msg);
149     crc->phase = RP_ERROR;
150   }
151   GNUNET_free_non_null (crc->data);
152   crc->data = NULL;
153   GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
154                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
155 }
156
157
158 static void
159 get_reserved (void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
160 {
161   struct CpsRunContext *crc = cls;
162
163   if (0 >= success)
164     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error obtaining reservation: `%s'\n",
165                 msg);
166   GNUNET_assert (0 < success);
167   crc->rid = success;
168   GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
169                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
170 }
171
172
173 static void
174 check_value (void *cls, const struct GNUNET_HashCode * key, size_t size,
175              const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority,
176              uint32_t anonymity, struct GNUNET_TIME_Absolute expiration,
177              uint64_t uid)
178 {
179   struct CpsRunContext *crc = cls;
180   int i;
181
182   i = crc->i;
183   if (NULL == key)
184   {
185     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
186                 "Value check failed (got NULL key) in %d/%d\n", crc->phase,
187                 crc->i);
188     crc->phase = RP_ERROR;
189     GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
190                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
191     return;
192   }
193 #if 0
194   FPRINTF (stderr,
195            "Check value got `%s' of size %u, type %d, expire %s\n",
196            GNUNET_h2s (key), (unsigned int) size, type,
197            GNUNET_STRINGS_absolute_time_to_string (expiration));
198   FPRINTF (stderr,
199            "Check value iteration %d wants size %u, type %d, expire %s\n", i,
200            (unsigned int) get_size (i), get_type (i),
201            GNUNET_STRINGS_absolute_time_to_string (get_expiration(i)));
202 #endif
203   GNUNET_assert (size == get_size (i));
204   GNUNET_assert (0 == memcmp (data, get_data (i), size));
205   GNUNET_assert (type == get_type (i));
206   GNUNET_assert (priority == get_priority (i));
207   GNUNET_assert (anonymity == get_anonymity (i));
208   GNUNET_assert (expiration.abs_value_us == get_expiration (i).abs_value_us);
209   crc->offset++;
210   if (crc->i == 0)
211   {
212     crc->phase = RP_DEL;
213     crc->i = ITERATIONS;
214   }
215   GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
216                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
217 }
218
219
220 static void
221 delete_value (void *cls, const struct GNUNET_HashCode * key, size_t size,
222               const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority,
223               uint32_t anonymity, struct GNUNET_TIME_Absolute expiration,
224               uint64_t uid)
225 {
226   struct CpsRunContext *crc = cls;
227
228   GNUNET_assert (crc->data == NULL);
229   GNUNET_assert (NULL != key);
230   crc->size = size;
231   crc->key = *key;
232   crc->data = GNUNET_malloc (size);
233   memcpy (crc->data, data, size);
234   crc->phase = RP_DO_DEL;
235   GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
236                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
237 }
238
239
240 static void
241 check_nothing (void *cls, const struct GNUNET_HashCode * key, size_t size,
242                const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority,
243                uint32_t anonymity, struct GNUNET_TIME_Absolute expiration,
244                uint64_t uid)
245 {
246   struct CpsRunContext *crc = cls;
247
248   GNUNET_assert (key == NULL);
249   if (crc->i == 0)
250     crc->phase = RP_RESERVE;
251   GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
252                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
253 }
254
255
256 static void
257 check_multiple (void *cls, const struct GNUNET_HashCode * key, size_t size,
258                 const void *data, enum GNUNET_BLOCK_Type type,
259                 uint32_t priority, uint32_t anonymity,
260                 struct GNUNET_TIME_Absolute expiration, uint64_t uid)
261 {
262   struct CpsRunContext *crc = cls;
263
264   GNUNET_assert (key != NULL);
265   switch (crc->phase)
266   {
267   case RP_GET_MULTIPLE:
268     crc->phase = RP_GET_MULTIPLE_NEXT;
269     crc->first_uid = uid;
270     crc->offset++;
271     break;
272   case RP_GET_MULTIPLE_NEXT:
273     GNUNET_assert (uid != crc->first_uid);
274     crc->phase = RP_UPDATE;
275     break;
276   default:
277     GNUNET_break (0);
278     crc->phase = RP_ERROR;
279     break;
280   }
281   if (priority == get_priority (42))
282     crc->uid = uid;
283   GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
284                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
285 }
286
287
288 static void
289 check_update (void *cls, const struct GNUNET_HashCode * key, size_t size,
290               const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority,
291               uint32_t anonymity, struct GNUNET_TIME_Absolute expiration,
292               uint64_t uid)
293 {
294   struct CpsRunContext *crc = cls;
295
296   GNUNET_assert (key != NULL);
297   if ((anonymity == get_anonymity (42)) && (size == get_size (42)) &&
298       (priority == get_priority (42) + 100))
299     crc->phase = RP_DONE;
300   else
301   {
302     GNUNET_assert (size == get_size (43));
303     crc->offset++;
304   }
305   GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
306                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
307 }
308
309
310 static void
311 run_continuation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
312 {
313   struct CpsRunContext *crc = cls;
314
315   ok = (int) crc->phase;
316   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test in phase %u\n", crc->phase);
317   switch (crc->phase)
318   {
319   case RP_PUT:
320     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing `%s' number %u\n", "PUT",
321                 crc->i);
322     GNUNET_CRYPTO_hash (&crc->i, sizeof (int), &crc->key);
323     GNUNET_DATASTORE_put (datastore, 0, &crc->key, get_size (crc->i),
324                           get_data (crc->i), get_type (crc->i),
325                           get_priority (crc->i), get_anonymity (crc->i), 0,
326                           get_expiration (crc->i), 1, 1, TIMEOUT,
327                           &check_success, crc);
328     crc->i++;
329     if (crc->i == ITERATIONS)
330       crc->phase = RP_GET;
331     break;
332   case RP_GET:
333     crc->i--;
334     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing `%s' number %u\n", "GET",
335                 crc->i);
336     GNUNET_CRYPTO_hash (&crc->i, sizeof (int), &crc->key);
337     GNUNET_DATASTORE_get_key (datastore, crc->offset, &crc->key,
338                               get_type (crc->i), 1, 1, TIMEOUT, &check_value,
339                               crc);
340     break;
341   case RP_DEL:
342     crc->i--;
343     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing `%s' number %u\n", "DEL",
344                 crc->i);
345     crc->data = NULL;
346     GNUNET_CRYPTO_hash (&crc->i, sizeof (int), &crc->key);
347     GNUNET_assert (NULL !=
348                    GNUNET_DATASTORE_get_key (datastore, crc->offset, &crc->key,
349                                              get_type (crc->i), 1, 1, TIMEOUT,
350                                              &delete_value, crc));
351     break;
352   case RP_DO_DEL:
353     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing `%s' number %u\n", "DO_DEL",
354                 crc->i);
355     if (crc->i == 0)
356     {
357       crc->i = ITERATIONS;
358       crc->phase = RP_DELVALIDATE;
359     }
360     else
361     {
362       crc->phase = RP_DEL;
363     }
364     GNUNET_assert (NULL !=
365                    GNUNET_DATASTORE_remove (datastore, &crc->key, crc->size,
366                                             crc->data, 1, 1, TIMEOUT,
367                                             &check_success, crc));
368     break;
369   case RP_DELVALIDATE:
370     crc->i--;
371     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing `%s' number %u\n",
372                 "DEL-VALIDATE", crc->i);
373     GNUNET_CRYPTO_hash (&crc->i, sizeof (int), &crc->key);
374     GNUNET_assert (NULL !=
375                    GNUNET_DATASTORE_get_key (datastore, crc->offset, &crc->key,
376                                              get_type (crc->i), 1, 1, TIMEOUT,
377                                              &check_nothing, crc));
378     break;
379   case RP_RESERVE:
380     crc->phase = RP_PUT_MULTIPLE;
381     GNUNET_DATASTORE_reserve (datastore, 128 * 1024, 2, 1, 1, TIMEOUT,
382                               &get_reserved, crc);
383     break;
384   case RP_PUT_MULTIPLE:
385     crc->phase = RP_PUT_MULTIPLE_NEXT;
386     GNUNET_DATASTORE_put (datastore, crc->rid, &crc->key, get_size (42),
387                           get_data (42), get_type (42), get_priority (42),
388                           get_anonymity (42), 0, get_expiration (42), 1, 1,
389                           TIMEOUT, &check_success, crc);
390     break;
391   case RP_PUT_MULTIPLE_NEXT:
392     crc->phase = RP_GET_MULTIPLE;
393     GNUNET_DATASTORE_put (datastore, crc->rid, &crc->key, get_size (43),
394                           get_data (43), get_type (42), get_priority (43),
395                           get_anonymity (43), 0, get_expiration (43), 1, 1,
396                           TIMEOUT, &check_success, crc);
397     break;
398   case RP_GET_MULTIPLE:
399     GNUNET_assert (NULL !=
400                    GNUNET_DATASTORE_get_key (datastore, crc->offset, &crc->key,
401                                              get_type (42), 1, 1, TIMEOUT,
402                                              &check_multiple, crc));
403     break;
404   case RP_GET_MULTIPLE_NEXT:
405     GNUNET_assert (NULL !=
406                    GNUNET_DATASTORE_get_key (datastore, crc->offset, &crc->key,
407                                              get_type (42), 1, 1, TIMEOUT,
408                                              &check_multiple, crc));
409     break;
410   case RP_UPDATE:
411     GNUNET_assert (crc->uid > 0);
412     crc->phase = RP_UPDATE_VALIDATE;
413     GNUNET_DATASTORE_update (datastore, crc->uid, 100, get_expiration (42), 1,
414                              1, TIMEOUT, &check_success, crc);
415     break;
416   case RP_UPDATE_VALIDATE:
417     GNUNET_assert (NULL !=
418                    GNUNET_DATASTORE_get_key (datastore, crc->offset, &crc->key,
419                                              get_type (42), 1, 1, TIMEOUT,
420                                              &check_update, crc));
421     break;
422   case RP_DONE:
423     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished, disconnecting\n");
424     GNUNET_DATASTORE_disconnect (datastore, GNUNET_YES);
425     GNUNET_free (crc);
426     ok = 0;
427     break;
428   case RP_ERROR:
429     GNUNET_DATASTORE_disconnect (datastore, GNUNET_YES);
430     GNUNET_free (crc);
431     ok = 43;
432     break;
433   }
434 }
435
436
437 static void
438 run_tests (void *cls, int32_t success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
439 {
440   struct CpsRunContext *crc = cls;
441
442   switch (success)
443   {
444   case GNUNET_YES:
445     GNUNET_SCHEDULER_add_continuation (&run_continuation, crc,
446                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
447     return;
448   case GNUNET_NO:
449     FPRINTF (stderr, "%s", "Test 'put' operation failed, key already exists (!?)\n");
450     GNUNET_DATASTORE_disconnect (datastore, GNUNET_YES);
451     GNUNET_free (crc);
452     return;
453   case GNUNET_SYSERR:
454     FPRINTF (stderr,
455              "Test 'put' operation failed with error `%s' database likely not setup, skipping test.\n",
456              msg);
457     GNUNET_DATASTORE_disconnect (datastore, GNUNET_YES);
458     GNUNET_free (crc);
459     return;
460   default:
461     GNUNET_assert (0);
462   }
463 }
464
465
466 static void
467 run (void *cls,
468      const struct GNUNET_CONFIGURATION_Handle *cfg,
469      struct GNUNET_TESTING_Peer *peer)
470 {
471   struct CpsRunContext *crc;
472   static struct GNUNET_HashCode zkey;
473
474   crc = GNUNET_malloc (sizeof (struct CpsRunContext));
475   crc->cfg = cfg;
476   crc->phase = RP_PUT;
477   now = GNUNET_TIME_absolute_get ();
478   datastore = GNUNET_DATASTORE_connect (cfg);
479   if (NULL ==
480       GNUNET_DATASTORE_put (datastore, 0, &zkey, 4, "TEST",
481                             GNUNET_BLOCK_TYPE_TEST, 0, 0, 0,
482                             GNUNET_TIME_relative_to_absolute
483                             (GNUNET_TIME_UNIT_SECONDS), 0, 1,
484                             GNUNET_TIME_UNIT_MINUTES, &run_tests, crc))
485   {
486     FPRINTF (stderr, "%s",  "Test 'put' operation failed.\n");
487     ok = 1;
488     GNUNET_free (crc);
489   }
490 }
491
492
493 int
494 main (int argc, char *argv[])
495 {
496   char cfg_name[128];
497
498   plugin_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]);
499   GNUNET_snprintf (cfg_name, sizeof (cfg_name),
500                    "test_datastore_api_data_%s.conf", plugin_name);
501   if (0 !=
502       GNUNET_TESTING_peer_run ("test-gnunet-datastore",
503                                cfg_name,
504                                &run,
505                                NULL))
506     return 1;
507   return ok;
508 }
509
510 /* end of test_datastore_api.c */