diff options
author | Christian Grothoff <christian@grothoff.org> | 2012-06-09 15:35:06 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2012-06-09 15:35:06 +0000 |
commit | e0033c1da56e1889775d7dccf92ea78ee52e4d5c (patch) | |
tree | 82a835de1f924de68dff5702d9e2b46b2f64ffdd /src/testing/test_testing_topology.c | |
parent | 5e29c9683d2c0dfff71d2ead9ebb98d74a844bd5 (diff) | |
download | gnunet-e0033c1da56e1889775d7dccf92ea78ee52e4d5c.tar.gz gnunet-e0033c1da56e1889775d7dccf92ea78ee52e4d5c.zip |
-moving old testing code to legacy location
Diffstat (limited to 'src/testing/test_testing_topology.c')
-rw-r--r-- | src/testing/test_testing_topology.c | 1220 |
1 files changed, 0 insertions, 1220 deletions
diff --git a/src/testing/test_testing_topology.c b/src/testing/test_testing_topology.c deleted file mode 100644 index 94cbc0df6..000000000 --- a/src/testing/test_testing_topology.c +++ /dev/null | |||
@@ -1,1220 +0,0 @@ | |||
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_topology.c | ||
22 | * @brief base testcase for testing all the topologies provided | ||
23 | */ | ||
24 | #include "platform.h" | ||
25 | #include "gnunet_testing_lib.h" | ||
26 | #include "gnunet_core_service.h" | ||
27 | #include "gnunet_os_lib.h" | ||
28 | |||
29 | |||
30 | #define PROGRESS_BARS GNUNET_YES | ||
31 | |||
32 | #define DELAY_FOR_LOGGING GNUNET_NO | ||
33 | |||
34 | /** | ||
35 | * How long until we fail the whole testcase? | ||
36 | */ | ||
37 | #define TEST_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 240) | ||
38 | |||
39 | /** | ||
40 | * How long until we give up on starting the peers? | ||
41 | */ | ||
42 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 500) | ||
43 | |||
44 | #define SECONDS_PER_PEER_START 120 | ||
45 | |||
46 | #define DEFAULT_NUM_PEERS 4 | ||
47 | |||
48 | #define MAX_OUTSTANDING_CONNECTIONS 100 | ||
49 | |||
50 | static float fail_percentage = 0.05; | ||
51 | |||
52 | static int ok; | ||
53 | |||
54 | static unsigned long long num_peers; | ||
55 | |||
56 | struct GNUNET_TIME_Relative connect_timeout; | ||
57 | |||
58 | static unsigned long long connect_attempts; | ||
59 | |||
60 | static unsigned int topology_connections; | ||
61 | |||
62 | static unsigned int total_connections; | ||
63 | |||
64 | static unsigned int failed_connections; | ||
65 | |||
66 | static unsigned int total_server_connections; | ||
67 | |||
68 | static unsigned int total_messages_received; | ||
69 | |||
70 | static unsigned int expected_messages; | ||
71 | |||
72 | static unsigned int expected_connections; | ||
73 | |||
74 | static unsigned long long peers_left; | ||
75 | |||
76 | static struct GNUNET_TESTING_PeerGroup *pg; | ||
77 | |||
78 | const struct GNUNET_CONFIGURATION_Handle *main_cfg; | ||
79 | |||
80 | GNUNET_SCHEDULER_TaskIdentifier die_task; | ||
81 | |||
82 | static char *dotOutFileName; | ||
83 | |||
84 | static struct GNUNET_TIME_Relative settle_time; | ||
85 | |||
86 | static FILE *dotOutFile; | ||
87 | |||
88 | static char *topology_string; | ||
89 | |||
90 | static char *blacklist_transports; | ||
91 | |||
92 | static int transmit_ready_scheduled; | ||
93 | |||
94 | static int transmit_ready_failed; | ||
95 | |||
96 | static int transmit_ready_called; | ||
97 | |||
98 | static unsigned int modnum; | ||
99 | |||
100 | static unsigned int dotnum; | ||
101 | |||
102 | static enum GNUNET_TESTING_Topology topology; | ||
103 | |||
104 | static enum GNUNET_TESTING_Topology blacklist_topology = GNUNET_TESTING_TOPOLOGY_NONE; /* Don't do any blacklisting */ | ||
105 | |||
106 | static enum GNUNET_TESTING_Topology connection_topology = GNUNET_TESTING_TOPOLOGY_NONE; /* NONE actually means connect all allowed peers */ | ||
107 | |||
108 | static enum GNUNET_TESTING_TopologyOption connect_topology_option = | ||
109 | GNUNET_TESTING_TOPOLOGY_OPTION_ALL; | ||
110 | |||
111 | static double connect_topology_option_modifier = 0.0; | ||
112 | |||
113 | static char *test_directory; | ||
114 | |||
115 | #define MTYPE 12345 | ||
116 | |||
117 | GNUNET_NETWORK_STRUCT_BEGIN | ||
118 | |||
119 | struct GNUNET_TestMessage | ||
120 | { | ||
121 | /** | ||
122 | * Header of the message | ||
123 | */ | ||
124 | struct GNUNET_MessageHeader header; | ||
125 | |||
126 | /** | ||
127 | * Unique identifier for this message. | ||
128 | */ | ||
129 | uint32_t uid; | ||
130 | }; | ||
131 | GNUNET_NETWORK_STRUCT_END | ||
132 | |||
133 | struct TestMessageContext | ||
134 | { | ||
135 | /* This is a linked list */ | ||
136 | struct TestMessageContext *next; | ||
137 | |||
138 | /* Handle to the sending peer core */ | ||
139 | struct GNUNET_CORE_Handle *peer1handle; | ||
140 | |||
141 | /* Handle to the receiving peer core */ | ||
142 | struct GNUNET_CORE_Handle *peer2handle; | ||
143 | |||
144 | /* Handle to the sending peer daemon */ | ||
145 | struct GNUNET_TESTING_Daemon *peer1; | ||
146 | |||
147 | /* Handle to the receiving peer daemon */ | ||
148 | struct GNUNET_TESTING_Daemon *peer2; | ||
149 | |||
150 | /* Identifier for this message, so we don't disconnect other peers! */ | ||
151 | uint32_t uid; | ||
152 | |||
153 | /* Has peer1 been notified already of a connection to peer2? */ | ||
154 | int peer1notified; | ||
155 | |||
156 | /* Has the core of peer2 been connected already? */ | ||
157 | int peer2connected; | ||
158 | |||
159 | /* Task for disconnecting cores, allow task to be cancelled on shutdown */ | ||
160 | GNUNET_SCHEDULER_TaskIdentifier disconnect_task; | ||
161 | |||
162 | }; | ||
163 | |||
164 | static struct TestMessageContext *test_messages; | ||
165 | |||
166 | /** | ||
167 | * Check whether peers successfully shut down. | ||
168 | */ | ||
169 | static void | ||
170 | shutdown_callback (void *cls, const char *emsg) | ||
171 | { | ||
172 | if (emsg != NULL) | ||
173 | { | ||
174 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Shutdown of peers failed: %s!\n", | ||
175 | emsg); | ||
176 | if (ok == 0) | ||
177 | ok = 666; | ||
178 | } | ||
179 | else | ||
180 | { | ||
181 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All peers successfully shut down!\n"); | ||
182 | } | ||
183 | } | ||
184 | |||
185 | |||
186 | #if DELAY_FOR_LOGGING | ||
187 | static void | ||
188 | gather_log_data () | ||
189 | { | ||
190 | char *peer_number; | ||
191 | char *connect_number; | ||
192 | struct GNUNET_OS_Process *mem_process; | ||
193 | |||
194 | GNUNET_asprintf (&peer_number, "%llu", num_peers); | ||
195 | GNUNET_asprintf (&connect_number, "%llu", expected_connections); | ||
196 | mem_process = | ||
197 | GNUNET_OS_start_process (NULL, NULL, "./memsize.pl", "memsize.pl", | ||
198 | "totals.txt", peer_number, connect_number, NULL); | ||
199 | GNUNET_OS_process_wait (mem_process); | ||
200 | GNUNET_OS_process_destroy (mem_process); | ||
201 | mem_process = NULL; | ||
202 | } | ||
203 | #endif | ||
204 | |||
205 | |||
206 | static void | ||
207 | finish_testing () | ||
208 | { | ||
209 | GNUNET_assert (pg != NULL); | ||
210 | struct TestMessageContext *pos; | ||
211 | struct TestMessageContext *free_pos; | ||
212 | |||
213 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
214 | "Called finish testing, stopping daemons.\n"); | ||
215 | pos = test_messages; | ||
216 | while (pos != NULL) | ||
217 | { | ||
218 | if (pos->peer1handle != NULL) | ||
219 | { | ||
220 | GNUNET_CORE_disconnect (pos->peer1handle); | ||
221 | pos->peer1handle = NULL; | ||
222 | } | ||
223 | if (pos->peer2handle != NULL) | ||
224 | { | ||
225 | GNUNET_CORE_disconnect (pos->peer2handle); | ||
226 | pos->peer2handle = NULL; | ||
227 | } | ||
228 | free_pos = pos; | ||
229 | pos = pos->next; | ||
230 | if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK) | ||
231 | { | ||
232 | GNUNET_SCHEDULER_cancel (free_pos->disconnect_task); | ||
233 | } | ||
234 | GNUNET_free (free_pos); | ||
235 | } | ||
236 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
237 | "Transmit_ready's scheduled %d, failed %d, transmit_ready's called %d\n", | ||
238 | transmit_ready_scheduled, transmit_ready_failed, | ||
239 | transmit_ready_called); | ||
240 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Calling daemons_stop\n"); | ||
241 | GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL); | ||
242 | |||
243 | if (dotOutFile != NULL) | ||
244 | { | ||
245 | FPRINTF (dotOutFile, "%s", "}"); | ||
246 | FCLOSE (dotOutFile); | ||
247 | } | ||
248 | ok = 0; | ||
249 | } | ||
250 | |||
251 | |||
252 | static void | ||
253 | disconnect_cores (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
254 | { | ||
255 | struct TestMessageContext *pos = cls; | ||
256 | |||
257 | /* Disconnect from the respective cores */ | ||
258 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from peer 1 `%4s'\n", | ||
259 | GNUNET_i2s (&pos->peer1->id)); | ||
260 | if (pos->peer1handle != NULL) | ||
261 | { | ||
262 | GNUNET_CORE_disconnect (pos->peer1handle); | ||
263 | pos->peer1handle = NULL; | ||
264 | } | ||
265 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from peer 2 `%4s'\n", | ||
266 | GNUNET_i2s (&pos->peer2->id)); | ||
267 | if (pos->peer2handle != NULL) | ||
268 | { | ||
269 | GNUNET_CORE_disconnect (pos->peer2handle); | ||
270 | pos->peer2handle = NULL; | ||
271 | } | ||
272 | pos->disconnect_task = GNUNET_SCHEDULER_NO_TASK; | ||
273 | /* Decrement total connections so new can be established */ | ||
274 | total_server_connections -= 2; | ||
275 | } | ||
276 | |||
277 | #if DO_STATS | ||
278 | static void | ||
279 | stats_finished (void *cls, int result) | ||
280 | { | ||
281 | GNUNET_SCHEDULER_add_now (&finish_testing, NULL); | ||
282 | } | ||
283 | |||
284 | /** | ||
285 | * Callback function to process statistic values. | ||
286 | * | ||
287 | * @param cls closure | ||
288 | * @param peer the peer the statistics belong to | ||
289 | * @param subsystem name of subsystem that created the statistic | ||
290 | * @param name the name of the datum | ||
291 | * @param value the current value | ||
292 | * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not | ||
293 | * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration | ||
294 | */ | ||
295 | static int | ||
296 | stats_print (void *cls, const struct GNUNET_PeerIdentity *peer, | ||
297 | const char *subsystem, const char *name, uint64_t value, | ||
298 | int is_persistent) | ||
299 | { | ||
300 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s:%s:%s -- %llu\n", GNUNET_i2s (peer), | ||
301 | subsystem, name, value); | ||
302 | return GNUNET_OK; | ||
303 | } | ||
304 | #endif | ||
305 | |||
306 | |||
307 | static void | ||
308 | topology_cb (void *cls, const struct GNUNET_PeerIdentity *first, | ||
309 | const struct GNUNET_PeerIdentity *second, const char *emsg) | ||
310 | { | ||
311 | FILE *outfile = cls; | ||
312 | |||
313 | if (first != NULL) | ||
314 | { | ||
315 | if (outfile != NULL) | ||
316 | { | ||
317 | FPRINTF (outfile, "\t\"%s\" -- ", GNUNET_i2s (first)); | ||
318 | FPRINTF (outfile, "\"%s\";\n", GNUNET_i2s (second)); | ||
319 | } | ||
320 | topology_connections++; | ||
321 | } | ||
322 | else | ||
323 | { | ||
324 | FPRINTF (stderr, | ||
325 | "Finished iterating over topology, %d total connections!\n", | ||
326 | topology_connections); | ||
327 | if (outfile != NULL) | ||
328 | { | ||
329 | FPRINTF (outfile, "%s", "}\n"); | ||
330 | FCLOSE (outfile); | ||
331 | #if DO_STATS | ||
332 | GNUNET_TESTING_get_statistics (pg, &stats_finished, &stats_print, NULL); | ||
333 | #endif | ||
334 | GNUNET_SCHEDULER_add_now (&finish_testing, NULL); | ||
335 | } | ||
336 | } | ||
337 | } | ||
338 | |||
339 | |||
340 | static int | ||
341 | process_mtype (void *cls, const struct GNUNET_PeerIdentity *peer, | ||
342 | const struct GNUNET_MessageHeader *message, | ||
343 | const struct GNUNET_ATS_Information *atsi, | ||
344 | unsigned int atsi_count) | ||
345 | { | ||
346 | char *dotOutFileNameFinished; | ||
347 | FILE *dotOutFileFinished; | ||
348 | struct TestMessageContext *pos = cls; | ||
349 | struct GNUNET_TestMessage *msg = (struct GNUNET_TestMessage *) message; | ||
350 | |||
351 | if (pos->uid != ntohl (msg->uid)) | ||
352 | return GNUNET_OK; | ||
353 | |||
354 | #if PROGRESS_BARS | ||
355 | if ((total_messages_received) % modnum == 0) | ||
356 | { | ||
357 | if (total_messages_received == 0) | ||
358 | FPRINTF (stdout, "%s", "0%%"); | ||
359 | else | ||
360 | FPRINTF (stdout, "%d%%", | ||
361 | (int) (((float) total_messages_received / expected_messages) * | ||
362 | 100)); | ||
363 | |||
364 | } | ||
365 | else if (total_messages_received % dotnum == 0) | ||
366 | { | ||
367 | FPRINTF (stdout, "%s", "."); | ||
368 | } | ||
369 | fflush (stdout); | ||
370 | #endif | ||
371 | |||
372 | total_messages_received++; | ||
373 | |||
374 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
375 | "Received message from `%4s', type %d.\n", GNUNET_i2s (peer), | ||
376 | ntohs (message->type)); | ||
377 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
378 | "Total messages received %d, expected %d.\n", | ||
379 | total_messages_received, expected_messages); | ||
380 | |||
381 | if (total_messages_received == expected_messages) | ||
382 | { | ||
383 | #if PROGRESS_BARS | ||
384 | FPRINTF (stdout, "%s", "100%%]\n"); | ||
385 | #endif | ||
386 | GNUNET_SCHEDULER_cancel (die_task); | ||
387 | GNUNET_asprintf (&dotOutFileNameFinished, "%s.dot", "final_topology"); | ||
388 | dotOutFileFinished = FOPEN (dotOutFileNameFinished, "w"); | ||
389 | GNUNET_free (dotOutFileNameFinished); | ||
390 | if (dotOutFileFinished != NULL) | ||
391 | { | ||
392 | FPRINTF (dotOutFileFinished, "%s", "strict graph G {\n"); | ||
393 | } | ||
394 | topology_connections = 0; | ||
395 | GNUNET_TESTING_get_topology (pg, &topology_cb, dotOutFileFinished); | ||
396 | //GNUNET_SCHEDULER_add_now (&finish_testing, NULL); | ||
397 | } | ||
398 | else | ||
399 | { | ||
400 | pos->disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cores, pos); | ||
401 | } | ||
402 | |||
403 | return GNUNET_OK; | ||
404 | } | ||
405 | |||
406 | |||
407 | static void | ||
408 | end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
409 | { | ||
410 | char *msg = cls; | ||
411 | |||
412 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
413 | "Ending with error: %s\n", msg); | ||
414 | struct TestMessageContext *pos; | ||
415 | struct TestMessageContext *free_pos; | ||
416 | |||
417 | pos = test_messages; | ||
418 | while (pos != NULL) | ||
419 | { | ||
420 | if (pos->peer1handle != NULL) | ||
421 | { | ||
422 | GNUNET_CORE_disconnect (pos->peer1handle); | ||
423 | pos->peer1handle = NULL; | ||
424 | } | ||
425 | if (pos->peer2handle != NULL) | ||
426 | { | ||
427 | GNUNET_CORE_disconnect (pos->peer2handle); | ||
428 | pos->peer2handle = NULL; | ||
429 | } | ||
430 | free_pos = pos; | ||
431 | pos = pos->next; | ||
432 | GNUNET_free (free_pos); | ||
433 | } | ||
434 | |||
435 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
436 | "Transmit_ready's scheduled %d, failed %d, transmit_ready's called %d\n", | ||
437 | transmit_ready_scheduled, transmit_ready_failed, | ||
438 | transmit_ready_called); | ||
439 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
440 | "Total messages received %d, expected %d.\n", | ||
441 | total_messages_received, expected_messages); | ||
442 | |||
443 | if (pg != NULL) | ||
444 | { | ||
445 | GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL); | ||
446 | ok = 7331; /* Opposite of leet */ | ||
447 | } | ||
448 | else | ||
449 | ok = 401; /* Never got peers started */ | ||
450 | |||
451 | if (dotOutFile != NULL) | ||
452 | { | ||
453 | FPRINTF (dotOutFile, "%s", "}"); | ||
454 | FCLOSE (dotOutFile); | ||
455 | } | ||
456 | } | ||
457 | |||
458 | |||
459 | static size_t | ||
460 | transmit_ready (void *cls, size_t size, void *buf) | ||
461 | { | ||
462 | struct GNUNET_TestMessage *m; | ||
463 | struct TestMessageContext *pos = cls; | ||
464 | |||
465 | GNUNET_assert (buf != NULL); | ||
466 | m = (struct GNUNET_TestMessage *) buf; | ||
467 | m->header.type = htons (MTYPE); | ||
468 | m->header.size = htons (sizeof (struct GNUNET_TestMessage)); | ||
469 | m->uid = htonl (pos->uid); | ||
470 | transmit_ready_called++; | ||
471 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
472 | "transmit ready for peer %s\ntransmit_ready's scheduled %d, transmit_ready's called %d\n", | ||
473 | GNUNET_i2s (&pos->peer1->id), transmit_ready_scheduled, | ||
474 | transmit_ready_called); | ||
475 | return sizeof (struct GNUNET_TestMessage); | ||
476 | } | ||
477 | |||
478 | |||
479 | static struct GNUNET_CORE_MessageHandler no_handlers[] = { | ||
480 | {NULL, 0, 0} | ||
481 | }; | ||
482 | |||
483 | |||
484 | static struct GNUNET_CORE_MessageHandler handlers[] = { | ||
485 | {&process_mtype, MTYPE, sizeof (struct GNUNET_TestMessage)}, | ||
486 | {NULL, 0, 0} | ||
487 | }; | ||
488 | |||
489 | |||
490 | static void | ||
491 | init_notify_peer2 (void *cls, struct GNUNET_CORE_Handle *server, | ||
492 | const struct GNUNET_PeerIdentity *my_identity) | ||
493 | { | ||
494 | struct TestMessageContext *pos = cls; | ||
495 | |||
496 | total_server_connections++; | ||
497 | |||
498 | pos->peer2connected = GNUNET_YES; | ||
499 | if (pos->peer1notified == GNUNET_YES) /* Peer 1 has been notified of connection to peer 2 */ | ||
500 | { | ||
501 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
502 | "Scheduling message send to peer `%s' from peer `%s' (init_notify_peer2)\n", | ||
503 | GNUNET_i2s (my_identity), | ||
504 | GNUNET_h2s (&pos->peer1->id.hashPubKey)); | ||
505 | if (NULL == | ||
506 | GNUNET_CORE_notify_transmit_ready (pos->peer1handle, GNUNET_YES, 0, | ||
507 | TIMEOUT, &pos->peer2->id, | ||
508 | sizeof (struct GNUNET_TestMessage), | ||
509 | &transmit_ready, pos)) | ||
510 | { | ||
511 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
512 | "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n", | ||
513 | GNUNET_i2s (&pos->peer2->id)); | ||
514 | transmit_ready_failed++; | ||
515 | } | ||
516 | else | ||
517 | { | ||
518 | transmit_ready_scheduled++; | ||
519 | } | ||
520 | } | ||
521 | } | ||
522 | |||
523 | |||
524 | /** | ||
525 | * Method called whenever a given peer connects. | ||
526 | * | ||
527 | * @param cls closure | ||
528 | * @param peer peer identity this notification is about | ||
529 | * @param atsi performance data for the connection | ||
530 | * @param atsi_count number of records in 'atsi' | ||
531 | */ | ||
532 | static void | ||
533 | connect_notify_peers (void *cls, const struct GNUNET_PeerIdentity *peer, | ||
534 | const struct GNUNET_ATS_Information *atsi, | ||
535 | unsigned int atsi_count) | ||
536 | { | ||
537 | struct TestMessageContext *pos = cls; | ||
538 | |||
539 | if (0 == memcmp (peer, &pos->peer2->id, sizeof (struct GNUNET_PeerIdentity))) | ||
540 | { | ||
541 | pos->peer1notified = GNUNET_YES; | ||
542 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
543 | "Peer `%s' notified of connection to peer `%s'\n", | ||
544 | GNUNET_i2s (&pos->peer1->id), GNUNET_h2s (&peer->hashPubKey)); | ||
545 | } | ||
546 | else | ||
547 | return; | ||
548 | |||
549 | if (pos->peer2connected == GNUNET_YES) /* Already connected and notified of connection, send message! */ | ||
550 | { | ||
551 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
552 | "Scheduling message send to peer `%s' from peer `%s' (init_notify_peer2)\n", | ||
553 | GNUNET_i2s (&pos->peer2->id), | ||
554 | GNUNET_h2s (&pos->peer1->id.hashPubKey)); | ||
555 | if (NULL == | ||
556 | GNUNET_CORE_notify_transmit_ready (pos->peer1handle, GNUNET_YES, 0, | ||
557 | TIMEOUT, &pos->peer2->id, | ||
558 | sizeof (struct GNUNET_TestMessage), | ||
559 | &transmit_ready, pos)) | ||
560 | { | ||
561 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
562 | "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n", | ||
563 | GNUNET_i2s (&pos->peer2->id)); | ||
564 | transmit_ready_failed++; | ||
565 | } | ||
566 | else | ||
567 | { | ||
568 | transmit_ready_scheduled++; | ||
569 | } | ||
570 | } | ||
571 | } | ||
572 | |||
573 | |||
574 | static void | ||
575 | init_notify_peer1 (void *cls, struct GNUNET_CORE_Handle *server, | ||
576 | const struct GNUNET_PeerIdentity *my_identity) | ||
577 | { | ||
578 | struct TestMessageContext *pos = cls; | ||
579 | |||
580 | total_server_connections++; | ||
581 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
582 | "Core connection to `%4s' established, setting up handles\n", | ||
583 | GNUNET_i2s (my_identity)); | ||
584 | /* | ||
585 | * Connect to the receiving peer | ||
586 | */ | ||
587 | pos->peer2handle = | ||
588 | GNUNET_CORE_connect (pos->peer2->cfg, pos, &init_notify_peer2, NULL, | ||
589 | NULL, NULL, GNUNET_YES, NULL, GNUNET_YES, handlers); | ||
590 | |||
591 | } | ||
592 | |||
593 | |||
594 | static void | ||
595 | send_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
596 | { | ||
597 | struct TestMessageContext *pos = cls; | ||
598 | |||
599 | if ((pos == test_messages) && (settle_time.rel_value > 0)) | ||
600 | { | ||
601 | topology_connections = 0; | ||
602 | GNUNET_TESTING_get_topology (pg, &topology_cb, NULL); | ||
603 | } | ||
604 | if (((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0) || (cls == NULL)) | ||
605 | return; | ||
606 | |||
607 | if (die_task == GNUNET_SCHEDULER_NO_TASK) | ||
608 | { | ||
609 | die_task = | ||
610 | GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT, &end_badly, | ||
611 | "from send test messages (timeout)"); | ||
612 | } | ||
613 | |||
614 | if (total_server_connections >= MAX_OUTSTANDING_CONNECTIONS) | ||
615 | { | ||
616 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | ||
617 | (GNUNET_TIME_UNIT_SECONDS, 1), | ||
618 | &send_test_messages, pos); | ||
619 | return; /* Otherwise we'll double schedule messages here! */ | ||
620 | } | ||
621 | |||
622 | /* | ||
623 | * Connect to the sending peer | ||
624 | */ | ||
625 | pos->peer1handle = | ||
626 | GNUNET_CORE_connect (pos->peer1->cfg, pos, &init_notify_peer1, | ||
627 | &connect_notify_peers, NULL, NULL, GNUNET_NO, NULL, | ||
628 | GNUNET_NO, no_handlers); | ||
629 | |||
630 | GNUNET_assert (pos->peer1handle != NULL); | ||
631 | |||
632 | if (total_server_connections < MAX_OUTSTANDING_CONNECTIONS) | ||
633 | { | ||
634 | GNUNET_SCHEDULER_add_now (&send_test_messages, pos->next); | ||
635 | } | ||
636 | else | ||
637 | { | ||
638 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | ||
639 | (GNUNET_TIME_UNIT_SECONDS, 1), | ||
640 | &send_test_messages, pos->next); | ||
641 | } | ||
642 | } | ||
643 | |||
644 | |||
645 | static void | ||
646 | topology_callback (void *cls, const struct GNUNET_PeerIdentity *first, | ||
647 | const struct GNUNET_PeerIdentity *second, uint32_t distance, | ||
648 | const struct GNUNET_CONFIGURATION_Handle *first_cfg, | ||
649 | const struct GNUNET_CONFIGURATION_Handle *second_cfg, | ||
650 | struct GNUNET_TESTING_Daemon *first_daemon, | ||
651 | struct GNUNET_TESTING_Daemon *second_daemon, | ||
652 | const char *emsg) | ||
653 | { | ||
654 | struct TestMessageContext *temp_context; | ||
655 | |||
656 | if (emsg == NULL) | ||
657 | { | ||
658 | #if PROGRESS_BARS | ||
659 | if ((total_connections) % modnum == 0) | ||
660 | { | ||
661 | if (total_connections == 0) | ||
662 | FPRINTF (stdout, "%s", "0%%"); | ||
663 | else | ||
664 | FPRINTF (stdout, "%d%%", | ||
665 | (int) (((float) total_connections / expected_connections) * | ||
666 | 100)); | ||
667 | |||
668 | } | ||
669 | else if (total_connections % dotnum == 0) | ||
670 | { | ||
671 | FPRINTF (stdout, "%s", "."); | ||
672 | } | ||
673 | fflush (stdout); | ||
674 | #endif | ||
675 | total_connections++; | ||
676 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "connected peer %s to peer %s\n", | ||
677 | first_daemon->shortname, second_daemon->shortname); | ||
678 | temp_context = GNUNET_malloc (sizeof (struct TestMessageContext)); | ||
679 | temp_context->peer1 = first_daemon; | ||
680 | temp_context->peer2 = second_daemon; | ||
681 | temp_context->next = test_messages; | ||
682 | temp_context->uid = total_connections; | ||
683 | temp_context->disconnect_task = GNUNET_SCHEDULER_NO_TASK; | ||
684 | test_messages = temp_context; | ||
685 | |||
686 | expected_messages++; | ||
687 | if (dotOutFile != NULL) | ||
688 | FPRINTF (dotOutFile, "\tn%s -- n%s;\n", first_daemon->shortname, | ||
689 | second_daemon->shortname); | ||
690 | } | ||
691 | else | ||
692 | { | ||
693 | failed_connections++; | ||
694 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
695 | "Failed to connect peer %s to peer %s with error :\n%s\n", | ||
696 | first_daemon->shortname, second_daemon->shortname, emsg); | ||
697 | } | ||
698 | |||
699 | if (total_connections == expected_connections) | ||
700 | { | ||
701 | #if PROGRESS_BARS | ||
702 | FPRINTF (stdout, "%s", "100%%]\n"); | ||
703 | #endif | ||
704 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
705 | "Created %d total connections, which is our target number! Calling send messages.\n", | ||
706 | total_connections); | ||
707 | modnum = expected_messages / 4; | ||
708 | dotnum = (expected_messages / 50) + 1; | ||
709 | if (modnum == 0) | ||
710 | modnum = 1; | ||
711 | if (dotnum == 0) | ||
712 | dotnum = 1; | ||
713 | GNUNET_SCHEDULER_cancel (die_task); | ||
714 | die_task = GNUNET_SCHEDULER_NO_TASK; | ||
715 | #if DELAY_FOR_LOGGING | ||
716 | FPRINTF (stdout, "%s", "Sending test messages in 10 seconds.\n"); | ||
717 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | ||
718 | (GNUNET_TIME_UNIT_SECONDS, 10), | ||
719 | &send_test_messages, test_messages); | ||
720 | gather_log_data (); | ||
721 | #else | ||
722 | if (settle_time.rel_value > 0) | ||
723 | { | ||
724 | GNUNET_TESTING_get_topology (pg, &topology_cb, NULL); | ||
725 | } | ||
726 | GNUNET_SCHEDULER_add_delayed (settle_time, &send_test_messages, | ||
727 | test_messages); | ||
728 | #endif | ||
729 | #if PROGRESS_BARS | ||
730 | FPRINTF (stdout, "%s", "Test message progress: ["); | ||
731 | #endif | ||
732 | |||
733 | } | ||
734 | else if (total_connections + failed_connections == expected_connections) | ||
735 | { | ||
736 | if (failed_connections < | ||
737 | (unsigned int) (fail_percentage * total_connections)) | ||
738 | { | ||
739 | GNUNET_SCHEDULER_cancel (die_task); | ||
740 | die_task = GNUNET_SCHEDULER_NO_TASK; | ||
741 | GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages); | ||
742 | } | ||
743 | else | ||
744 | { | ||
745 | GNUNET_SCHEDULER_cancel (die_task); | ||
746 | die_task = | ||
747 | GNUNET_SCHEDULER_add_now (&end_badly, | ||
748 | "from topology_callback (too many failed connections)"); | ||
749 | } | ||
750 | } | ||
751 | else | ||
752 | { | ||
753 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
754 | "Have %d total connections, %d failed connections, Want %d (at least %d)\n", | ||
755 | total_connections, failed_connections, expected_connections, | ||
756 | expected_connections - | ||
757 | (unsigned int) (fail_percentage * expected_connections)); | ||
758 | } | ||
759 | } | ||
760 | |||
761 | |||
762 | static void | ||
763 | topology_creation_finished (void *cls, const char *emsg) | ||
764 | { | ||
765 | if (emsg == NULL) | ||
766 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
767 | "All topology connections created successfully!\n"); | ||
768 | } | ||
769 | |||
770 | |||
771 | static void | ||
772 | connect_topology () | ||
773 | { | ||
774 | expected_connections = -1; | ||
775 | if ((pg != NULL) && (peers_left == 0)) | ||
776 | { | ||
777 | expected_connections = | ||
778 | GNUNET_TESTING_connect_topology (pg, connection_topology, | ||
779 | connect_topology_option, | ||
780 | connect_topology_option_modifier, | ||
781 | connect_timeout, connect_attempts, | ||
782 | &topology_creation_finished, NULL); | ||
783 | #if PROGRESS_BARS | ||
784 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Have %d expected connections\n", | ||
785 | expected_connections); | ||
786 | #endif | ||
787 | } | ||
788 | |||
789 | GNUNET_SCHEDULER_cancel (die_task); | ||
790 | if (expected_connections < 1) | ||
791 | { | ||
792 | die_task = | ||
793 | GNUNET_SCHEDULER_add_now (&end_badly, | ||
794 | "from connect topology (bad return)"); | ||
795 | return; | ||
796 | } | ||
797 | |||
798 | die_task = | ||
799 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | ||
800 | (GNUNET_TIME_UNIT_SECONDS, | ||
801 | SECONDS_PER_PEER_START * num_peers), | ||
802 | &end_badly, | ||
803 | "from connect topology (timeout)"); | ||
804 | modnum = expected_connections / 4; | ||
805 | dotnum = (expected_connections / 50) + 1; | ||
806 | if (modnum == 0) | ||
807 | modnum = 1; | ||
808 | if (dotnum == 0) | ||
809 | dotnum = 1; | ||
810 | #if PROGRESS_BARS | ||
811 | FPRINTF (stdout, "%s", "Peer connection progress: ["); | ||
812 | #endif | ||
813 | } | ||
814 | |||
815 | static void | ||
816 | create_topology () | ||
817 | { | ||
818 | peers_left = num_peers; /* Reset counter */ | ||
819 | if (GNUNET_TESTING_create_topology | ||
820 | (pg, topology, blacklist_topology, blacklist_transports) != GNUNET_SYSERR) | ||
821 | { | ||
822 | #if PROGRESS_BARS | ||
823 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
824 | "Topology set up, now starting peers!\n"); | ||
825 | FPRINTF (stdout, "%s", "Daemon start progress ["); | ||
826 | #endif | ||
827 | GNUNET_TESTING_daemons_continue_startup (pg); | ||
828 | } | ||
829 | else | ||
830 | { | ||
831 | GNUNET_SCHEDULER_cancel (die_task); | ||
832 | die_task = | ||
833 | GNUNET_SCHEDULER_add_now (&end_badly, | ||
834 | "from create topology (bad return)"); | ||
835 | } | ||
836 | GNUNET_SCHEDULER_cancel (die_task); | ||
837 | die_task = | ||
838 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | ||
839 | (GNUNET_TIME_UNIT_SECONDS, | ||
840 | SECONDS_PER_PEER_START * num_peers), | ||
841 | &end_badly, | ||
842 | "from continue startup (timeout)"); | ||
843 | } | ||
844 | |||
845 | |||
846 | static void | ||
847 | peers_started_callback (void *cls, const struct GNUNET_PeerIdentity *id, | ||
848 | const struct GNUNET_CONFIGURATION_Handle *cfg, | ||
849 | struct GNUNET_TESTING_Daemon *d, const char *emsg) | ||
850 | { | ||
851 | if (emsg != NULL) | ||
852 | { | ||
853 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
854 | "Failed to start daemon with error: `%s'\n", emsg); | ||
855 | return; | ||
856 | } | ||
857 | GNUNET_assert (id != NULL); | ||
858 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started daemon %llu out of %llu\n", | ||
859 | (num_peers - peers_left) + 1, num_peers); | ||
860 | #if PROGRESS_BARS | ||
861 | if ((num_peers - peers_left) % modnum == 0) | ||
862 | { | ||
863 | if (num_peers - peers_left == 0) | ||
864 | FPRINTF (stdout, "%s", "0%%"); | ||
865 | else | ||
866 | FPRINTF (stdout, "%d%%", | ||
867 | (int) (((float) (num_peers - peers_left) / num_peers) * 100)); | ||
868 | |||
869 | } | ||
870 | else if ((num_peers - peers_left) % dotnum == 0) | ||
871 | { | ||
872 | FPRINTF (stdout, "%s", "."); | ||
873 | } | ||
874 | fflush (stdout); | ||
875 | #endif | ||
876 | peers_left--; | ||
877 | if (peers_left == 0) | ||
878 | { | ||
879 | #if PROGRESS_BARS | ||
880 | FPRINTF (stdout, "%s", "100%%]\n"); | ||
881 | #endif | ||
882 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
883 | "All %d daemons started, now connecting peers!\n", num_peers); | ||
884 | GNUNET_SCHEDULER_cancel (die_task); | ||
885 | /* Set up task in case topology creation doesn't finish | ||
886 | * within a reasonable amount of time */ | ||
887 | die_task = | ||
888 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | ||
889 | (GNUNET_TIME_UNIT_MINUTES, 8), &end_badly, | ||
890 | "from peers_started_callback"); | ||
891 | #if DELAY_FOR_LOGGING | ||
892 | FPRINTF (stdout, "%s", "Connecting topology in 10 seconds\n"); | ||
893 | gather_log_data (); | ||
894 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | ||
895 | (GNUNET_TIME_UNIT_SECONDS, 10), | ||
896 | &connect_topology, NULL); | ||
897 | #else | ||
898 | connect_topology (); | ||
899 | #endif | ||
900 | ok = 0; | ||
901 | } | ||
902 | } | ||
903 | |||
904 | /** | ||
905 | * Callback indicating that the hostkey was created for a peer. | ||
906 | * | ||
907 | * @param cls NULL | ||
908 | * @param id the peer identity | ||
909 | * @param d the daemon handle (pretty useless at this point, remove?) | ||
910 | * @param emsg non-null on failure | ||
911 | */ | ||
912 | void | ||
913 | hostkey_callback (void *cls, const struct GNUNET_PeerIdentity *id, | ||
914 | struct GNUNET_TESTING_Daemon *d, const char *emsg) | ||
915 | { | ||
916 | if (emsg != NULL) | ||
917 | { | ||
918 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
919 | "Hostkey callback received error: %s\n", emsg); | ||
920 | } | ||
921 | |||
922 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
923 | "Hostkey (%d/%d) created for peer `%s'\n", num_peers - peers_left, | ||
924 | num_peers, GNUNET_i2s (id)); | ||
925 | #if PROGRESS_BARS | ||
926 | if ((num_peers - peers_left) % modnum == 0) | ||
927 | { | ||
928 | if (num_peers - peers_left == 0) | ||
929 | FPRINTF (stdout, "%s", "0%%"); | ||
930 | else | ||
931 | FPRINTF (stdout, "%d%%", | ||
932 | (int) (((float) (num_peers - peers_left) / num_peers) * 100)); | ||
933 | |||
934 | } | ||
935 | else if ((num_peers - peers_left) % dotnum == 0) | ||
936 | { | ||
937 | FPRINTF (stdout, "%s", "."); | ||
938 | } | ||
939 | fflush (stdout); | ||
940 | #endif | ||
941 | peers_left--; | ||
942 | if (peers_left == 0) | ||
943 | { | ||
944 | #if PROGRESS_BARS | ||
945 | FPRINTF (stdout, "%s", "100%%]\n"); | ||
946 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
947 | "All %d hostkeys created, now creating topology!\n", num_peers); | ||
948 | #endif | ||
949 | GNUNET_SCHEDULER_cancel (die_task); | ||
950 | /* Set up task in case topology creation doesn't finish | ||
951 | * within a reasonable amount of time */ | ||
952 | die_task = | ||
953 | GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, | ||
954 | "from create_topology"); | ||
955 | GNUNET_SCHEDULER_add_now (&create_topology, NULL); | ||
956 | ok = 0; | ||
957 | } | ||
958 | } | ||
959 | |||
960 | |||
961 | static void | ||
962 | run (void *cls, char *const *args, const char *cfgfile, | ||
963 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
964 | { | ||
965 | char *topology_str; | ||
966 | char *connect_topology_str; | ||
967 | char *blacklist_topology_str; | ||
968 | char *connect_topology_option_str; | ||
969 | char *connect_topology_option_modifier_string; | ||
970 | unsigned long long max_outstanding_connections; | ||
971 | |||
972 | ok = 1; | ||
973 | |||
974 | dotOutFile = FOPEN (dotOutFileName, "w"); | ||
975 | if (dotOutFile != NULL) | ||
976 | { | ||
977 | FPRINTF (dotOutFile, "%s", "strict graph G {\n"); | ||
978 | } | ||
979 | |||
980 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
981 | "Starting daemons based on config file %s\n", cfgfile); | ||
982 | if (GNUNET_YES != | ||
983 | GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome", | ||
984 | &test_directory)) | ||
985 | { | ||
986 | ok = 404; | ||
987 | return; | ||
988 | } | ||
989 | |||
990 | if ((GNUNET_YES == | ||
991 | GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "topology", | ||
992 | &topology_str)) && | ||
993 | (GNUNET_NO == GNUNET_TESTING_topology_get (&topology, topology_str))) | ||
994 | { | ||
995 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
996 | "Invalid topology `%s' given for section %s option %s\n", | ||
997 | topology_str, "TESTING", "TOPOLOGY"); | ||
998 | topology = GNUNET_TESTING_TOPOLOGY_CLIQUE; /* Defaults to NONE, so set better default here */ | ||
999 | } | ||
1000 | |||
1001 | if ((GNUNET_YES == | ||
1002 | GNUNET_CONFIGURATION_get_value_string (cfg, "testing", | ||
1003 | "connect_topology", | ||
1004 | &connect_topology_str)) && | ||
1005 | (GNUNET_NO == | ||
1006 | GNUNET_TESTING_topology_get (&connection_topology, | ||
1007 | connect_topology_str))) | ||
1008 | { | ||
1009 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
1010 | "Invalid connect topology `%s' given for section %s option %s\n", | ||
1011 | connect_topology_str, "TESTING", "CONNECT_TOPOLOGY"); | ||
1012 | } | ||
1013 | GNUNET_free_non_null (connect_topology_str); | ||
1014 | if ((GNUNET_YES == | ||
1015 | GNUNET_CONFIGURATION_get_value_string (cfg, "testing", | ||
1016 | "connect_topology_option", | ||
1017 | &connect_topology_option_str)) && | ||
1018 | (GNUNET_NO == | ||
1019 | GNUNET_TESTING_topology_option_get (&connect_topology_option, | ||
1020 | connect_topology_option_str))) | ||
1021 | { | ||
1022 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
1023 | "Invalid connect topology option `%s' given for section %s option %s\n", | ||
1024 | connect_topology_option_str, "TESTING", | ||
1025 | "CONNECT_TOPOLOGY_OPTION"); | ||
1026 | connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL; /* Defaults to NONE, set to ALL */ | ||
1027 | } | ||
1028 | GNUNET_free_non_null (connect_topology_option_str); | ||
1029 | if (GNUNET_YES == | ||
1030 | GNUNET_CONFIGURATION_get_value_string (cfg, "testing", | ||
1031 | "connect_topology_option_modifier", | ||
1032 | &connect_topology_option_modifier_string)) | ||
1033 | { | ||
1034 | if (SSCANF | ||
1035 | (connect_topology_option_modifier_string, "%lf", | ||
1036 | &connect_topology_option_modifier) != 1) | ||
1037 | { | ||
1038 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
1039 | _ | ||
1040 | ("Invalid value `%s' for option `%s' in section `%s': expected float\n"), | ||
1041 | connect_topology_option_modifier_string, | ||
1042 | "connect_topology_option_modifier", "TESTING"); | ||
1043 | } | ||
1044 | GNUNET_free (connect_topology_option_modifier_string); | ||
1045 | } | ||
1046 | |||
1047 | if (GNUNET_YES != | ||
1048 | GNUNET_CONFIGURATION_get_value_string (cfg, "testing", | ||
1049 | "blacklist_transports", | ||
1050 | &blacklist_transports)) | ||
1051 | blacklist_transports = NULL; | ||
1052 | |||
1053 | if ((GNUNET_YES == | ||
1054 | GNUNET_CONFIGURATION_get_value_string (cfg, "testing", | ||
1055 | "blacklist_topology", | ||
1056 | &blacklist_topology_str)) && | ||
1057 | (GNUNET_NO == | ||
1058 | GNUNET_TESTING_topology_get (&blacklist_topology, | ||
1059 | blacklist_topology_str))) | ||
1060 | { | ||
1061 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
1062 | "Invalid topology `%s' given for section %s option %s\n", | ||
1063 | topology_str, "TESTING", "BLACKLIST_TOPOLOGY"); | ||
1064 | } | ||
1065 | GNUNET_free_non_null (topology_str); | ||
1066 | GNUNET_free_non_null (blacklist_topology_str); | ||
1067 | |||
1068 | if (GNUNET_OK != | ||
1069 | GNUNET_CONFIGURATION_get_value_time (cfg, "testing", "SETTLE_TIME", | ||
1070 | &settle_time)) | ||
1071 | { | ||
1072 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", | ||
1073 | "testing", "SETTLE_TIME"); | ||
1074 | return; | ||
1075 | } | ||
1076 | |||
1077 | if (GNUNET_OK != | ||
1078 | GNUNET_CONFIGURATION_get_value_time (cfg, "testing", "CONNECT_TIMEOUT", | ||
1079 | &connect_timeout)) | ||
1080 | { | ||
1081 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", | ||
1082 | "testing", "CONNECT_TIMEOUT"); | ||
1083 | return; | ||
1084 | } | ||
1085 | |||
1086 | |||
1087 | if (GNUNET_OK != | ||
1088 | GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "connect_attempts", | ||
1089 | &connect_attempts)) | ||
1090 | { | ||
1091 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", | ||
1092 | "testing", "connect_attempts"); | ||
1093 | return; | ||
1094 | } | ||
1095 | |||
1096 | if (GNUNET_OK != | ||
1097 | GNUNET_CONFIGURATION_get_value_number (cfg, "testing", | ||
1098 | "max_outstanding_connections", | ||
1099 | &max_outstanding_connections)) | ||
1100 | { | ||
1101 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", | ||
1102 | "testing", "max_outstanding_connections"); | ||
1103 | return; | ||
1104 | } | ||
1105 | |||
1106 | if (GNUNET_SYSERR == | ||
1107 | GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers", | ||
1108 | &num_peers)) | ||
1109 | num_peers = DEFAULT_NUM_PEERS; | ||
1110 | |||
1111 | main_cfg = cfg; | ||
1112 | |||
1113 | peers_left = num_peers; | ||
1114 | modnum = num_peers / 4; | ||
1115 | dotnum = (num_peers / 50) + 1; | ||
1116 | if (modnum == 0) | ||
1117 | modnum = 1; | ||
1118 | if (dotnum == 0) | ||
1119 | dotnum = 1; | ||
1120 | #if PROGRESS_BARS | ||
1121 | FPRINTF (stdout, "%s", "Hostkey generation progress: ["); | ||
1122 | #endif | ||
1123 | /* Set up a task to end testing if peer start fails */ | ||
1124 | die_task = | ||
1125 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | ||
1126 | (GNUNET_TIME_UNIT_SECONDS, | ||
1127 | SECONDS_PER_PEER_START * num_peers), | ||
1128 | &end_badly, | ||
1129 | "didn't generate all hostkeys within a reasonable amount of time!!!"); | ||
1130 | |||
1131 | GNUNET_assert (num_peers > 0 && num_peers < (unsigned int) -1); | ||
1132 | pg = GNUNET_TESTING_daemons_start (cfg, peers_left, | ||
1133 | max_outstanding_connections, peers_left, | ||
1134 | GNUNET_TIME_relative_multiply | ||
1135 | (GNUNET_TIME_UNIT_SECONDS, | ||
1136 | SECONDS_PER_PEER_START * num_peers), | ||
1137 | &hostkey_callback, NULL, | ||
1138 | &peers_started_callback, NULL, | ||
1139 | &topology_callback, NULL, NULL); | ||
1140 | |||
1141 | } | ||
1142 | |||
1143 | |||
1144 | static int | ||
1145 | check () | ||
1146 | { | ||
1147 | char *binary_name; | ||
1148 | char *config_file_name; | ||
1149 | |||
1150 | GNUNET_asprintf (&binary_name, "test-testing-topology-%s", topology_string); | ||
1151 | GNUNET_asprintf (&config_file_name, "test_testing_data_topology_%s.conf", | ||
1152 | topology_string); | ||
1153 | int ret; | ||
1154 | |||
1155 | char *const argv[] = { binary_name, | ||
1156 | "-c", | ||
1157 | config_file_name, | ||
1158 | NULL | ||
1159 | }; | ||
1160 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
1161 | GNUNET_GETOPT_OPTION_END | ||
1162 | }; | ||
1163 | ret = | ||
1164 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv, | ||
1165 | binary_name, "nohelp", options, &run, &ok); | ||
1166 | if (ret != GNUNET_OK) | ||
1167 | { | ||
1168 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
1169 | "`test-testing-topology-%s': Failed with error code %d\n", | ||
1170 | topology_string, ret); | ||
1171 | } | ||
1172 | GNUNET_free (binary_name); | ||
1173 | GNUNET_free (config_file_name); | ||
1174 | return ok; | ||
1175 | } | ||
1176 | |||
1177 | |||
1178 | int | ||
1179 | main (int argc, char *argv[]) | ||
1180 | { | ||
1181 | int ret; | ||
1182 | char *binary_start_pos; | ||
1183 | char *our_binary_name; | ||
1184 | char *dotexe; | ||
1185 | |||
1186 | binary_start_pos = strchr (argv[0], '/'); | ||
1187 | GNUNET_assert (binary_start_pos != NULL); | ||
1188 | topology_string = strstr (binary_start_pos, "_topology"); | ||
1189 | GNUNET_assert (topology_string != NULL); | ||
1190 | topology_string++; | ||
1191 | topology_string = strstr (topology_string, "_"); | ||
1192 | GNUNET_assert (topology_string != NULL); | ||
1193 | topology_string++; | ||
1194 | topology_string = GNUNET_strdup (topology_string); | ||
1195 | if (NULL != (dotexe = strstr (topology_string, ".exe"))) | ||
1196 | dotexe[0] = '\0'; | ||
1197 | GNUNET_asprintf (&our_binary_name, "test-testing-topology_%s", | ||
1198 | topology_string); | ||
1199 | GNUNET_asprintf (&dotOutFileName, "topology_%s.dot", topology_string); | ||
1200 | |||
1201 | GNUNET_log_setup (our_binary_name, | ||
1202 | "WARNING", | ||
1203 | NULL); | ||
1204 | ret = check (); | ||
1205 | GNUNET_free (topology_string); | ||
1206 | |||
1207 | /** | ||
1208 | * Need to remove base directory, subdirectories taken care | ||
1209 | * of by the testing framework. | ||
1210 | */ | ||
1211 | if (GNUNET_DISK_directory_remove (test_directory) != GNUNET_OK) | ||
1212 | { | ||
1213 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
1214 | "Failed to remove testing directory %s\n", test_directory); | ||
1215 | } | ||
1216 | GNUNET_free (our_binary_name); | ||
1217 | return ret; | ||
1218 | } | ||
1219 | |||
1220 | /* end of test_testing_topology.c */ | ||