indentation
[oweals/gnunet.git] / src / dht / test_dht_twopeer.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 dht/test_dht_twopeer.c
22  * @brief base testcase for testing DHT service with
23  *        two running peers
24  */
25 #include "platform.h"
26 #include "gnunet_testing_lib.h"
27 #include "gnunet_core_service.h"
28 #include "gnunet_dht_service.h"
29
30 /* DEFINES */
31 #define VERBOSE GNUNET_NO
32
33 #define MAX_GET_ATTEMPTS 10
34
35 #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5)
36
37 #define DEFAULT_NUM_PEERS 2
38
39 /* Structs */
40
41 struct PeerGetContext
42 {
43   struct GNUNET_PeerIdentity *peer;
44
45   struct GNUNET_DHT_Handle *dht_handle;
46
47   struct GNUNET_DHT_GetHandle *get_handle;
48
49   unsigned int get_attempts;
50
51   GNUNET_SCHEDULER_TaskIdentifier retry_task;
52 };
53
54 /* Globals */
55 static char *test_directory;
56
57 static struct PeerGetContext curr_get_ctx;
58
59 static unsigned int expected_connections;
60
61 static unsigned long long peers_left;
62
63 static struct GNUNET_TESTING_PeerGroup *pg;
64
65 static unsigned long long num_peers;
66
67 static unsigned int total_gets;
68
69 static unsigned int gets_succeeded;
70
71 static unsigned int total_connections;
72
73 static unsigned int failed_connections;
74
75 GNUNET_SCHEDULER_TaskIdentifier die_task;
76
77 static int ok;
78
79 static struct GNUNET_PeerIdentity peer1id;
80
81 static struct GNUNET_PeerIdentity peer2id;
82
83 static struct GNUNET_DHT_Handle *peer1dht;
84
85 static struct GNUNET_DHT_Handle *peer2dht;
86
87 /**
88  * Check whether peers successfully shut down.
89  */
90 void
91 shutdown_callback (void *cls, const char *emsg)
92 {
93   if (emsg != NULL)
94   {
95     if (ok == 0)
96       ok = 2;
97   }
98 }
99
100 static void
101 finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
102 {
103   GNUNET_assert (pg != NULL);
104   GNUNET_assert (peer1dht != NULL);
105   GNUNET_assert (peer2dht != NULL);
106   GNUNET_DHT_disconnect (peer1dht);
107   GNUNET_DHT_disconnect (peer2dht);
108   GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
109   ok = 0;
110 }
111
112 static void
113 end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
114 {
115   if (peer1dht != NULL)
116     GNUNET_DHT_disconnect (peer1dht);
117
118   if (peer2dht != NULL)
119     GNUNET_DHT_disconnect (peer2dht);
120
121   if (pg != NULL)
122     GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
123
124   if (curr_get_ctx.retry_task != GNUNET_SCHEDULER_NO_TASK)
125     GNUNET_SCHEDULER_cancel (curr_get_ctx.retry_task);
126 }
127
128 static void
129 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
130 {
131   if (curr_get_ctx.retry_task != GNUNET_SCHEDULER_NO_TASK)
132     GNUNET_SCHEDULER_cancel (curr_get_ctx.retry_task);
133
134   if (curr_get_ctx.get_handle != NULL)
135   {
136     GNUNET_DHT_get_stop (curr_get_ctx.get_handle);
137   }
138
139   GNUNET_SCHEDULER_add_now (&end_badly_cont, NULL);
140   ok = 1;
141 }
142
143 /* Forward declaration */
144 static void do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
145
146 /**
147  * Iterator called on each result obtained for a DHT
148  * operation that expects a reply
149  *
150  * @param cls closure
151  * @param exp when will this value expire
152  * @param key key of the result
153  * @param type type of the result
154  * @param size number of bytes in data
155  * @param data pointer to the result data
156  */
157 void
158 get_result_iterator (void *cls, struct GNUNET_TIME_Absolute exp,
159                      const GNUNET_HashCode * key,
160                      const struct GNUNET_PeerIdentity *const *get_path,
161                      const struct GNUNET_PeerIdentity *const *put_path,
162                      enum GNUNET_BLOCK_Type type, size_t size, const void *data)
163 {
164   struct PeerGetContext *get_context = cls;
165
166   if (0 !=
167       memcmp (&get_context->peer->hashPubKey, key, sizeof (GNUNET_HashCode)))
168   {
169     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
170                 "Key returned is not the same key as was searched for!\n");
171     GNUNET_SCHEDULER_cancel (die_task);
172     GNUNET_SCHEDULER_add_now (&end_badly, "key mismatch in get response!\n");
173     return;
174   }
175
176   if (get_context->retry_task != GNUNET_SCHEDULER_NO_TASK)
177   {
178     GNUNET_SCHEDULER_cancel (get_context->retry_task);
179     get_context->retry_task = GNUNET_SCHEDULER_NO_TASK;
180   }
181
182   if (get_context->peer == &peer2id)
183   {
184     get_context->peer = &peer1id;
185     get_context->dht_handle = peer2dht;
186     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
187                 "Received first correct GET request response!\n");
188     GNUNET_DHT_get_stop (get_context->get_handle);
189     GNUNET_SCHEDULER_add_now (&do_get, get_context);
190   }
191   else
192   {
193     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
194                 "Received second correct GET request response!\n");
195     GNUNET_SCHEDULER_cancel (die_task);
196     GNUNET_DHT_get_stop (get_context->get_handle);
197     GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
198   }
199
200 }
201
202 static void stop_retry_get (void *cls,
203                             const struct GNUNET_SCHEDULER_TaskContext *tc);
204
205 static void
206 get_stop_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
207 {
208   struct PeerGetContext *get_context = cls;
209
210   if (get_context->get_attempts < MAX_GET_ATTEMPTS)
211     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
212                 "Get attempt %u failed, retrying request!\n",
213                 get_context->get_attempts);
214   else
215   {
216     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
217                 "Too many attempts failed, ending test!\n",
218                 get_context->get_attempts);
219     GNUNET_SCHEDULER_cancel (die_task);
220     GNUNET_SCHEDULER_add_now (&end_badly, "key mismatch in get response!\n");
221     return;
222   }
223   get_context->get_attempts++;
224   get_context->retry_task =
225       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
226                                     (GNUNET_TIME_UNIT_SECONDS, 10),
227                                     &stop_retry_get, get_context);
228   get_context->get_handle =
229       GNUNET_DHT_get_start (get_context->dht_handle,
230                             GNUNET_TIME_relative_multiply
231                             (GNUNET_TIME_UNIT_SECONDS, 5),
232                             GNUNET_BLOCK_TYPE_DHT_HELLO,
233                             &get_context->peer->hashPubKey,
234                             DEFAULT_GET_REPLICATION, GNUNET_DHT_RO_NONE, NULL,
235                             0, NULL, 0, &get_result_iterator, get_context);
236 }
237
238 static void
239 stop_retry_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
240 {
241   struct PeerGetContext *get_context = cls;
242
243   get_context->retry_task = GNUNET_SCHEDULER_NO_TASK;
244   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
245               "Get attempt %u failed, canceling request!\n",
246               get_context->get_attempts);
247   GNUNET_DHT_get_stop (get_context->get_handle);
248   get_context->get_handle = NULL;
249   GNUNET_SCHEDULER_add_now (&get_stop_finished, get_context);
250 }
251
252 static void
253 do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
254 {
255   struct PeerGetContext *get_context = cls;
256
257   get_context->retry_task =
258       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
259                                     (GNUNET_TIME_UNIT_SECONDS, 10),
260                                     &stop_retry_get, get_context);
261
262   get_context->get_handle =
263       GNUNET_DHT_get_start (get_context->dht_handle,
264                             GNUNET_TIME_relative_multiply
265                             (GNUNET_TIME_UNIT_SECONDS, 5),
266                             GNUNET_BLOCK_TYPE_DHT_HELLO,
267                             &get_context->peer->hashPubKey,
268                             DEFAULT_GET_REPLICATION, GNUNET_DHT_RO_NONE, NULL,
269                             0, NULL, 0, &get_result_iterator, get_context);
270 }
271
272
273 void
274 topology_callback (void *cls, const struct GNUNET_PeerIdentity *first,
275                    const struct GNUNET_PeerIdentity *second, uint32_t distance,
276                    const struct GNUNET_CONFIGURATION_Handle *first_cfg,
277                    const struct GNUNET_CONFIGURATION_Handle *second_cfg,
278                    struct GNUNET_TESTING_Daemon *first_daemon,
279                    struct GNUNET_TESTING_Daemon *second_daemon,
280                    const char *emsg)
281 {
282   if (emsg == NULL)
283   {
284     total_connections++;
285 #if VERBOSE
286     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
287                 "connected peer %s to peer %s, distance %u\n",
288                 first_daemon->shortname, second_daemon->shortname, distance);
289 #endif
290   }
291 #if VERBOSE
292   else
293   {
294     failed_connections++;
295     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
296                 "Failed to connect peer %s to peer %s with error :\n%s\n",
297                 first_daemon->shortname, second_daemon->shortname, emsg);
298   }
299 #endif
300
301   if (total_connections == expected_connections)
302   {
303 #if VERBOSE
304     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
305                 "Created %d total connections, which is our target number!  Starting next phase of testing.\n",
306                 total_connections);
307 #endif
308     GNUNET_SCHEDULER_cancel (die_task);
309     die_task =
310         GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, "from test gets");
311
312     curr_get_ctx.dht_handle = peer1dht;
313     curr_get_ctx.peer = &peer2id;
314     GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
315                                   (GNUNET_TIME_UNIT_SECONDS, 2), &do_get,
316                                   &curr_get_ctx);
317   }
318   else if (total_connections + failed_connections == expected_connections)
319   {
320     GNUNET_SCHEDULER_cancel (die_task);
321     die_task =
322         GNUNET_SCHEDULER_add_now (&end_badly,
323                                   "from topology_callback (too many failed connections)");
324   }
325 }
326
327 static void
328 connect_topology (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
329 {
330   expected_connections = -1;
331   if ((pg != NULL) && (peers_left == 0))
332     expected_connections =
333         GNUNET_TESTING_connect_topology (pg, GNUNET_TESTING_TOPOLOGY_CLIQUE,
334                                          GNUNET_TESTING_TOPOLOGY_OPTION_ALL,
335                                          0.0, TIMEOUT, 12, NULL, NULL);
336
337   GNUNET_SCHEDULER_cancel (die_task);
338   if (expected_connections == GNUNET_SYSERR)
339     die_task =
340         GNUNET_SCHEDULER_add_now (&end_badly,
341                                   "from connect topology (bad return)");
342
343
344   die_task =
345       GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly,
346                                     "from connect topology (timeout)");
347 }
348
349 static void
350 peers_started_callback (void *cls, const struct GNUNET_PeerIdentity *id,
351                         const struct GNUNET_CONFIGURATION_Handle *cfg,
352                         struct GNUNET_TESTING_Daemon *d, const char *emsg)
353 {
354   if (emsg != NULL)
355   {
356     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
357                 "Failed to start daemon with error: `%s'\n", emsg);
358     return;
359   }
360   GNUNET_assert (id != NULL);
361   if (peers_left == num_peers)
362   {
363     memcpy (&peer1id, id, sizeof (struct GNUNET_PeerIdentity));
364     peer1dht = GNUNET_DHT_connect (cfg, 100);
365     if (peer1dht == NULL)
366     {
367       GNUNET_SCHEDULER_cancel (die_task);
368       GNUNET_SCHEDULER_add_now (&end_badly, "Failed to get dht handle!\n");
369     }
370   }
371   else
372   {
373     memcpy (&peer2id, id, sizeof (struct GNUNET_PeerIdentity));
374     peer2dht = GNUNET_DHT_connect (cfg, 100);
375     if (peer2dht == NULL)
376     {
377       GNUNET_SCHEDULER_cancel (die_task);
378       GNUNET_SCHEDULER_add_now (&end_badly, "Failed to get dht handle!\n");
379     }
380   }
381
382
383   peers_left--;
384
385   if (peers_left == 0)
386   {
387 #if VERBOSE
388     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
389                 "All %d daemons started, now connecting peers!\n", num_peers);
390 #endif
391     GNUNET_SCHEDULER_cancel (die_task);
392     /* Set up task in case topology creation doesn't finish
393      * within a reasonable amount of time */
394     die_task =
395         GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly,
396                                       "from peers_started_callback");
397
398     GNUNET_SCHEDULER_add_now (&connect_topology, NULL);
399     ok = 0;
400   }
401 }
402
403 static void
404 run (void *cls, char *const *args, const char *cfgfile,
405      const struct GNUNET_CONFIGURATION_Handle *cfg)
406 {
407
408   if (GNUNET_YES !=
409       GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome",
410                                              &test_directory))
411   {
412     ok = 404;
413     return;
414   }
415
416   if (GNUNET_SYSERR ==
417       GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
418                                              &num_peers))
419     num_peers = DEFAULT_NUM_PEERS;
420
421   peers_left = num_peers;
422   total_gets = num_peers;
423   gets_succeeded = 0;
424   /* Set up a task to end testing if peer start fails */
425   die_task =
426       GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly,
427                                     "didn't start all daemons in reasonable amount of time!!!");
428
429   pg = GNUNET_TESTING_daemons_start (cfg, num_peers, 10, num_peers, TIMEOUT,
430                                      NULL, NULL, &peers_started_callback, NULL,
431                                      &topology_callback, NULL, NULL);
432
433 }
434
435 static int
436 check ()
437 {
438   int ret;
439
440   char *const argv[] = { "test-dht-twopeer",
441     "-c",
442     "test_dht_twopeer_data.conf",
443 #if VERBOSE
444     "-L", "DEBUG",
445 #endif
446     NULL
447   };
448   struct GNUNET_GETOPT_CommandLineOption options[] = {
449     GNUNET_GETOPT_OPTION_END
450   };
451   ret =
452       GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
453                           "test-dht-twopeer", "nohelp", options, &run, &ok);
454   if (ret != GNUNET_OK)
455   {
456     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
457                 "`test-dht-twopeer': Failed with error code %d\n", ret);
458   }
459   return ok;
460 }
461
462 int
463 main (int argc, char *argv[])
464 {
465   int ret;
466
467   GNUNET_log_setup ("test-dht-twopeer",
468 #if VERBOSE
469                     "DEBUG",
470 #else
471                     "WARNING",
472 #endif
473                     NULL);
474   ret = check ();
475   /**
476    * Need to remove base directory, subdirectories taken care
477    * of by the testing framework.
478    */
479   if (GNUNET_DISK_directory_remove (test_directory) != GNUNET_OK)
480   {
481     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
482                 "Failed to remove testing directory %s\n", test_directory);
483   }
484   return ret;
485 }
486
487 /* end of test_dht_twopeer.c */