diff options
author | Christian Grothoff <christian@grothoff.org> | 2012-09-09 13:28:48 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2012-09-09 13:28:48 +0000 |
commit | 9d732bb204de9177aad6ae70c910cbf2615d81a3 (patch) | |
tree | 44ddd6e9e1dad749db51003acfa46d7835593dc6 /src/fs | |
parent | a1d7926951beb7466a1462e43b9933530e5825f7 (diff) | |
download | gnunet-9d732bb204de9177aad6ae70c910cbf2615d81a3.tar.gz gnunet-9d732bb204de9177aad6ae70c910cbf2615d81a3.zip |
make fs tests build against new testbed library -- they do not pass yet
Diffstat (limited to 'src/fs')
-rw-r--r-- | src/fs/Makefile.am | 17 | ||||
-rw-r--r-- | src/fs/fs_test_lib.c | 892 | ||||
-rw-r--r-- | src/fs/fs_test_lib.h | 106 | ||||
-rw-r--r-- | src/fs/perf_gnunet_service_fs_p2p.c | 200 | ||||
-rw-r--r-- | src/fs/perf_gnunet_service_fs_p2p_respect.c | 210 | ||||
-rw-r--r-- | src/fs/test_fs_test_lib.c | 98 | ||||
-rw-r--r-- | src/fs/test_gnunet_service_fs_migration.c | 101 | ||||
-rw-r--r-- | src/fs/test_gnunet_service_fs_p2p.c | 81 |
8 files changed, 766 insertions, 939 deletions
diff --git a/src/fs/Makefile.am b/src/fs/Makefile.am index de5bb8ac4..b4e493d2b 100644 --- a/src/fs/Makefile.am +++ b/src/fs/Makefile.am | |||
@@ -57,7 +57,8 @@ libgnunetfstest_a_SOURCES = \ | |||
57 | fs_test_lib.c fs_test_lib.h | 57 | fs_test_lib.c fs_test_lib.h |
58 | 58 | ||
59 | libgnunetfstest_a_LIBADD = \ | 59 | libgnunetfstest_a_LIBADD = \ |
60 | $(top_builddir)/src/testing_old/libgnunettesting_old.la | 60 | $(top_builddir)/src/testing/libgnunettesting.la \ |
61 | $(top_builddir)/src/testbed/libgnunettestbed.la | ||
61 | 62 | ||
62 | bin_PROGRAMS = \ | 63 | bin_PROGRAMS = \ |
63 | gnunet-auto-share \ | 64 | gnunet-auto-share \ |
@@ -406,7 +407,7 @@ test_fs_test_lib_SOURCES = \ | |||
406 | test_fs_test_lib.c | 407 | test_fs_test_lib.c |
407 | test_fs_test_lib_LDADD = \ | 408 | test_fs_test_lib_LDADD = \ |
408 | $(top_builddir)/src/fs/libgnunetfstest.a \ | 409 | $(top_builddir)/src/fs/libgnunetfstest.a \ |
409 | $(top_builddir)/src/testing_old/libgnunettesting_old.la \ | 410 | $(top_builddir)/src/testbed/libgnunettestbed.la \ |
410 | $(top_builddir)/src/fs/libgnunetfs.la \ | 411 | $(top_builddir)/src/fs/libgnunetfs.la \ |
411 | $(top_builddir)/src/util/libgnunetutil.la | 412 | $(top_builddir)/src/util/libgnunetutil.la |
412 | 413 | ||
@@ -414,7 +415,7 @@ test_gnunet_service_fs_p2p_SOURCES = \ | |||
414 | test_gnunet_service_fs_p2p.c | 415 | test_gnunet_service_fs_p2p.c |
415 | test_gnunet_service_fs_p2p_LDADD = \ | 416 | test_gnunet_service_fs_p2p_LDADD = \ |
416 | $(top_builddir)/src/fs/libgnunetfstest.a \ | 417 | $(top_builddir)/src/fs/libgnunetfstest.a \ |
417 | $(top_builddir)/src/testing_old/libgnunettesting_old.la \ | 418 | $(top_builddir)/src/testbed/libgnunettestbed.la \ |
418 | $(top_builddir)/src/fs/libgnunetfs.la \ | 419 | $(top_builddir)/src/fs/libgnunetfs.la \ |
419 | $(top_builddir)/src/util/libgnunetutil.la | 420 | $(top_builddir)/src/util/libgnunetutil.la |
420 | 421 | ||
@@ -422,7 +423,7 @@ test_gnunet_service_fs_migration_SOURCES = \ | |||
422 | test_gnunet_service_fs_migration.c | 423 | test_gnunet_service_fs_migration.c |
423 | test_gnunet_service_fs_migration_LDADD = \ | 424 | test_gnunet_service_fs_migration_LDADD = \ |
424 | $(top_builddir)/src/fs/libgnunetfstest.a \ | 425 | $(top_builddir)/src/fs/libgnunetfstest.a \ |
425 | $(top_builddir)/src/testing_old/libgnunettesting_old.la \ | 426 | $(top_builddir)/src/testbed/libgnunettestbed.la \ |
426 | $(top_builddir)/src/fs/libgnunetfs.la \ | 427 | $(top_builddir)/src/fs/libgnunetfs.la \ |
427 | $(top_builddir)/src/util/libgnunetutil.la | 428 | $(top_builddir)/src/util/libgnunetutil.la |
428 | 429 | ||
@@ -431,7 +432,7 @@ perf_gnunet_service_fs_p2p_SOURCES = \ | |||
431 | perf_gnunet_service_fs_p2p_LDADD = \ | 432 | perf_gnunet_service_fs_p2p_LDADD = \ |
432 | $(top_builddir)/src/fs/libgnunetfstest.a \ | 433 | $(top_builddir)/src/fs/libgnunetfstest.a \ |
433 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ | 434 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ |
434 | $(top_builddir)/src/testing_old/libgnunettesting_old.la \ | 435 | $(top_builddir)/src/testbed/libgnunettestbed.la \ |
435 | $(top_builddir)/src/fs/libgnunetfs.la \ | 436 | $(top_builddir)/src/fs/libgnunetfs.la \ |
436 | $(top_builddir)/src/util/libgnunetutil.la | 437 | $(top_builddir)/src/util/libgnunetutil.la |
437 | 438 | ||
@@ -440,7 +441,7 @@ perf_gnunet_service_fs_p2p_index_SOURCES = \ | |||
440 | perf_gnunet_service_fs_p2p_index_LDADD = \ | 441 | perf_gnunet_service_fs_p2p_index_LDADD = \ |
441 | $(top_builddir)/src/fs/libgnunetfstest.a \ | 442 | $(top_builddir)/src/fs/libgnunetfstest.a \ |
442 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ | 443 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ |
443 | $(top_builddir)/src/testing_old/libgnunettesting_old.la \ | 444 | $(top_builddir)/src/testbed/libgnunettestbed.la \ |
444 | $(top_builddir)/src/fs/libgnunetfs.la \ | 445 | $(top_builddir)/src/fs/libgnunetfs.la \ |
445 | $(top_builddir)/src/util/libgnunetutil.la | 446 | $(top_builddir)/src/util/libgnunetutil.la |
446 | 447 | ||
@@ -449,7 +450,7 @@ perf_gnunet_service_fs_p2p_dht_SOURCES = \ | |||
449 | perf_gnunet_service_fs_p2p_dht_LDADD = \ | 450 | perf_gnunet_service_fs_p2p_dht_LDADD = \ |
450 | $(top_builddir)/src/fs/libgnunetfstest.a \ | 451 | $(top_builddir)/src/fs/libgnunetfstest.a \ |
451 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ | 452 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ |
452 | $(top_builddir)/src/testing_old/libgnunettesting_old.la \ | 453 | $(top_builddir)/src/testbed/libgnunettestbed.la \ |
453 | $(top_builddir)/src/fs/libgnunetfs.la \ | 454 | $(top_builddir)/src/fs/libgnunetfs.la \ |
454 | $(top_builddir)/src/util/libgnunetutil.la | 455 | $(top_builddir)/src/util/libgnunetutil.la |
455 | 456 | ||
@@ -458,7 +459,7 @@ perf_gnunet_service_fs_p2p_respect_SOURCES = \ | |||
458 | perf_gnunet_service_fs_p2p_respect_LDADD = \ | 459 | perf_gnunet_service_fs_p2p_respect_LDADD = \ |
459 | $(top_builddir)/src/fs/libgnunetfstest.a \ | 460 | $(top_builddir)/src/fs/libgnunetfstest.a \ |
460 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ | 461 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ |
461 | $(top_builddir)/src/testing_old/libgnunettesting_old.la \ | 462 | $(top_builddir)/src/testbed/libgnunettestbed.la \ |
462 | $(top_builddir)/src/fs/libgnunetfs.la \ | 463 | $(top_builddir)/src/fs/libgnunetfs.la \ |
463 | $(top_builddir)/src/util/libgnunetutil.la | 464 | $(top_builddir)/src/util/libgnunetutil.la |
464 | 465 | ||
diff --git a/src/fs/fs_test_lib.c b/src/fs/fs_test_lib.c index 06ab01f8d..bbed98249 100644 --- a/src/fs/fs_test_lib.c +++ b/src/fs/fs_test_lib.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | (C) 2010, 2011 Christian Grothoff (and other contributing authors) | 3 | (C) 2010, 2011, 2012 Christian Grothoff (and other contributing authors) |
4 | 4 | ||
5 | GNUnet is free software; you can redistribute it and/or modify | 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 | 6 | it under the terms of the GNU General Public License as published |
@@ -20,8 +20,8 @@ | |||
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file fs/fs_test_lib.c | 22 | * @file fs/fs_test_lib.c |
23 | * @brief library routines for testing FS publishing and downloading | 23 | * @brief library routines for testing FS publishing and downloading; |
24 | * with multiple peers; this code is limited to flat files | 24 | * this code is limited to flat files |
25 | * and no keywords (those functions can be tested with | 25 | * and no keywords (those functions can be tested with |
26 | * single-peer setups; this is for testing routing). | 26 | * single-peer setups; this is for testing routing). |
27 | * @author Christian Grothoff | 27 | * @author Christian Grothoff |
@@ -29,23 +29,21 @@ | |||
29 | #include "platform.h" | 29 | #include "platform.h" |
30 | #include "fs_api.h" | 30 | #include "fs_api.h" |
31 | #include "fs_test_lib.h" | 31 | #include "fs_test_lib.h" |
32 | #include "gnunet_testing_lib.h" | ||
33 | 32 | ||
34 | #define CONNECT_ATTEMPTS 4 | ||
35 | 33 | ||
36 | #define CONTENT_LIFETIME GNUNET_TIME_UNIT_HOURS | 34 | #define CONTENT_LIFETIME GNUNET_TIME_UNIT_HOURS |
37 | 35 | ||
36 | |||
38 | /** | 37 | /** |
39 | * Handle for a daemon started for testing FS. | 38 | * Handle for a publishing operation started for testing FS. |
40 | */ | 39 | */ |
41 | struct GNUNET_FS_TestDaemon | 40 | struct TestPublishOperation |
42 | { | 41 | { |
43 | 42 | ||
44 | /** | 43 | /** |
45 | * Global configuration, only stored in first test daemon, | 44 | * Handle for the operation to connect to the peer's 'fs' service. |
46 | * otherwise NULL. | ||
47 | */ | 45 | */ |
48 | struct GNUNET_CONFIGURATION_Handle *gcfg; | 46 | struct GNUNET_TESTBED_Operation *fs_op; |
49 | 47 | ||
50 | /** | 48 | /** |
51 | * Handle to the file sharing context using this daemon. | 49 | * Handle to the file sharing context using this daemon. |
@@ -53,27 +51,6 @@ struct GNUNET_FS_TestDaemon | |||
53 | struct GNUNET_FS_Handle *fs; | 51 | struct GNUNET_FS_Handle *fs; |
54 | 52 | ||
55 | /** | 53 | /** |
56 | * Handle to the daemon via testing. | ||
57 | */ | ||
58 | struct GNUNET_TESTING_Daemon *daemon; | ||
59 | |||
60 | /** | ||
61 | * Note that 'group' will be the same value for all of the | ||
62 | * daemons started jointly. | ||
63 | */ | ||
64 | struct GNUNET_TESTING_PeerGroup *group; | ||
65 | |||
66 | /** | ||
67 | * Configuration for accessing this peer. | ||
68 | */ | ||
69 | struct GNUNET_CONFIGURATION_Handle *cfg; | ||
70 | |||
71 | /** | ||
72 | * ID of this peer. | ||
73 | */ | ||
74 | struct GNUNET_PeerIdentity id; | ||
75 | |||
76 | /** | ||
77 | * Function to call when upload is done. | 54 | * Function to call when upload is done. |
78 | */ | 55 | */ |
79 | GNUNET_FS_TEST_UriContinuation publish_cont; | 56 | GNUNET_FS_TEST_UriContinuation publish_cont; |
@@ -109,6 +86,49 @@ struct GNUNET_FS_TestDaemon | |||
109 | char *publish_tmp_file; | 86 | char *publish_tmp_file; |
110 | 87 | ||
111 | /** | 88 | /** |
89 | * Size of the file. | ||
90 | */ | ||
91 | uint64_t size; | ||
92 | |||
93 | /** | ||
94 | * Anonymity level used. | ||
95 | */ | ||
96 | uint32_t anonymity; | ||
97 | |||
98 | /** | ||
99 | * Verbosity level of the current operation. | ||
100 | */ | ||
101 | unsigned int verbose; | ||
102 | |||
103 | /** | ||
104 | * Are we testing indexing? (YES: index, NO: insert, SYSERR: simulate) | ||
105 | */ | ||
106 | int do_index; | ||
107 | }; | ||
108 | |||
109 | |||
110 | /** | ||
111 | * Handle for a download operation started for testing FS. | ||
112 | */ | ||
113 | struct TestDownloadOperation | ||
114 | { | ||
115 | |||
116 | /** | ||
117 | * Handle for the operation to connect to the peer's 'fs' service. | ||
118 | */ | ||
119 | struct GNUNET_TESTBED_Operation *fs_op; | ||
120 | |||
121 | /** | ||
122 | * Handle to the file sharing context using this daemon. | ||
123 | */ | ||
124 | struct GNUNET_FS_Handle *fs; | ||
125 | |||
126 | /** | ||
127 | * Handle to the daemon via testing. | ||
128 | */ | ||
129 | struct GNUNET_TESTING_Daemon *daemon; | ||
130 | |||
131 | /** | ||
112 | * Function to call when download is done. | 132 | * Function to call when download is done. |
113 | */ | 133 | */ |
114 | GNUNET_SCHEDULER_Task download_cont; | 134 | GNUNET_SCHEDULER_Task download_cont; |
@@ -119,9 +139,9 @@ struct GNUNET_FS_TestDaemon | |||
119 | void *download_cont_cls; | 139 | void *download_cont_cls; |
120 | 140 | ||
121 | /** | 141 | /** |
122 | * Seed for download verification. | 142 | * URI to download. |
123 | */ | 143 | */ |
124 | uint32_t download_seed; | 144 | struct GNUNET_FS_Uri *uri; |
125 | 145 | ||
126 | /** | 146 | /** |
127 | * Task to abort downloading (timeout). | 147 | * Task to abort downloading (timeout). |
@@ -134,107 +154,108 @@ struct GNUNET_FS_TestDaemon | |||
134 | struct GNUNET_FS_DownloadContext *download_context; | 154 | struct GNUNET_FS_DownloadContext *download_context; |
135 | 155 | ||
136 | /** | 156 | /** |
137 | * Verbosity level of the current operation. | 157 | * Size of the file. |
138 | */ | 158 | */ |
139 | int verbose; | 159 | uint64_t size; |
140 | 160 | ||
161 | /** | ||
162 | * Anonymity level used. | ||
163 | */ | ||
164 | uint32_t anonymity; | ||
141 | 165 | ||
142 | }; | 166 | /** |
167 | * Seed for download verification. | ||
168 | */ | ||
169 | uint32_t download_seed; | ||
143 | 170 | ||
144 | /** | 171 | /** |
145 | * Check whether peers successfully shut down. | 172 | * Verbosity level of the current operation. |
146 | */ | 173 | */ |
147 | static void | 174 | unsigned int verbose; |
148 | shutdown_callback (void *cls, const char *emsg) | ||
149 | { | ||
150 | struct GNUNET_CONFIGURATION_Handle *gcfg = cls; | ||
151 | 175 | ||
152 | if (emsg != NULL) | 176 | }; |
153 | { | ||
154 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Shutdown of peers failed: %s\n", | ||
155 | emsg); | ||
156 | } | ||
157 | else | ||
158 | { | ||
159 | #if VERBOSE | ||
160 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All peers successfully shut down!\n"); | ||
161 | #endif | ||
162 | } | ||
163 | if (gcfg != NULL) | ||
164 | GNUNET_CONFIGURATION_destroy (gcfg); | ||
165 | } | ||
166 | 177 | ||
167 | 178 | ||
179 | /** | ||
180 | * Task scheduled to report on the completion of our publish operation. | ||
181 | * | ||
182 | * @param cls the publish operation context | ||
183 | * @param tc scheduler context (unused) | ||
184 | */ | ||
168 | static void | 185 | static void |
169 | report_uri (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 186 | report_uri (void *cls, |
187 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
170 | { | 188 | { |
171 | struct GNUNET_FS_TestDaemon *daemon = cls; | 189 | struct TestPublishOperation *po = cls; |
172 | GNUNET_FS_TEST_UriContinuation cont; | 190 | |
173 | struct GNUNET_FS_Uri *uri; | 191 | GNUNET_FS_publish_stop (po->publish_context); |
174 | 192 | GNUNET_TESTBED_operation_done (po->fs_op); | |
175 | GNUNET_FS_publish_stop (daemon->publish_context); | 193 | po->publish_cont (po->publish_cont_cls, po->publish_uri); |
176 | daemon->publish_context = NULL; | 194 | GNUNET_FS_uri_destroy (po->publish_uri); |
177 | cont = daemon->publish_cont; | 195 | GNUNET_free_non_null (po->publish_tmp_file); |
178 | daemon->publish_cont = NULL; | 196 | GNUNET_free (po); |
179 | uri = daemon->publish_uri; | ||
180 | cont (daemon->publish_cont_cls, uri); | ||
181 | GNUNET_FS_uri_destroy (uri); | ||
182 | } | 197 | } |
183 | 198 | ||
184 | 199 | ||
200 | /** | ||
201 | * Task scheduled to run when publish operation times out. | ||
202 | * | ||
203 | * @param cls the publish operation context | ||
204 | * @param tc scheduler context (unused) | ||
205 | */ | ||
185 | static void | 206 | static void |
186 | report_success (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 207 | publish_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
187 | { | 208 | { |
188 | struct GNUNET_FS_TestDaemon *daemon = cls; | 209 | struct TestPublishOperation *po = cls; |
189 | 210 | ||
190 | GNUNET_FS_download_stop (daemon->download_context, GNUNET_YES); | 211 | po->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK; |
191 | daemon->download_context = NULL; | 212 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
192 | GNUNET_SCHEDULER_add_continuation (daemon->download_cont, | 213 | "Timeout while trying to publish data\n"); |
193 | daemon->download_cont_cls, | 214 | if (NULL == po->fs) |
194 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 215 | GNUNET_TESTBED_operation_cancel (po->fs_op); |
195 | daemon->download_cont = NULL; | 216 | else |
217 | GNUNET_TESTBED_operation_done (po->fs_op); | ||
218 | GNUNET_FS_publish_stop (po->publish_context); | ||
219 | GNUNET_TESTBED_operation_done (po->fs_op); | ||
220 | po->publish_cont (po->publish_cont_cls, NULL); | ||
221 | GNUNET_free_non_null (po->publish_tmp_file); | ||
222 | GNUNET_free (po); | ||
196 | } | 223 | } |
197 | 224 | ||
198 | 225 | ||
226 | /** | ||
227 | * Progress callback for file-sharing events while publishing. | ||
228 | * | ||
229 | * @param cls the publish operation context | ||
230 | * @param info information about the event | ||
231 | */ | ||
199 | static void * | 232 | static void * |
200 | progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info) | 233 | publish_progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info) |
201 | { | 234 | { |
202 | struct GNUNET_FS_TestDaemon *daemon = cls; | 235 | struct TestPublishOperation *po = cls; |
203 | 236 | ||
204 | switch (info->status) | 237 | switch (info->status) |
205 | { | 238 | { |
206 | case GNUNET_FS_STATUS_PUBLISH_COMPLETED: | 239 | case GNUNET_FS_STATUS_PUBLISH_COMPLETED: |
207 | GNUNET_SCHEDULER_cancel (daemon->publish_timeout_task); | 240 | GNUNET_SCHEDULER_cancel (po->publish_timeout_task); |
208 | daemon->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK; | 241 | po->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK; |
209 | daemon->publish_uri = | 242 | po->publish_uri = |
210 | GNUNET_FS_uri_dup (info->value.publish.specifics.completed.chk_uri); | 243 | GNUNET_FS_uri_dup (info->value.publish.specifics.completed.chk_uri); |
211 | GNUNET_SCHEDULER_add_continuation (&report_uri, daemon, | 244 | GNUNET_SCHEDULER_add_continuation (&report_uri, po, |
212 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 245 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
213 | break; | 246 | break; |
214 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS: | 247 | case GNUNET_FS_STATUS_PUBLISH_PROGRESS: |
215 | if (daemon->verbose) | 248 | if (po->verbose) |
216 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Publishing at %llu/%llu bytes\n", | 249 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Publishing at %llu/%llu bytes\n", |
217 | (unsigned long long) info->value.publish.completed, | 250 | (unsigned long long) info->value.publish.completed, |
218 | (unsigned long long) info->value.publish.size); | 251 | (unsigned long long) info->value.publish.size); |
219 | break; | 252 | break; |
220 | case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: | 253 | case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: |
221 | if (daemon->verbose) | 254 | if (po->verbose) |
222 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Download at %llu/%llu bytes\n", | 255 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Download at %llu/%llu bytes\n", |
223 | (unsigned long long) info->value.download.completed, | 256 | (unsigned long long) info->value.download.completed, |
224 | (unsigned long long) info->value.download.size); | 257 | (unsigned long long) info->value.download.size); |
225 | break; | 258 | break; |
226 | case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: | ||
227 | GNUNET_SCHEDULER_cancel (daemon->download_timeout_task); | ||
228 | daemon->download_timeout_task = GNUNET_SCHEDULER_NO_TASK; | ||
229 | GNUNET_SCHEDULER_add_continuation (&report_success, daemon, | ||
230 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
231 | break; | ||
232 | case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: | ||
233 | case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: | ||
234 | break; | ||
235 | /* FIXME: monitor data correctness during download progress */ | ||
236 | /* FIXME: do performance reports given sufficient verbosity */ | ||
237 | /* FIXME: advance timeout task to "immediate" on error */ | ||
238 | default: | 259 | default: |
239 | break; | 260 | break; |
240 | } | 261 | } |
@@ -242,460 +263,347 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info) | |||
242 | } | 263 | } |
243 | 264 | ||
244 | 265 | ||
245 | struct StartContext | 266 | /** |
246 | { | 267 | * Generate test data for publishing test. |
247 | struct GNUNET_TIME_Relative timeout; | 268 | * |
248 | unsigned int total; | 269 | * @param cls pointer to uint32_t with publishing seed |
249 | unsigned int have; | 270 | * @param offset offset to generate data for |
250 | struct GNUNET_FS_TestDaemon **daemons; | 271 | * @param max maximum number of bytes to generate |
251 | GNUNET_SCHEDULER_Task cont; | 272 | * @param buf where to write generated data |
252 | void *cont_cls; | 273 | * @param emsg where to store error message (unused) |
253 | struct GNUNET_TESTING_PeerGroup *group; | 274 | * @return number of bytes written to buf |
254 | struct GNUNET_CONFIGURATION_Handle *cfg; | 275 | */ |
255 | GNUNET_SCHEDULER_TaskIdentifier timeout_task; | 276 | static size_t |
256 | }; | 277 | file_generator (void *cls, |
257 | 278 | uint64_t offset, | |
258 | 279 | size_t max, | |
259 | static void | 280 | void *buf, |
260 | notify_running (void *cls, const struct GNUNET_PeerIdentity *id, | 281 | char **emsg) |
261 | const struct GNUNET_CONFIGURATION_Handle *cfg, | ||
262 | struct GNUNET_TESTING_Daemon *d, const char *emsg) | ||
263 | { | 282 | { |
264 | struct StartContext *sctx = cls; | 283 | uint32_t *publish_seed = cls; |
265 | unsigned int i; | 284 | uint64_t pos; |
285 | uint8_t *cbuf = buf; | ||
286 | int mod; | ||
266 | 287 | ||
267 | if (emsg != NULL) | 288 | if (emsg != NULL) |
289 | *emsg = NULL; | ||
290 | if (buf == NULL) | ||
291 | return 0; | ||
292 | for (pos = 0; pos < 8; pos++) | ||
293 | cbuf[pos] = (uint8_t) (offset >> pos * 8); | ||
294 | for (pos = 8; pos < max; pos++) | ||
268 | { | 295 | { |
269 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Failed to start daemon: %s\n"), | 296 | mod = (255 - (offset / 1024 / 32)); |
270 | emsg); | 297 | if (mod == 0) |
271 | return; | 298 | mod = 1; |
272 | } | 299 | cbuf[pos] = (uint8_t) ((offset * (*publish_seed)) % mod); |
273 | i = 0; | ||
274 | while (i < sctx->total) | ||
275 | { | ||
276 | if (GNUNET_TESTING_daemon_get (sctx->group, i) == d) | ||
277 | break; | ||
278 | i++; | ||
279 | } | ||
280 | GNUNET_assert (i < sctx->total); | ||
281 | GNUNET_assert (sctx->have < sctx->total); | ||
282 | GNUNET_assert (sctx->daemons[i]->cfg == NULL); | ||
283 | sctx->daemons[i]->cfg = GNUNET_CONFIGURATION_dup (cfg); | ||
284 | sctx->daemons[i]->group = sctx->group; | ||
285 | sctx->daemons[i]->daemon = d; | ||
286 | sctx->daemons[i]->id = *id; | ||
287 | sctx->have++; | ||
288 | if (sctx->have == sctx->total) | ||
289 | { | ||
290 | GNUNET_SCHEDULER_add_continuation (sctx->cont, sctx->cont_cls, | ||
291 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
292 | sctx->daemons[0]->gcfg = sctx->cfg; | ||
293 | GNUNET_SCHEDULER_cancel (sctx->timeout_task); | ||
294 | for (i = 0; i < sctx->total; i++) | ||
295 | { | ||
296 | sctx->daemons[i]->fs = | ||
297 | GNUNET_FS_start (sctx->daemons[i]->cfg, "<tester>", &progress_cb, | ||
298 | sctx->daemons[i], GNUNET_FS_FLAGS_NONE, | ||
299 | GNUNET_FS_OPTIONS_END); | ||
300 | } | ||
301 | GNUNET_free (sctx); | ||
302 | } | 300 | } |
301 | return max; | ||
303 | } | 302 | } |
304 | 303 | ||
305 | 304 | ||
306 | static void | 305 | /** |
307 | start_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 306 | * Connect adapter for publishing operation. |
307 | * | ||
308 | * @param cls the 'struct TestPublishOperation' | ||
309 | * @param cfg configuration of the peer to connect to; will be available until | ||
310 | * GNUNET_TESTBED_operation_done() is called on the operation returned | ||
311 | * from GNUNET_TESTBED_service_connect() | ||
312 | * @return service handle to return in 'op_result', NULL on error | ||
313 | */ | ||
314 | static void * | ||
315 | publish_connect_adapter (void *cls, | ||
316 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
308 | { | 317 | { |
309 | struct StartContext *sctx = cls; | 318 | struct TestPublishOperation *po = cls; |
310 | unsigned int i; | 319 | |
311 | 320 | return GNUNET_FS_start (cfg, | |
312 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 321 | "fs-test-publish", |
313 | "Timeout while trying to start daemons\n"); | 322 | &publish_progress_cb, po, |
314 | GNUNET_TESTING_daemons_stop (sctx->group, | 323 | GNUNET_FS_OPTIONS_END); |
315 | GNUNET_TIME_relative_multiply | ||
316 | (GNUNET_TIME_UNIT_SECONDS, 30), | ||
317 | &shutdown_callback, NULL); | ||
318 | for (i = 0; i < sctx->total; i++) | ||
319 | { | ||
320 | if (i < sctx->have) | ||
321 | GNUNET_CONFIGURATION_destroy (sctx->daemons[i]->cfg); | ||
322 | GNUNET_free (sctx->daemons[i]); | ||
323 | sctx->daemons[i] = NULL; | ||
324 | } | ||
325 | GNUNET_CONFIGURATION_destroy (sctx->cfg); | ||
326 | GNUNET_SCHEDULER_add_continuation (sctx->cont, sctx->cont_cls, | ||
327 | GNUNET_SCHEDULER_REASON_TIMEOUT); | ||
328 | GNUNET_free (sctx); | ||
329 | } | 324 | } |
330 | 325 | ||
331 | 326 | ||
332 | /** | 327 | /** |
333 | * Start daemons for testing. | 328 | * Adapter function called to destroy connection to file-sharing service. |
334 | * | 329 | * |
335 | * @param template_cfg_file configuration template to use | 330 | * @param cls the 'struct GNUNET_FS_Handle' |
336 | * @param timeout if this operation cannot be completed within the | 331 | * @param op_result unused (different for publish/download!) |
337 | * given period, call the continuation with an error code | ||
338 | * @param total number of daemons to start | ||
339 | * @param daemons array of 'total' entries to be initialized | ||
340 | * (array must already be allocated, will be filled) | ||
341 | * @param cont function to call when done | ||
342 | * @param cont_cls closure for cont | ||
343 | */ | 332 | */ |
344 | void | 333 | static void |
345 | GNUNET_FS_TEST_daemons_start (const char *template_cfg_file, | 334 | fs_disconnect_adapter (void *cls, |
346 | struct GNUNET_TIME_Relative timeout, | 335 | void *op_result) |
347 | unsigned int total, | ||
348 | struct GNUNET_FS_TestDaemon **daemons, | ||
349 | GNUNET_SCHEDULER_Task cont, void *cont_cls) | ||
350 | { | 336 | { |
351 | struct StartContext *sctx; | 337 | struct GNUNET_FS_Handle *fs = op_result; |
352 | unsigned int i; | ||
353 | |||
354 | GNUNET_assert (total > 0); | ||
355 | sctx = GNUNET_malloc (sizeof (struct StartContext)); | ||
356 | sctx->daemons = daemons; | ||
357 | sctx->total = total; | ||
358 | sctx->cont = cont; | ||
359 | sctx->cont_cls = cont_cls; | ||
360 | sctx->cfg = GNUNET_CONFIGURATION_create (); | ||
361 | if (GNUNET_OK != GNUNET_CONFIGURATION_load (sctx->cfg, template_cfg_file)) | ||
362 | { | ||
363 | GNUNET_break (0); | ||
364 | GNUNET_CONFIGURATION_destroy (sctx->cfg); | ||
365 | GNUNET_free (sctx); | ||
366 | GNUNET_SCHEDULER_add_continuation (cont, cont_cls, | ||
367 | GNUNET_SCHEDULER_REASON_TIMEOUT); | ||
368 | return; | ||
369 | } | ||
370 | for (i = 0; i < total; i++) | ||
371 | daemons[i] = GNUNET_malloc (sizeof (struct GNUNET_FS_TestDaemon)); | ||
372 | sctx->group = GNUNET_TESTING_daemons_start (sctx->cfg, total, total, /* Outstanding connections */ | ||
373 | total, /* Outstanding ssh connections */ | ||
374 | timeout, NULL, NULL, | ||
375 | ¬ify_running, sctx, NULL, NULL, | ||
376 | NULL); | ||
377 | sctx->timeout_task = | ||
378 | GNUNET_SCHEDULER_add_delayed (timeout, &start_timeout, sctx); | ||
379 | } | ||
380 | 338 | ||
381 | 339 | GNUNET_FS_stop (fs); | |
382 | struct GNUNET_FS_TEST_ConnectContext | 340 | } |
383 | { | ||
384 | GNUNET_SCHEDULER_Task cont; | ||
385 | void *cont_cls; | ||
386 | struct GNUNET_TESTING_ConnectContext *cc; | ||
387 | }; | ||
388 | 341 | ||
389 | 342 | ||
390 | /** | 343 | /** |
391 | * Prototype of a function that will be called whenever | 344 | * Callback to be called when testbed has connected to the fs service |
392 | * two daemons are connected by the testing library. | ||
393 | * | 345 | * |
394 | * @param cls closure | 346 | * @param cls the 'struct TestPublishOperation' |
395 | * @param first peer id for first daemon | 347 | * @param op the operation that has been finished |
396 | * @param second peer id for the second daemon | 348 | * @param ca_result the 'struct GNUNET_FS_Handle ' (NULL on error) |
397 | * @param distance distance between the connected peers | 349 | * @param emsg error message in case the operation has failed; will be NULL if |
398 | * @param first_cfg config for the first daemon | 350 | * operation has executed successfully. |
399 | * @param second_cfg config for the second daemon | ||
400 | * @param first_daemon handle for the first daemon | ||
401 | * @param second_daemon handle for the second daemon | ||
402 | * @param emsg error message (NULL on success) | ||
403 | */ | 351 | */ |
404 | static void | 352 | static void |
405 | notify_connection (void *cls, const struct GNUNET_PeerIdentity *first, | 353 | publish_fs_connect_complete_cb (void *cls, |
406 | const struct GNUNET_PeerIdentity *second, uint32_t distance, | 354 | struct GNUNET_TESTBED_Operation *op, |
407 | const struct GNUNET_CONFIGURATION_Handle *first_cfg, | 355 | void *ca_result, |
408 | const struct GNUNET_CONFIGURATION_Handle *second_cfg, | 356 | const char *emsg) |
409 | struct GNUNET_TESTING_Daemon *first_daemon, | ||
410 | struct GNUNET_TESTING_Daemon *second_daemon, | ||
411 | const char *emsg) | ||
412 | { | 357 | { |
413 | struct GNUNET_FS_TEST_ConnectContext *cc = cls; | 358 | struct TestPublishOperation *po = cls; |
359 | struct GNUNET_FS_FileInformation *fi; | ||
360 | struct GNUNET_DISK_FileHandle *fh; | ||
361 | char *em; | ||
362 | uint64_t off; | ||
363 | char buf[DBLOCK_SIZE]; | ||
364 | size_t bsize; | ||
365 | struct GNUNET_FS_BlockOptions bo; | ||
414 | 366 | ||
415 | cc->cc = NULL; | 367 | if (NULL == ca_result) |
416 | if (emsg != NULL) | 368 | { |
417 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failed to connect peers: %s\n", | 369 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to connect to FS for publishing: %s\n", emsg); |
418 | emsg); | 370 | po->publish_cont (po->publish_cont_cls, |
419 | GNUNET_SCHEDULER_add_continuation (cc->cont, cc->cont_cls, | 371 | NULL); |
420 | (emsg != | 372 | GNUNET_TESTBED_operation_done (po->fs_op); |
421 | NULL) ? GNUNET_SCHEDULER_REASON_TIMEOUT : | 373 | GNUNET_free (po); |
422 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 374 | return; |
423 | GNUNET_free (cc); | 375 | } |
376 | po->fs = ca_result; | ||
377 | |||
378 | bo.expiration_time = GNUNET_TIME_relative_to_absolute (CONTENT_LIFETIME); | ||
379 | bo.anonymity_level = po->anonymity; | ||
380 | bo.content_priority = 42; | ||
381 | bo.replication_level = 1; | ||
382 | if (GNUNET_YES == po->do_index) | ||
383 | { | ||
384 | po->publish_tmp_file = GNUNET_DISK_mktemp ("fs-test-publish-index"); | ||
385 | GNUNET_assert (po->publish_tmp_file != NULL); | ||
386 | fh = GNUNET_DISK_file_open (po->publish_tmp_file, | ||
387 | GNUNET_DISK_OPEN_WRITE | | ||
388 | GNUNET_DISK_OPEN_CREATE, | ||
389 | GNUNET_DISK_PERM_USER_READ | | ||
390 | GNUNET_DISK_PERM_USER_WRITE); | ||
391 | GNUNET_assert (NULL != fh); | ||
392 | off = 0; | ||
393 | while (off < po->size) | ||
394 | { | ||
395 | bsize = GNUNET_MIN (sizeof (buf), po->size - off); | ||
396 | emsg = NULL; | ||
397 | GNUNET_assert (bsize == file_generator (&po->publish_seed, off, bsize, buf, &em)); | ||
398 | GNUNET_assert (em == NULL); | ||
399 | GNUNET_assert (bsize == GNUNET_DISK_file_write (fh, buf, bsize)); | ||
400 | off += bsize; | ||
401 | } | ||
402 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh)); | ||
403 | fi = GNUNET_FS_file_information_create_from_file (po->fs, po, | ||
404 | po->publish_tmp_file, | ||
405 | NULL, NULL, po->do_index, | ||
406 | &bo); | ||
407 | } | ||
408 | else | ||
409 | { | ||
410 | fi = GNUNET_FS_file_information_create_from_reader (po->fs, po, | ||
411 | po->size, | ||
412 | &file_generator, &po->publish_seed, | ||
413 | NULL, NULL, | ||
414 | po->do_index, &bo); | ||
415 | } | ||
416 | po->publish_context = | ||
417 | GNUNET_FS_publish_start (po->fs, fi, NULL, NULL, NULL, | ||
418 | GNUNET_FS_PUBLISH_OPTION_NONE); | ||
424 | } | 419 | } |
425 | 420 | ||
426 | 421 | ||
427 | /** | 422 | /** |
428 | * Connect two daemons for testing. | 423 | * Publish a file at the given peer. |
429 | * | 424 | * |
430 | * @param daemon1 first daemon to connect | 425 | * @param peer where to publish |
431 | * @param daemon2 second first daemon to connect | ||
432 | * @param timeout if this operation cannot be completed within the | 426 | * @param timeout if this operation cannot be completed within the |
433 | * given period, call the continuation with an error code | 427 | * given period, call the continuation with an error code |
428 | * @param anonymity option for publication | ||
429 | * @param do_index GNUNET_YES for index, GNUNET_NO for insertion, | ||
430 | * GNUNET_SYSERR for simulation | ||
431 | * @param size size of the file to publish | ||
432 | * @param seed seed to use for file generation | ||
433 | * @param verbose how verbose to be in reporting | ||
434 | * @param cont function to call when done | 434 | * @param cont function to call when done |
435 | * @param cont_cls closure for cont | 435 | * @param cont_cls closure for cont |
436 | */ | 436 | */ |
437 | struct GNUNET_FS_TEST_ConnectContext * | 437 | void |
438 | GNUNET_FS_TEST_daemons_connect (struct GNUNET_FS_TestDaemon *daemon1, | 438 | GNUNET_FS_TEST_publish (struct GNUNET_TESTBED_Peer *peer, |
439 | struct GNUNET_FS_TestDaemon *daemon2, | 439 | struct GNUNET_TIME_Relative timeout, uint32_t anonymity, |
440 | struct GNUNET_TIME_Relative timeout, | 440 | int do_index, uint64_t size, uint32_t seed, |
441 | GNUNET_SCHEDULER_Task cont, void *cont_cls) | 441 | unsigned int verbose, |
442 | GNUNET_FS_TEST_UriContinuation cont, void *cont_cls) | ||
442 | { | 443 | { |
443 | struct GNUNET_FS_TEST_ConnectContext *ncc; | 444 | struct TestPublishOperation *po; |
444 | 445 | ||
445 | ncc = GNUNET_malloc (sizeof (struct GNUNET_FS_TEST_ConnectContext)); | 446 | po = GNUNET_malloc (sizeof (struct TestPublishOperation)); |
446 | ncc->cont = cont; | 447 | po->publish_cont = cont; |
447 | ncc->cont_cls = cont_cls; | 448 | po->publish_cont_cls = cont_cls; |
448 | ncc->cc = | 449 | po->publish_seed = seed; |
449 | GNUNET_TESTING_daemons_connect (daemon1->daemon, daemon2->daemon, timeout, | 450 | po->anonymity = anonymity; |
450 | CONNECT_ATTEMPTS, GNUNET_YES, | 451 | po->size = size; |
451 | ¬ify_connection, ncc); | 452 | po->verbose = verbose; |
452 | return ncc; | 453 | po->do_index = do_index; |
454 | po->fs_op = GNUNET_TESTBED_service_connect (po, | ||
455 | peer, | ||
456 | "fs", | ||
457 | &publish_fs_connect_complete_cb, | ||
458 | po, | ||
459 | &publish_connect_adapter, | ||
460 | &fs_disconnect_adapter, | ||
461 | po); | ||
462 | po->publish_timeout_task = | ||
463 | GNUNET_SCHEDULER_add_delayed (timeout, &publish_timeout, po); | ||
453 | } | 464 | } |
454 | 465 | ||
455 | 466 | ||
456 | /** | 467 | /* ************************** download ************************ */ |
457 | * Cancel connect operation. | ||
458 | * | ||
459 | * @param cc operation to cancel | ||
460 | */ | ||
461 | void | ||
462 | GNUNET_FS_TEST_daemons_connect_cancel (struct GNUNET_FS_TEST_ConnectContext *cc) | ||
463 | { | ||
464 | GNUNET_TESTING_daemons_connect_cancel (cc->cc); | ||
465 | GNUNET_free (cc); | ||
466 | } | ||
467 | 468 | ||
468 | 469 | ||
469 | /** | 470 | /** |
470 | * Obtain peer configuration used for testing. | 471 | * Task scheduled to run when download operation times out. |
471 | * | 472 | * |
472 | * @param daemons array with the daemons | 473 | * @param cls the download operation context |
473 | * @param off which configuration to get | 474 | * @param tc scheduler context (unused) |
474 | * @return peer configuration | ||
475 | */ | 475 | */ |
476 | const struct GNUNET_CONFIGURATION_Handle * | 476 | static void |
477 | GNUNET_FS_TEST_get_configuration (struct GNUNET_FS_TestDaemon **daemons, | 477 | download_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
478 | unsigned int off) | ||
479 | { | 478 | { |
480 | return daemons[off]->cfg; | 479 | struct TestDownloadOperation *dop = cls; |
481 | } | ||
482 | 480 | ||
483 | /** | 481 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
484 | * Obtain peer group used for testing. | 482 | "Timeout while trying to download file\n"); |
485 | * | 483 | dop->download_timeout_task = GNUNET_SCHEDULER_NO_TASK; |
486 | * @param daemons array with the daemons (must contain at least one) | 484 | GNUNET_FS_download_stop (dop->download_context, GNUNET_YES); |
487 | * @return peer group | 485 | GNUNET_SCHEDULER_add_continuation (dop->download_cont, |
488 | */ | 486 | dop->download_cont_cls, |
489 | struct GNUNET_TESTING_PeerGroup * | 487 | GNUNET_SCHEDULER_REASON_TIMEOUT); |
490 | GNUNET_FS_TEST_get_group (struct GNUNET_FS_TestDaemon **daemons) | 488 | if (NULL == dop->fs) |
491 | { | 489 | GNUNET_TESTBED_operation_cancel (dop->fs_op); |
492 | return daemons[0]->group; | 490 | else |
491 | GNUNET_TESTBED_operation_done (dop->fs_op); | ||
492 | GNUNET_FS_uri_destroy (dop->uri); | ||
493 | GNUNET_free (dop); | ||
493 | } | 494 | } |
494 | 495 | ||
495 | 496 | ||
496 | /** | 497 | /** |
497 | * Stop daemons used for testing. | 498 | * Task scheduled to report on the completion of our download operation. |
498 | * | 499 | * |
499 | * @param total number of daemons to stop | 500 | * @param cls the download operation context |
500 | * @param daemons array with the daemons (values will be clobbered) | 501 | * @param tc scheduler context (unused) |
501 | */ | 502 | */ |
502 | void | ||
503 | GNUNET_FS_TEST_daemons_stop (unsigned int total, | ||
504 | struct GNUNET_FS_TestDaemon **daemons) | ||
505 | { | ||
506 | unsigned int i; | ||
507 | struct GNUNET_TESTING_PeerGroup *pg; | ||
508 | struct GNUNET_CONFIGURATION_Handle *gcfg; | ||
509 | struct GNUNET_FS_TestDaemon *daemon; | ||
510 | |||
511 | GNUNET_assert (total > 0); | ||
512 | GNUNET_assert (daemons[0] != NULL); | ||
513 | pg = daemons[0]->group; | ||
514 | gcfg = daemons[0]->gcfg; | ||
515 | for (i = 0; i < total; i++) | ||
516 | { | ||
517 | daemon = daemons[i]; | ||
518 | if (daemon->download_timeout_task != GNUNET_SCHEDULER_NO_TASK) | ||
519 | { | ||
520 | GNUNET_SCHEDULER_cancel (daemon->download_timeout_task); | ||
521 | daemon->download_timeout_task = GNUNET_SCHEDULER_NO_TASK; | ||
522 | } | ||
523 | if (daemon->publish_timeout_task != GNUNET_SCHEDULER_NO_TASK) | ||
524 | { | ||
525 | GNUNET_SCHEDULER_cancel (daemon->publish_timeout_task); | ||
526 | daemon->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK; | ||
527 | } | ||
528 | if (NULL != daemon->download_context) | ||
529 | { | ||
530 | GNUNET_FS_download_stop (daemon->download_context, GNUNET_YES); | ||
531 | daemon->download_context = NULL; | ||
532 | } | ||
533 | if (daemon->fs != NULL) | ||
534 | GNUNET_FS_stop (daemon->fs); | ||
535 | if (daemon->cfg != NULL) | ||
536 | GNUNET_CONFIGURATION_destroy (daemon->cfg); | ||
537 | if (NULL != daemon->publish_tmp_file) | ||
538 | { | ||
539 | GNUNET_break (GNUNET_OK == | ||
540 | GNUNET_DISK_directory_remove (daemon->publish_tmp_file)); | ||
541 | GNUNET_free (daemon->publish_tmp_file); | ||
542 | daemon->publish_tmp_file = NULL; | ||
543 | } | ||
544 | GNUNET_free (daemon); | ||
545 | daemons[i] = NULL; | ||
546 | } | ||
547 | GNUNET_TESTING_daemons_stop (pg, | ||
548 | GNUNET_TIME_relative_multiply | ||
549 | (GNUNET_TIME_UNIT_SECONDS, 30), | ||
550 | &shutdown_callback, gcfg); | ||
551 | } | ||
552 | |||
553 | |||
554 | static void | 503 | static void |
555 | publish_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 504 | report_success (void *cls, |
505 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
556 | { | 506 | { |
557 | struct GNUNET_FS_TestDaemon *daemon = cls; | 507 | struct TestDownloadOperation *dop = cls; |
558 | GNUNET_FS_TEST_UriContinuation cont; | ||
559 | 508 | ||
560 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 509 | GNUNET_FS_download_stop (dop->download_context, GNUNET_YES); |
561 | "Timeout while trying to publish data\n"); | 510 | GNUNET_SCHEDULER_add_continuation (dop->download_cont, |
562 | cont = daemon->publish_cont; | 511 | dop->download_cont_cls, |
563 | daemon->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK; | 512 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
564 | daemon->publish_cont = NULL; | 513 | GNUNET_TESTBED_operation_done (dop->fs_op); |
565 | GNUNET_FS_publish_stop (daemon->publish_context); | 514 | GNUNET_FS_uri_destroy (dop->uri); |
566 | daemon->publish_context = NULL; | 515 | GNUNET_free (dop); |
567 | cont (daemon->publish_cont_cls, NULL); | ||
568 | } | 516 | } |
569 | 517 | ||
570 | 518 | ||
571 | static size_t | 519 | /** |
572 | file_generator (void *cls, uint64_t offset, size_t max, void *buf, char **emsg) | 520 | * Progress callback for file-sharing events while downloading. |
521 | * | ||
522 | * @param cls the download operation context | ||
523 | * @param info information about the event | ||
524 | */ | ||
525 | static void * | ||
526 | download_progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info) | ||
573 | { | 527 | { |
574 | struct GNUNET_FS_TestDaemon *daemon = cls; | 528 | struct TestDownloadOperation *dop = cls; |
575 | uint64_t pos; | ||
576 | uint8_t *cbuf = buf; | ||
577 | int mod; | ||
578 | 529 | ||
579 | if (emsg != NULL) | 530 | switch (info->status) |
580 | *emsg = NULL; | ||
581 | if (buf == NULL) | ||
582 | return 0; | ||
583 | for (pos = 0; pos < 8; pos++) | ||
584 | cbuf[pos] = (uint8_t) (offset >> pos * 8); | ||
585 | for (pos = 8; pos < max; pos++) | ||
586 | { | 531 | { |
587 | mod = (255 - (offset / 1024 / 32)); | 532 | case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: |
588 | if (mod == 0) | 533 | if (dop->verbose) |
589 | mod = 1; | 534 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Download at %llu/%llu bytes\n", |
590 | cbuf[pos] = (uint8_t) ((offset * daemon->publish_seed) % mod); | 535 | (unsigned long long) info->value.download.completed, |
536 | (unsigned long long) info->value.download.size); | ||
537 | break; | ||
538 | case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: | ||
539 | GNUNET_SCHEDULER_cancel (dop->download_timeout_task); | ||
540 | dop->download_timeout_task = GNUNET_SCHEDULER_NO_TASK; | ||
541 | GNUNET_SCHEDULER_add_continuation (&report_success, dop, | ||
542 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
543 | break; | ||
544 | case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: | ||
545 | case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: | ||
546 | break; | ||
547 | /* FIXME: monitor data correctness during download progress */ | ||
548 | /* FIXME: do performance reports given sufficient verbosity */ | ||
549 | /* FIXME: advance timeout task to "immediate" on error */ | ||
550 | default: | ||
551 | break; | ||
591 | } | 552 | } |
592 | return max; | 553 | return NULL; |
593 | } | 554 | } |
594 | 555 | ||
595 | 556 | ||
596 | |||
597 | /** | 557 | /** |
598 | * Publish a file at the given daemon. | 558 | * Connect adapter for download operation. |
599 | * | 559 | * |
600 | * @param daemon where to publish | 560 | * @param cls the 'struct TestDownloadOperation' |
601 | * @param timeout if this operation cannot be completed within the | 561 | * @param cfg configuration of the peer to connect to; will be available until |
602 | * given period, call the continuation with an error code | 562 | * GNUNET_TESTBED_operation_done() is called on the operation returned |
603 | * @param anonymity option for publication | 563 | * from GNUNET_TESTBED_service_connect() |
604 | * @param do_index GNUNET_YES for index, GNUNET_NO for insertion, | 564 | * @return service handle to return in 'op_result', NULL on error |
605 | * GNUNET_SYSERR for simulation | ||
606 | * @param size size of the file to publish | ||
607 | * @param seed seed to use for file generation | ||
608 | * @param verbose how verbose to be in reporting | ||
609 | * @param cont function to call when done | ||
610 | * @param cont_cls closure for cont | ||
611 | */ | 565 | */ |
612 | void | 566 | static void * |
613 | GNUNET_FS_TEST_publish (struct GNUNET_FS_TestDaemon *daemon, | 567 | download_connect_adapter (void *cls, |
614 | struct GNUNET_TIME_Relative timeout, uint32_t anonymity, | 568 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
615 | int do_index, uint64_t size, uint32_t seed, | ||
616 | unsigned int verbose, | ||
617 | GNUNET_FS_TEST_UriContinuation cont, void *cont_cls) | ||
618 | { | 569 | { |
619 | struct GNUNET_FS_FileInformation *fi; | 570 | struct TestPublishOperation *po = cls; |
620 | struct GNUNET_DISK_FileHandle *fh; | 571 | |
621 | char *emsg; | 572 | return GNUNET_FS_start (cfg, |
622 | uint64_t off; | 573 | "fs-test-download", |
623 | char buf[DBLOCK_SIZE]; | 574 | &download_progress_cb, po, |
624 | size_t bsize; | 575 | GNUNET_FS_OPTIONS_END); |
625 | struct GNUNET_FS_BlockOptions bo; | ||
626 | |||
627 | GNUNET_assert (daemon->publish_cont == NULL); | ||
628 | daemon->publish_cont = cont; | ||
629 | daemon->publish_cont_cls = cont_cls; | ||
630 | daemon->publish_seed = seed; | ||
631 | daemon->verbose = verbose; | ||
632 | bo.expiration_time = GNUNET_TIME_relative_to_absolute (CONTENT_LIFETIME); | ||
633 | bo.anonymity_level = anonymity; | ||
634 | bo.content_priority = 42; | ||
635 | bo.replication_level = 1; | ||
636 | if (GNUNET_YES == do_index) | ||
637 | { | ||
638 | GNUNET_assert (daemon->publish_tmp_file == NULL); | ||
639 | daemon->publish_tmp_file = GNUNET_DISK_mktemp ("fs-test-publish-index"); | ||
640 | GNUNET_assert (daemon->publish_tmp_file != NULL); | ||
641 | fh = GNUNET_DISK_file_open (daemon->publish_tmp_file, | ||
642 | GNUNET_DISK_OPEN_WRITE | | ||
643 | GNUNET_DISK_OPEN_CREATE, | ||
644 | GNUNET_DISK_PERM_USER_READ | | ||
645 | GNUNET_DISK_PERM_USER_WRITE); | ||
646 | GNUNET_assert (NULL != fh); | ||
647 | off = 0; | ||
648 | while (off < size) | ||
649 | { | ||
650 | bsize = GNUNET_MIN (sizeof (buf), size - off); | ||
651 | emsg = NULL; | ||
652 | GNUNET_assert (bsize == file_generator (daemon, off, bsize, buf, &emsg)); | ||
653 | GNUNET_assert (emsg == NULL); | ||
654 | GNUNET_assert (bsize == GNUNET_DISK_file_write (fh, buf, bsize)); | ||
655 | off += bsize; | ||
656 | } | ||
657 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh)); | ||
658 | fi = GNUNET_FS_file_information_create_from_file (daemon->fs, daemon, | ||
659 | daemon->publish_tmp_file, | ||
660 | NULL, NULL, do_index, | ||
661 | &bo); | ||
662 | } | ||
663 | else | ||
664 | { | ||
665 | fi = GNUNET_FS_file_information_create_from_reader (daemon->fs, daemon, | ||
666 | size, &file_generator, | ||
667 | daemon, NULL, NULL, | ||
668 | do_index, &bo); | ||
669 | } | ||
670 | daemon->publish_context = | ||
671 | GNUNET_FS_publish_start (daemon->fs, fi, NULL, NULL, NULL, | ||
672 | GNUNET_FS_PUBLISH_OPTION_NONE); | ||
673 | daemon->publish_timeout_task = | ||
674 | GNUNET_SCHEDULER_add_delayed (timeout, &publish_timeout, daemon); | ||
675 | } | 576 | } |
676 | 577 | ||
677 | 578 | ||
579 | /** | ||
580 | * Callback to be called when testbed has connected to the fs service | ||
581 | * | ||
582 | * @param cls the 'struct TestPublishOperation' | ||
583 | * @param op the operation that has been finished | ||
584 | * @param ca_result the 'struct GNUNET_FS_Handle ' (NULL on error) | ||
585 | * @param emsg error message in case the operation has failed; will be NULL if | ||
586 | * operation has executed successfully. | ||
587 | */ | ||
678 | static void | 588 | static void |
679 | download_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 589 | download_fs_connect_complete_cb (void *cls, |
590 | struct GNUNET_TESTBED_Operation *op, | ||
591 | void *ca_result, | ||
592 | const char *emsg) | ||
680 | { | 593 | { |
681 | struct GNUNET_FS_TestDaemon *daemon = cls; | 594 | struct TestDownloadOperation *dop = cls; |
682 | 595 | ||
683 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 596 | dop->download_context = |
684 | "Timeout while trying to download file\n"); | 597 | GNUNET_FS_download_start (dop->fs, dop->uri, NULL, NULL, NULL, 0, dop->size, |
685 | daemon->download_timeout_task = GNUNET_SCHEDULER_NO_TASK; | 598 | dop->anonymity, GNUNET_FS_DOWNLOAD_OPTION_NONE, |
686 | GNUNET_FS_download_stop (daemon->download_context, GNUNET_YES); | 599 | NULL, NULL); |
687 | daemon->download_context = NULL; | ||
688 | GNUNET_SCHEDULER_add_continuation (daemon->download_cont, | ||
689 | daemon->download_cont_cls, | ||
690 | GNUNET_SCHEDULER_REASON_TIMEOUT); | ||
691 | daemon->download_cont = NULL; | ||
692 | } | 600 | } |
693 | 601 | ||
694 | 602 | ||
695 | /** | 603 | /** |
696 | * Perform test download. | 604 | * Perform test download. |
697 | * | 605 | * |
698 | * @param daemon which peer to download from | 606 | * @param peer which peer to download from |
699 | * @param timeout if this operation cannot be completed within the | 607 | * @param timeout if this operation cannot be completed within the |
700 | * given period, call the continuation with an error code | 608 | * given period, call the continuation with an error code |
701 | * @param anonymity option for download | 609 | * @param anonymity option for download |
@@ -706,26 +614,34 @@ download_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
706 | * @param cont_cls closure for cont | 614 | * @param cont_cls closure for cont |
707 | */ | 615 | */ |
708 | void | 616 | void |
709 | GNUNET_FS_TEST_download (struct GNUNET_FS_TestDaemon *daemon, | 617 | GNUNET_FS_TEST_download (struct GNUNET_TESTBED_Peer *peer, |
710 | struct GNUNET_TIME_Relative timeout, | 618 | struct GNUNET_TIME_Relative timeout, |
711 | uint32_t anonymity, uint32_t seed, | 619 | uint32_t anonymity, uint32_t seed, |
712 | const struct GNUNET_FS_Uri *uri, unsigned int verbose, | 620 | const struct GNUNET_FS_Uri *uri, unsigned int verbose, |
713 | GNUNET_SCHEDULER_Task cont, void *cont_cls) | 621 | GNUNET_SCHEDULER_Task cont, void *cont_cls) |
714 | { | 622 | { |
715 | uint64_t size; | 623 | struct TestDownloadOperation *dop; |
716 | 624 | ||
717 | GNUNET_assert (daemon->download_cont == NULL); | 625 | dop = GNUNET_malloc (sizeof (struct TestDownloadOperation)); |
718 | size = GNUNET_FS_uri_chk_get_file_size (uri); | 626 | dop->uri = GNUNET_FS_uri_dup (uri); |
719 | daemon->verbose = verbose; | 627 | dop->size = GNUNET_FS_uri_chk_get_file_size (uri); |
720 | daemon->download_cont = cont; | 628 | dop->verbose = verbose; |
721 | daemon->download_cont_cls = cont_cls; | 629 | dop->anonymity = anonymity; |
722 | daemon->download_seed = seed; | 630 | dop->download_cont = cont; |
723 | daemon->download_context = | 631 | dop->download_cont_cls = cont_cls; |
724 | GNUNET_FS_download_start (daemon->fs, uri, NULL, NULL, NULL, 0, size, | 632 | dop->download_seed = seed; |
725 | anonymity, GNUNET_FS_DOWNLOAD_OPTION_NONE, NULL, | 633 | |
726 | NULL); | 634 | dop->fs_op = GNUNET_TESTBED_service_connect (dop, |
727 | daemon->download_timeout_task = | 635 | peer, |
728 | GNUNET_SCHEDULER_add_delayed (timeout, &download_timeout, daemon); | 636 | "fs", |
637 | &download_fs_connect_complete_cb, | ||
638 | dop, | ||
639 | &download_connect_adapter, | ||
640 | &fs_disconnect_adapter, | ||
641 | dop); | ||
642 | dop->download_timeout_task = | ||
643 | GNUNET_SCHEDULER_add_delayed (timeout, &download_timeout, dop); | ||
729 | } | 644 | } |
730 | 645 | ||
731 | /* end of test_fs_lib.c */ | 646 | |
647 | /* end of fs_test_lib.c */ | ||
diff --git a/src/fs/fs_test_lib.h b/src/fs/fs_test_lib.h index 81125cafc..d00c21b1e 100644 --- a/src/fs/fs_test_lib.h +++ b/src/fs/fs_test_lib.h | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | (C) 2010 Christian Grothoff (and other contributing authors) | 3 | (C) 2010, 2012 Christian Grothoff (and other contributing authors) |
4 | 4 | ||
5 | GNUnet is free software; you can redistribute it and/or modify | 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 | 6 | it under the terms of the GNU General Public License as published |
@@ -20,8 +20,8 @@ | |||
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file fs/fs_test_lib.h | 22 | * @file fs/fs_test_lib.h |
23 | * @brief library routines for testing FS publishing and downloading | 23 | * @brief library routines for testing FS publishing and downloading; |
24 | * with multiple peers; this code is limited to flat files | 24 | * this code is limited to flat files |
25 | * and no keywords (those functions can be tested with | 25 | * and no keywords (those functions can be tested with |
26 | * single-peer setups; this is for testing routing). | 26 | * single-peer setups; this is for testing routing). |
27 | * @author Christian Grothoff | 27 | * @author Christian Grothoff |
@@ -31,97 +31,7 @@ | |||
31 | 31 | ||
32 | #include "gnunet_util_lib.h" | 32 | #include "gnunet_util_lib.h" |
33 | #include "gnunet_fs_service.h" | 33 | #include "gnunet_fs_service.h" |
34 | 34 | #include "gnunet_testbed_service.h" | |
35 | /** | ||
36 | * Handle for a daemon started for testing FS. | ||
37 | */ | ||
38 | struct GNUNET_FS_TestDaemon; | ||
39 | |||
40 | |||
41 | /** | ||
42 | * Start daemons for testing. | ||
43 | * | ||
44 | * @param template_cfg_file configuration template to use | ||
45 | * @param timeout if this operation cannot be completed within the | ||
46 | * given period, call the continuation with an error code | ||
47 | * @param total number of daemons to start | ||
48 | * @param daemons array of 'total' entries to be initialized | ||
49 | * (array must already be allocated, will be filled) | ||
50 | * @param cont function to call when done; note that if 'cont' | ||
51 | * is called with reason "TIMEOUT", then starting the | ||
52 | * daemons has failed and the client MUST NOT call | ||
53 | * 'GNUNET_FS_TEST_daemons_stop'! | ||
54 | * @param cont_cls closure for cont | ||
55 | */ | ||
56 | void | ||
57 | GNUNET_FS_TEST_daemons_start (const char *template_cfg_file, | ||
58 | struct GNUNET_TIME_Relative timeout, | ||
59 | unsigned int total, | ||
60 | struct GNUNET_FS_TestDaemon **daemons, | ||
61 | GNUNET_SCHEDULER_Task cont, void *cont_cls); | ||
62 | |||
63 | |||
64 | struct GNUNET_FS_TEST_ConnectContext; | ||
65 | |||
66 | |||
67 | /** | ||
68 | * Connect two daemons for testing. | ||
69 | * | ||
70 | * @param daemon1 first daemon to connect | ||
71 | * @param daemon2 second first daemon to connect | ||
72 | * @param timeout if this operation cannot be completed within the | ||
73 | * given period, call the continuation with an error code | ||
74 | * @param cont function to call when done | ||
75 | * @param cont_cls closure for cont | ||
76 | */ | ||
77 | struct GNUNET_FS_TEST_ConnectContext * | ||
78 | GNUNET_FS_TEST_daemons_connect (struct GNUNET_FS_TestDaemon *daemon1, | ||
79 | struct GNUNET_FS_TestDaemon *daemon2, | ||
80 | struct GNUNET_TIME_Relative timeout, | ||
81 | GNUNET_SCHEDULER_Task cont, void *cont_cls); | ||
82 | |||
83 | |||
84 | /** | ||
85 | * Cancel connect operation. | ||
86 | * | ||
87 | * @param cc operation to cancel | ||
88 | */ | ||
89 | void | ||
90 | GNUNET_FS_TEST_daemons_connect_cancel (struct GNUNET_FS_TEST_ConnectContext | ||
91 | *cc); | ||
92 | |||
93 | |||
94 | /** | ||
95 | * Obtain peer group used for testing. | ||
96 | * | ||
97 | * @param daemons array with the daemons (must contain at least one) | ||
98 | * @return peer group | ||
99 | */ | ||
100 | struct GNUNET_TESTING_PeerGroup * | ||
101 | GNUNET_FS_TEST_get_group (struct GNUNET_FS_TestDaemon **daemons); | ||
102 | |||
103 | |||
104 | |||
105 | /** | ||
106 | * Obtain peer configuration used for testing. | ||
107 | * | ||
108 | * @param daemons array with the daemons | ||
109 | * @param off which configuration to get | ||
110 | * @return peer configuration | ||
111 | */ | ||
112 | const struct GNUNET_CONFIGURATION_Handle * | ||
113 | GNUNET_FS_TEST_get_configuration (struct GNUNET_FS_TestDaemon **daemons, | ||
114 | unsigned int off); | ||
115 | |||
116 | /** | ||
117 | * Stop daemons used for testing. | ||
118 | * | ||
119 | * @param total number of daemons to stop | ||
120 | * @param daemons array with the daemons (values will be clobbered) | ||
121 | */ | ||
122 | void | ||
123 | GNUNET_FS_TEST_daemons_stop (unsigned int total, | ||
124 | struct GNUNET_FS_TestDaemon **daemons); | ||
125 | 35 | ||
126 | 36 | ||
127 | /** | 37 | /** |
@@ -138,7 +48,7 @@ typedef void (*GNUNET_FS_TEST_UriContinuation) (void *cls, | |||
138 | /** | 48 | /** |
139 | * Publish a file at the given daemon. | 49 | * Publish a file at the given daemon. |
140 | * | 50 | * |
141 | * @param daemon where to publish | 51 | * @param peer where to publish |
142 | * @param timeout if this operation cannot be completed within the | 52 | * @param timeout if this operation cannot be completed within the |
143 | * given period, call the continuation with an error code | 53 | * given period, call the continuation with an error code |
144 | * @param anonymity option for publication | 54 | * @param anonymity option for publication |
@@ -151,7 +61,7 @@ typedef void (*GNUNET_FS_TEST_UriContinuation) (void *cls, | |||
151 | * @param cont_cls closure for cont | 61 | * @param cont_cls closure for cont |
152 | */ | 62 | */ |
153 | void | 63 | void |
154 | GNUNET_FS_TEST_publish (struct GNUNET_FS_TestDaemon *daemon, | 64 | GNUNET_FS_TEST_publish (struct GNUNET_TESTBED_Peer *peer, |
155 | struct GNUNET_TIME_Relative timeout, uint32_t anonymity, | 65 | struct GNUNET_TIME_Relative timeout, uint32_t anonymity, |
156 | int do_index, uint64_t size, uint32_t seed, | 66 | int do_index, uint64_t size, uint32_t seed, |
157 | unsigned int verbose, | 67 | unsigned int verbose, |
@@ -161,7 +71,7 @@ GNUNET_FS_TEST_publish (struct GNUNET_FS_TestDaemon *daemon, | |||
161 | /** | 71 | /** |
162 | * Perform test download. | 72 | * Perform test download. |
163 | * | 73 | * |
164 | * @param daemon which peer to download from | 74 | * @param peer which peer to download from |
165 | * @param timeout if this operation cannot be completed within the | 75 | * @param timeout if this operation cannot be completed within the |
166 | * given period, call the continuation with an error code | 76 | * given period, call the continuation with an error code |
167 | * @param anonymity option for download | 77 | * @param anonymity option for download |
@@ -172,7 +82,7 @@ GNUNET_FS_TEST_publish (struct GNUNET_FS_TestDaemon *daemon, | |||
172 | * @param cont_cls closure for cont | 82 | * @param cont_cls closure for cont |
173 | */ | 83 | */ |
174 | void | 84 | void |
175 | GNUNET_FS_TEST_download (struct GNUNET_FS_TestDaemon *daemon, | 85 | GNUNET_FS_TEST_download (struct GNUNET_TESTBED_Peer *peer, |
176 | struct GNUNET_TIME_Relative timeout, | 86 | struct GNUNET_TIME_Relative timeout, |
177 | uint32_t anonymity, uint32_t seed, | 87 | uint32_t anonymity, uint32_t seed, |
178 | const struct GNUNET_FS_Uri *uri, unsigned int verbose, | 88 | const struct GNUNET_FS_Uri *uri, unsigned int verbose, |
diff --git a/src/fs/perf_gnunet_service_fs_p2p.c b/src/fs/perf_gnunet_service_fs_p2p.c index 22068732d..a7eb5ad16 100644 --- a/src/fs/perf_gnunet_service_fs_p2p.c +++ b/src/fs/perf_gnunet_service_fs_p2p.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | (C) 2010 Christian Grothoff (and other contributing authors) | 3 | (C) 2010, 2012 Christian Grothoff (and other contributing authors) |
4 | 4 | ||
5 | GNUnet is free software; you can redistribute it and/or modify | 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 | 6 | it under the terms of the GNU General Public License as published |
@@ -25,7 +25,7 @@ | |||
25 | */ | 25 | */ |
26 | #include "platform.h" | 26 | #include "platform.h" |
27 | #include "fs_test_lib.h" | 27 | #include "fs_test_lib.h" |
28 | #include "gnunet_testing_lib.h" | 28 | #include "gnunet_testbed_service.h" |
29 | 29 | ||
30 | #define VERBOSE GNUNET_NO | 30 | #define VERBOSE GNUNET_NO |
31 | 31 | ||
@@ -43,7 +43,7 @@ | |||
43 | 43 | ||
44 | #define SEED 42 | 44 | #define SEED 42 |
45 | 45 | ||
46 | static struct GNUNET_FS_TestDaemon *daemons[NUM_DAEMONS]; | 46 | static struct GNUNET_TESTBED_Peer *daemons[NUM_DAEMONS]; |
47 | 47 | ||
48 | static int ok; | 48 | static int ok; |
49 | 49 | ||
@@ -51,12 +51,6 @@ static struct GNUNET_TIME_Absolute start_time; | |||
51 | 51 | ||
52 | static const char *progname; | 52 | static const char *progname; |
53 | 53 | ||
54 | static void | ||
55 | do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
56 | { | ||
57 | GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons); | ||
58 | } | ||
59 | |||
60 | 54 | ||
61 | /** | 55 | /** |
62 | * Master context for 'stat_run'. | 56 | * Master context for 'stat_run'. |
@@ -64,6 +58,7 @@ do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
64 | struct StatMaster | 58 | struct StatMaster |
65 | { | 59 | { |
66 | struct GNUNET_STATISTICS_Handle *stat; | 60 | struct GNUNET_STATISTICS_Handle *stat; |
61 | struct GNUNET_TESTBED_Operation *op; | ||
67 | unsigned int daemon; | 62 | unsigned int daemon; |
68 | unsigned int value; | 63 | unsigned int value; |
69 | }; | 64 | }; |
@@ -130,7 +125,10 @@ print_stat (void *cls, const char *subsystem, const char *name, uint64_t value, | |||
130 | * Function that gathers stats from all daemons. | 125 | * Function that gathers stats from all daemons. |
131 | */ | 126 | */ |
132 | static void | 127 | static void |
133 | stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); | 128 | stat_run (void *cls, |
129 | struct GNUNET_TESTBED_Operation *op, | ||
130 | void *ca_result, | ||
131 | const char *emsg); | ||
134 | 132 | ||
135 | 133 | ||
136 | /** | 134 | /** |
@@ -143,7 +141,41 @@ get_done (void *cls, int success) | |||
143 | 141 | ||
144 | GNUNET_break (GNUNET_OK == success); | 142 | GNUNET_break (GNUNET_OK == success); |
145 | sm->value++; | 143 | sm->value++; |
146 | GNUNET_SCHEDULER_add_now (&stat_run, sm); | 144 | stat_run (sm, sm->op, sm->stat, NULL); |
145 | } | ||
146 | |||
147 | |||
148 | /** | ||
149 | * Adapter function called to establish a connection to | ||
150 | * statistics service. | ||
151 | * | ||
152 | * @param cls closure | ||
153 | * @param cfg configuration of the peer to connect to; will be available until | ||
154 | * GNUNET_TESTBED_operation_done() is called on the operation returned | ||
155 | * from GNUNET_TESTBED_service_connect() | ||
156 | * @return service handle to return in 'op_result', NULL on error | ||
157 | */ | ||
158 | static void * | ||
159 | statistics_connect_adapter (void *cls, | ||
160 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
161 | { | ||
162 | return GNUNET_STATISTICS_create ("<driver>", | ||
163 | cfg); | ||
164 | } | ||
165 | |||
166 | |||
167 | /** | ||
168 | * Adapter function called to destroy a connection to | ||
169 | * statistics service. | ||
170 | * | ||
171 | * @param cls closure | ||
172 | * @param op_result service handle returned from the connect adapter | ||
173 | */ | ||
174 | static void | ||
175 | statistics_disconnect_adapter (void *cls, | ||
176 | void *op_result) | ||
177 | { | ||
178 | GNUNET_STATISTICS_destroy (op_result, GNUNET_NO); | ||
147 | } | 179 | } |
148 | 180 | ||
149 | 181 | ||
@@ -151,10 +183,23 @@ get_done (void *cls, int success) | |||
151 | * Function that gathers stats from all daemons. | 183 | * Function that gathers stats from all daemons. |
152 | */ | 184 | */ |
153 | static void | 185 | static void |
154 | stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 186 | stat_run (void *cls, |
187 | struct GNUNET_TESTBED_Operation *op, | ||
188 | void *ca_result, | ||
189 | const char *emsg) | ||
155 | { | 190 | { |
156 | struct StatMaster *sm = cls; | 191 | struct StatMaster *sm = cls; |
157 | 192 | ||
193 | if (NULL != emsg) | ||
194 | { | ||
195 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
196 | "Failed to statistics service: %s\n", | ||
197 | emsg); | ||
198 | GNUNET_SCHEDULER_shutdown (); | ||
199 | return; | ||
200 | } | ||
201 | sm->stat = ca_result; | ||
202 | |||
158 | if (stats[sm->value].name != NULL) | 203 | if (stats[sm->value].name != NULL) |
159 | { | 204 | { |
160 | GNUNET_STATISTICS_get (sm->stat, | 205 | GNUNET_STATISTICS_get (sm->stat, |
@@ -167,20 +212,23 @@ stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
167 | sm); | 212 | sm); |
168 | return; | 213 | return; |
169 | } | 214 | } |
170 | GNUNET_STATISTICS_destroy (sm->stat, GNUNET_NO); | 215 | GNUNET_TESTBED_operation_done (sm->op); |
171 | sm->value = 0; | 216 | sm->value = 0; |
172 | sm->daemon++; | 217 | sm->daemon++; |
173 | if (sm->daemon == NUM_DAEMONS) | 218 | if (NUM_DAEMONS == sm->daemon) |
174 | { | 219 | { |
175 | GNUNET_free (sm); | 220 | GNUNET_free (sm); |
176 | GNUNET_SCHEDULER_add_now (&do_stop, NULL); | 221 | GNUNET_SCHEDULER_shutdown (); |
177 | return; | 222 | return; |
178 | } | 223 | } |
179 | sm->stat = | 224 | sm->op = |
180 | GNUNET_STATISTICS_create ("<driver>", | 225 | GNUNET_TESTBED_service_connect (NULL, |
181 | GNUNET_FS_TEST_get_configuration (daemons, | 226 | daemons[sm->daemon], |
182 | sm->daemon)); | 227 | "statistics", |
183 | GNUNET_SCHEDULER_add_now (&stat_run, sm); | 228 | &stat_run, sm, |
229 | &statistics_connect_adapter, | ||
230 | &statistics_disconnect_adapter, | ||
231 | NULL); | ||
184 | } | 232 | } |
185 | 233 | ||
186 | 234 | ||
@@ -191,32 +239,33 @@ do_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
191 | char *fancy; | 239 | char *fancy; |
192 | struct StatMaster *sm; | 240 | struct StatMaster *sm; |
193 | 241 | ||
194 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) | 242 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) |
195 | { | ||
196 | del = GNUNET_TIME_absolute_get_duration (start_time); | ||
197 | if (del.rel_value == 0) | ||
198 | del.rel_value = 1; | ||
199 | fancy = | ||
200 | GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) * | ||
201 | 1000LL / del.rel_value); | ||
202 | FPRINTF (stdout, "Download speed was %s/s\n", fancy); | ||
203 | GNUNET_free (fancy); | ||
204 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished download, shutting down\n", | ||
205 | (unsigned long long) FILESIZE); | ||
206 | sm = GNUNET_malloc (sizeof (struct StatMaster)); | ||
207 | sm->stat = | ||
208 | GNUNET_STATISTICS_create ("<driver>", | ||
209 | GNUNET_FS_TEST_get_configuration (daemons, | ||
210 | sm->daemon)); | ||
211 | GNUNET_SCHEDULER_add_now (&stat_run, sm); | ||
212 | } | ||
213 | else | ||
214 | { | 243 | { |
215 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 244 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
216 | "Timeout during download, shutting down with error\n"); | 245 | "Timeout during download, shutting down with error\n"); |
217 | ok = 1; | 246 | ok = 1; |
218 | GNUNET_SCHEDULER_add_now (&do_stop, NULL); | 247 | GNUNET_SCHEDULER_shutdown (); |
248 | return; | ||
219 | } | 249 | } |
250 | del = GNUNET_TIME_absolute_get_duration (start_time); | ||
251 | if (del.rel_value == 0) | ||
252 | del.rel_value = 1; | ||
253 | fancy = | ||
254 | GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) * | ||
255 | 1000LL / del.rel_value); | ||
256 | FPRINTF (stdout, "Download speed was %s/s\n", fancy); | ||
257 | GNUNET_free (fancy); | ||
258 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished download, shutting down\n", | ||
259 | (unsigned long long) FILESIZE); | ||
260 | sm = GNUNET_malloc (sizeof (struct StatMaster)); | ||
261 | sm->op = | ||
262 | GNUNET_TESTBED_service_connect (NULL, | ||
263 | daemons[sm->daemon], | ||
264 | "statistics", | ||
265 | &stat_run, sm, | ||
266 | &statistics_connect_adapter, | ||
267 | &statistics_disconnect_adapter, | ||
268 | NULL); | ||
220 | } | 269 | } |
221 | 270 | ||
222 | 271 | ||
@@ -226,8 +275,8 @@ do_download (void *cls, const struct GNUNET_FS_Uri *uri) | |||
226 | int anonymity; | 275 | int anonymity; |
227 | 276 | ||
228 | if (NULL == uri) | 277 | if (NULL == uri) |
229 | { | 278 | { |
230 | GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons); | 279 | GNUNET_SCHEDULER_shutdown (); |
231 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 280 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
232 | "Timeout during upload attempt, shutting down with error\n"); | 281 | "Timeout during upload attempt, shutting down with error\n"); |
233 | ok = 1; | 282 | ok = 1; |
@@ -246,14 +295,16 @@ do_download (void *cls, const struct GNUNET_FS_Uri *uri) | |||
246 | 295 | ||
247 | 296 | ||
248 | static void | 297 | static void |
249 | do_publish (void *cls, const char *emsg) | 298 | do_publish (void *cls, |
299 | struct GNUNET_TESTBED_Operation *op, | ||
300 | const char *emsg) | ||
250 | { | 301 | { |
251 | int do_index; | 302 | int do_index; |
252 | int anonymity; | 303 | int anonymity; |
253 | 304 | ||
254 | if (NULL != emsg) | 305 | if (NULL != emsg) |
255 | { | 306 | { |
256 | GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons); | 307 | GNUNET_SCHEDULER_shutdown (); |
257 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error trying to connect: %s\n", emsg); | 308 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error trying to connect: %s\n", emsg); |
258 | ok = 1; | 309 | ok = 1; |
259 | return; | 310 | return; |
@@ -276,53 +327,32 @@ do_publish (void *cls, const char *emsg) | |||
276 | 327 | ||
277 | 328 | ||
278 | static void | 329 | static void |
279 | do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 330 | do_connect (void *cls, |
331 | unsigned int num_peers, | ||
332 | struct GNUNET_TESTBED_Peer **peers) | ||
280 | { | 333 | { |
281 | struct GNUNET_TESTING_PeerGroup *pg; | 334 | unsigned int i; |
282 | 335 | ||
283 | GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)); | 336 | GNUNET_assert (NUM_DAEMONS == num_peers); |
284 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 337 | for (i=0;i<num_peers;i++) |
285 | "Daemons started, will now try to connect them\n"); | 338 | daemons[i] = peers[i]; |
286 | pg = GNUNET_FS_TEST_get_group (daemons); | 339 | GNUNET_TESTBED_overlay_connect (NULL, |
287 | GNUNET_break ((NUM_DAEMONS - 1) * 2 == | 340 | &do_publish, |
288 | (GNUNET_TESTING_create_topology | 341 | NULL, |
289 | (pg, GNUNET_TESTING_TOPOLOGY_LINE, | 342 | peers[0], |
290 | GNUNET_TESTING_TOPOLOGY_NONE, NULL))); | 343 | peers[1]); |
291 | GNUNET_TESTING_connect_topology (pg, GNUNET_TESTING_TOPOLOGY_LINE, | 344 | // FIXME: was supposed to connect in line... |
292 | GNUNET_TESTING_TOPOLOGY_OPTION_NONE, 0.0, | ||
293 | TIMEOUT, NUM_DAEMONS, &do_publish, NULL); | ||
294 | } | ||
295 | |||
296 | |||
297 | static void | ||
298 | run (void *cls, char *const *args, const char *cfgfile, | ||
299 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
300 | { | ||
301 | GNUNET_FS_TEST_daemons_start ("perf_gnunet_service_fs_p2p.conf", TIMEOUT, NUM_DAEMONS, | ||
302 | daemons, &do_connect, NULL); | ||
303 | } | 345 | } |
304 | 346 | ||
305 | 347 | ||
306 | int | 348 | int |
307 | main (int argc, char *argv[]) | 349 | main (int argc, char *argv[]) |
308 | { | 350 | { |
309 | char *const argvx[] = { | 351 | GNUNET_TESTBED_test_run ("perf-gnunet-service-fs-p2p", |
310 | "perf-gnunet-service-fs-p2p", | 352 | "perf_gnunet_service_fs_p2p.conf", |
311 | "-c", | 353 | NUM_DAEMONS, |
312 | "perf_gnunet_service_fs_p2p.conf", | 354 | 0, NULL, NULL, |
313 | NULL | 355 | &do_connect, NULL); |
314 | }; | ||
315 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
316 | GNUNET_GETOPT_OPTION_END | ||
317 | }; | ||
318 | progname = argv[0]; | ||
319 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); | ||
320 | GNUNET_log_setup ("perf_gnunet_service_fs_p2p_index", | ||
321 | "WARNING", | ||
322 | NULL); | ||
323 | GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, argvx, | ||
324 | "perf-gnunet-service-fs-p2p-index", "nohelp", options, | ||
325 | &run, NULL); | ||
326 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); | 356 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); |
327 | return ok; | 357 | return ok; |
328 | } | 358 | } |
diff --git a/src/fs/perf_gnunet_service_fs_p2p_respect.c b/src/fs/perf_gnunet_service_fs_p2p_respect.c index 58fe34eef..3030749e2 100644 --- a/src/fs/perf_gnunet_service_fs_p2p_respect.c +++ b/src/fs/perf_gnunet_service_fs_p2p_respect.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | (C) 2010, 2011 Christian Grothoff (and other contributing authors) | 3 | (C) 2010, 2011, 2012 Christian Grothoff (and other contributing authors) |
4 | 4 | ||
5 | GNUnet is free software; you can redistribute it and/or modify | 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 | 6 | it under the terms of the GNU General Public License as published |
@@ -45,7 +45,7 @@ | |||
45 | */ | 45 | */ |
46 | #include "platform.h" | 46 | #include "platform.h" |
47 | #include "fs_test_lib.h" | 47 | #include "fs_test_lib.h" |
48 | #include "gnunet_testing_lib.h" | 48 | #include "gnunet_testbed_service.h" |
49 | 49 | ||
50 | #define VERBOSE GNUNET_NO | 50 | #define VERBOSE GNUNET_NO |
51 | 51 | ||
@@ -74,7 +74,7 @@ | |||
74 | */ | 74 | */ |
75 | #define SEED2 43 | 75 | #define SEED2 43 |
76 | 76 | ||
77 | static struct GNUNET_FS_TestDaemon *daemons[NUM_DAEMONS]; | 77 | static struct GNUNET_TESTBED_Peer *daemons[NUM_DAEMONS]; |
78 | 78 | ||
79 | static int ok; | 79 | static int ok; |
80 | 80 | ||
@@ -86,12 +86,6 @@ static struct GNUNET_FS_Uri *uri1; | |||
86 | 86 | ||
87 | static struct GNUNET_FS_Uri *uri2; | 87 | static struct GNUNET_FS_Uri *uri2; |
88 | 88 | ||
89 | static void | ||
90 | do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
91 | { | ||
92 | GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons); | ||
93 | } | ||
94 | |||
95 | 89 | ||
96 | /** | 90 | /** |
97 | * Master context for 'stat_run'. | 91 | * Master context for 'stat_run'. |
@@ -99,6 +93,7 @@ do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
99 | struct StatMaster | 93 | struct StatMaster |
100 | { | 94 | { |
101 | struct GNUNET_STATISTICS_Handle *stat; | 95 | struct GNUNET_STATISTICS_Handle *stat; |
96 | struct GNUNET_TESTBED_Operation *op; | ||
102 | unsigned int daemon; | 97 | unsigned int daemon; |
103 | unsigned int value; | 98 | unsigned int value; |
104 | }; | 99 | }; |
@@ -163,7 +158,10 @@ print_stat (void *cls, const char *subsystem, const char *name, uint64_t value, | |||
163 | * Function that gathers stats from all daemons. | 158 | * Function that gathers stats from all daemons. |
164 | */ | 159 | */ |
165 | static void | 160 | static void |
166 | stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); | 161 | stat_run (void *cls, |
162 | struct GNUNET_TESTBED_Operation *op, | ||
163 | void *ca_result, | ||
164 | const char *emsg); | ||
167 | 165 | ||
168 | 166 | ||
169 | /** | 167 | /** |
@@ -176,7 +174,42 @@ get_done (void *cls, int success) | |||
176 | 174 | ||
177 | GNUNET_break (GNUNET_OK == success); | 175 | GNUNET_break (GNUNET_OK == success); |
178 | sm->value++; | 176 | sm->value++; |
179 | GNUNET_SCHEDULER_add_now (&stat_run, sm); | 177 | stat_run (sm, sm->op, sm->stat, NULL); |
178 | } | ||
179 | |||
180 | |||
181 | |||
182 | /** | ||
183 | * Adapter function called to establish a connection to | ||
184 | * statistics service. | ||
185 | * | ||
186 | * @param cls closure | ||
187 | * @param cfg configuration of the peer to connect to; will be available until | ||
188 | * GNUNET_TESTBED_operation_done() is called on the operation returned | ||
189 | * from GNUNET_TESTBED_service_connect() | ||
190 | * @return service handle to return in 'op_result', NULL on error | ||
191 | */ | ||
192 | static void * | ||
193 | statistics_connect_adapter (void *cls, | ||
194 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
195 | { | ||
196 | return GNUNET_STATISTICS_create ("<driver>", | ||
197 | cfg); | ||
198 | } | ||
199 | |||
200 | |||
201 | /** | ||
202 | * Adapter function called to destroy a connection to | ||
203 | * statistics service. | ||
204 | * | ||
205 | * @param cls closure | ||
206 | * @param op_result service handle returned from the connect adapter | ||
207 | */ | ||
208 | static void | ||
209 | statistics_disconnect_adapter (void *cls, | ||
210 | void *op_result) | ||
211 | { | ||
212 | GNUNET_STATISTICS_destroy (op_result, GNUNET_NO); | ||
180 | } | 213 | } |
181 | 214 | ||
182 | 215 | ||
@@ -184,7 +217,10 @@ get_done (void *cls, int success) | |||
184 | * Function that gathers stats from all daemons. | 217 | * Function that gathers stats from all daemons. |
185 | */ | 218 | */ |
186 | static void | 219 | static void |
187 | stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 220 | stat_run (void *cls, |
221 | struct GNUNET_TESTBED_Operation *op, | ||
222 | void *ca_result, | ||
223 | const char *emsg) | ||
188 | { | 224 | { |
189 | struct StatMaster *sm = cls; | 225 | struct StatMaster *sm = cls; |
190 | 226 | ||
@@ -200,20 +236,23 @@ stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
200 | sm); | 236 | sm); |
201 | return; | 237 | return; |
202 | } | 238 | } |
203 | GNUNET_STATISTICS_destroy (sm->stat, GNUNET_NO); | 239 | GNUNET_TESTBED_operation_done (sm->op); |
204 | sm->value = 0; | 240 | sm->value = 0; |
205 | sm->daemon++; | 241 | sm->daemon++; |
206 | if (sm->daemon == NUM_DAEMONS) | 242 | if (NUM_DAEMONS == sm->daemon) |
207 | { | 243 | { |
208 | GNUNET_free (sm); | 244 | GNUNET_free (sm); |
209 | GNUNET_SCHEDULER_add_now (&do_stop, NULL); | 245 | GNUNET_SCHEDULER_shutdown (); |
210 | return; | 246 | return; |
211 | } | 247 | } |
212 | sm->stat = | 248 | sm->op = |
213 | GNUNET_STATISTICS_create ("<driver>", | 249 | GNUNET_TESTBED_service_connect (NULL, |
214 | GNUNET_FS_TEST_get_configuration (daemons, | 250 | daemons[sm->daemon], |
215 | sm->daemon)); | 251 | "statistics", |
216 | GNUNET_SCHEDULER_add_now (&stat_run, sm); | 252 | &stat_run, sm, |
253 | &statistics_connect_adapter, | ||
254 | &statistics_disconnect_adapter, | ||
255 | NULL); | ||
217 | } | 256 | } |
218 | 257 | ||
219 | 258 | ||
@@ -226,36 +265,37 @@ do_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
226 | char *fancy; | 265 | char *fancy; |
227 | struct StatMaster *sm; | 266 | struct StatMaster *sm; |
228 | 267 | ||
229 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)) | 268 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)) |
230 | { | ||
231 | del = GNUNET_TIME_absolute_get_duration (start_time); | ||
232 | if (del.rel_value == 0) | ||
233 | del.rel_value = 1; | ||
234 | fancy = | ||
235 | GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) * | ||
236 | 1000LL / del.rel_value); | ||
237 | FPRINTF (stderr, "Download speed of type `%s' was %s/s\n", type, fancy); | ||
238 | GNUNET_free (fancy); | ||
239 | if (NUM_DAEMONS != ++download_counter) | ||
240 | return; /* more downloads to come */ | ||
241 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
242 | "Finished all downloads, shutting down\n", | ||
243 | (unsigned long long) FILESIZE); | ||
244 | sm = GNUNET_malloc (sizeof (struct StatMaster)); | ||
245 | sm->stat = | ||
246 | GNUNET_STATISTICS_create ("<driver>", | ||
247 | GNUNET_FS_TEST_get_configuration (daemons, | ||
248 | sm->daemon)); | ||
249 | GNUNET_SCHEDULER_add_now (&stat_run, sm); | ||
250 | } | ||
251 | else | ||
252 | { | 269 | { |
253 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 270 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
254 | "Timeout during download for type `%s', shutting down with error\n", | 271 | "Timeout during download for type `%s', shutting down with error\n", |
255 | type); | 272 | type); |
256 | ok = 1; | 273 | ok = 1; |
257 | GNUNET_SCHEDULER_add_now (&do_stop, NULL); | 274 | GNUNET_SCHEDULER_shutdown (); |
275 | return; | ||
258 | } | 276 | } |
277 | del = GNUNET_TIME_absolute_get_duration (start_time); | ||
278 | if (del.rel_value == 0) | ||
279 | del.rel_value = 1; | ||
280 | fancy = | ||
281 | GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) * | ||
282 | 1000LL / del.rel_value); | ||
283 | FPRINTF (stderr, "Download speed of type `%s' was %s/s\n", type, fancy); | ||
284 | GNUNET_free (fancy); | ||
285 | if (NUM_DAEMONS != ++download_counter) | ||
286 | return; /* more downloads to come */ | ||
287 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
288 | "Finished all downloads, shutting down\n", | ||
289 | (unsigned long long) FILESIZE); | ||
290 | sm = GNUNET_malloc (sizeof (struct StatMaster)); | ||
291 | sm->op = | ||
292 | GNUNET_TESTBED_service_connect (NULL, | ||
293 | daemons[sm->daemon], | ||
294 | "statistics", | ||
295 | &stat_run, sm, | ||
296 | &statistics_connect_adapter, | ||
297 | &statistics_disconnect_adapter, | ||
298 | NULL); | ||
259 | } | 299 | } |
260 | 300 | ||
261 | 301 | ||
@@ -267,7 +307,7 @@ do_downloads (void *cls, const struct GNUNET_FS_Uri *u2) | |||
267 | 307 | ||
268 | if (NULL == u2) | 308 | if (NULL == u2) |
269 | { | 309 | { |
270 | GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons); | 310 | GNUNET_SCHEDULER_shutdown (); |
271 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 311 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
272 | "Timeout during upload attempt, shutting down with error\n"); | 312 | "Timeout during upload attempt, shutting down with error\n"); |
273 | ok = 1; | 313 | ok = 1; |
@@ -298,14 +338,15 @@ do_downloads (void *cls, const struct GNUNET_FS_Uri *u2) | |||
298 | 338 | ||
299 | 339 | ||
300 | static void | 340 | static void |
301 | do_publish2 (void *cls, const struct GNUNET_FS_Uri *u1) | 341 | do_publish2 (void *cls, |
342 | const struct GNUNET_FS_Uri *u1) | ||
302 | { | 343 | { |
303 | int do_index; | 344 | int do_index; |
304 | int anonymity; | 345 | int anonymity; |
305 | 346 | ||
306 | if (NULL == u1) | 347 | if (NULL == u1) |
307 | { | 348 | { |
308 | GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons); | 349 | GNUNET_SCHEDULER_shutdown (); |
309 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 350 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
310 | "Timeout during upload attempt, shutting down with error\n"); | 351 | "Timeout during upload attempt, shutting down with error\n"); |
311 | ok = 1; | 352 | ok = 1; |
@@ -329,18 +370,23 @@ do_publish2 (void *cls, const struct GNUNET_FS_Uri *u1) | |||
329 | } | 370 | } |
330 | 371 | ||
331 | static void | 372 | static void |
332 | do_publish1 (void *cls, const char *emsg) | 373 | do_publish1 (void *cls, |
374 | struct GNUNET_TESTBED_Operation *op, | ||
375 | const char *emsg) | ||
333 | { | 376 | { |
377 | unsigned int *coco = cls; | ||
334 | int do_index; | 378 | int do_index; |
335 | int anonymity; | 379 | int anonymity; |
336 | 380 | ||
337 | if (NULL != emsg) | 381 | if (NULL != emsg) |
338 | { | 382 | { |
339 | GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons); | 383 | GNUNET_SCHEDULER_shutdown (); |
340 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error trying to connect: %s\n", emsg); | 384 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error trying to connect: %s\n", emsg); |
341 | ok = 1; | 385 | ok = 1; |
342 | return; | 386 | return; |
343 | } | 387 | } |
388 | if (0 != (--(*coco))) | ||
389 | return; /* more connections to be created */ | ||
344 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n", | 390 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n", |
345 | (unsigned long long) FILESIZE); | 391 | (unsigned long long) FILESIZE); |
346 | if (NULL != strstr (progname, "index")) | 392 | if (NULL != strstr (progname, "index")) |
@@ -351,7 +397,6 @@ do_publish1 (void *cls, const char *emsg) | |||
351 | anonymity = 0; | 397 | anonymity = 0; |
352 | else | 398 | else |
353 | anonymity = 1; | 399 | anonymity = 1; |
354 | |||
355 | GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS - 1], TIMEOUT, anonymity, | 400 | GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS - 1], TIMEOUT, anonymity, |
356 | do_index, FILESIZE, SEED1, VERBOSE, &do_publish2, | 401 | do_index, FILESIZE, SEED1, VERBOSE, &do_publish2, |
357 | NULL); | 402 | NULL); |
@@ -359,51 +404,38 @@ do_publish1 (void *cls, const char *emsg) | |||
359 | 404 | ||
360 | 405 | ||
361 | static void | 406 | static void |
362 | do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 407 | do_connect (void *cls, |
408 | unsigned int num_peers, | ||
409 | struct GNUNET_TESTBED_Peer **peers) | ||
363 | { | 410 | { |
364 | struct GNUNET_TESTING_PeerGroup *pg; | 411 | static unsigned int coco; |
365 | 412 | unsigned int i; | |
366 | GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)); | 413 | unsigned int j; |
367 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 414 | |
368 | "Daemons started, will now try to connect them\n"); | 415 | GNUNET_assert (NUM_DAEMONS == num_peers); |
369 | pg = GNUNET_FS_TEST_get_group (daemons); | 416 | for (i=0;i<num_peers;i++) |
370 | GNUNET_TESTING_create_topology (pg, GNUNET_TESTING_TOPOLOGY_CLIQUE, | 417 | daemons[i] = peers[i]; |
371 | GNUNET_TESTING_TOPOLOGY_NONE, NULL); | 418 | for (i=0;i<NUM_DAEMONS;i++) |
372 | GNUNET_TESTING_connect_topology (pg, GNUNET_TESTING_TOPOLOGY_CLIQUE, | 419 | for (j=i+1;j<NUM_DAEMONS;j++) |
373 | GNUNET_TESTING_TOPOLOGY_OPTION_NONE, 0.0, | 420 | { |
374 | TIMEOUT, NUM_DAEMONS, &do_publish1, NULL); | 421 | coco++; |
375 | } | 422 | GNUNET_TESTBED_overlay_connect (NULL, |
376 | 423 | &do_publish1, | |
377 | 424 | &coco, | |
378 | static void | 425 | peers[i], |
379 | run (void *cls, char *const *args, const char *cfgfile, | 426 | peers[j]); |
380 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 427 | } |
381 | { | ||
382 | GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf", TIMEOUT, NUM_DAEMONS, | ||
383 | daemons, &do_connect, NULL); | ||
384 | } | 428 | } |
385 | 429 | ||
386 | 430 | ||
387 | int | 431 | int |
388 | main (int argc, char *argv[]) | 432 | main (int argc, char *argv[]) |
389 | { | 433 | { |
390 | char *const argvx[] = { | 434 | GNUNET_TESTBED_test_run ("perf-gnunet-service-fs-p2p-respect", |
391 | "perf-gnunet-service-fs-p2p", | 435 | "perf_gnunet_service_fs_p2p.conf", |
392 | "-c", | 436 | NUM_DAEMONS, |
393 | "fs_test_lib_data.conf", | 437 | 0, NULL, NULL, |
394 | NULL | 438 | &do_connect, NULL); |
395 | }; | ||
396 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
397 | GNUNET_GETOPT_OPTION_END | ||
398 | }; | ||
399 | progname = argv[0]; | ||
400 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); | ||
401 | GNUNET_log_setup ("perf_gnunet_service_fs_p2p_respect", | ||
402 | "WARNING", | ||
403 | NULL); | ||
404 | GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, argvx, | ||
405 | "perf-gnunet-service-fs-p2p-respect", "nohelp", options, | ||
406 | &run, NULL); | ||
407 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); | 439 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); |
408 | return ok; | 440 | return ok; |
409 | } | 441 | } |
diff --git a/src/fs/test_fs_test_lib.c b/src/fs/test_fs_test_lib.c index 29d5fe47f..bee7909a9 100644 --- a/src/fs/test_fs_test_lib.c +++ b/src/fs/test_fs_test_lib.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | (C) 2010 Christian Grothoff (and other contributing authors) | 3 | (C) 2010, 2012 Christian Grothoff (and other contributing authors) |
4 | 4 | ||
5 | GNUnet is free software; you can redistribute it and/or modify | 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 | 6 | it under the terms of the GNU General Public License as published |
@@ -42,20 +42,14 @@ | |||
42 | 42 | ||
43 | #define SEED 42 | 43 | #define SEED 42 |
44 | 44 | ||
45 | static struct GNUNET_FS_TestDaemon *daemons[NUM_DAEMONS]; | 45 | static struct GNUNET_TESTBED_Peer *the_peers[NUM_DAEMONS]; |
46 | |||
47 | static struct GNUNET_FS_TEST_ConnectContext *cc; | ||
48 | 46 | ||
49 | static int ret; | 47 | static int ret; |
50 | 48 | ||
49 | |||
51 | static void | 50 | static void |
52 | do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 51 | do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
53 | { | 52 | { |
54 | if (NULL != cc) | ||
55 | { | ||
56 | GNUNET_FS_TEST_daemons_connect_cancel (cc); | ||
57 | cc = NULL; | ||
58 | } | ||
59 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)) | 53 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)) |
60 | { | 54 | { |
61 | GNUNET_break (0); | 55 | GNUNET_break (0); |
@@ -66,7 +60,7 @@ do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
66 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished download, shutting down\n", | 60 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished download, shutting down\n", |
67 | (unsigned long long) FILESIZE); | 61 | (unsigned long long) FILESIZE); |
68 | } | 62 | } |
69 | GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons); | 63 | GNUNET_SCHEDULER_shutdown (); |
70 | } | 64 | } |
71 | 65 | ||
72 | 66 | ||
@@ -76,80 +70,80 @@ do_download (void *cls, const struct GNUNET_FS_Uri *uri) | |||
76 | if (NULL == uri) | 70 | if (NULL == uri) |
77 | { | 71 | { |
78 | GNUNET_break (0); | 72 | GNUNET_break (0); |
79 | GNUNET_SCHEDULER_add_now (&do_stop, NULL); | 73 | GNUNET_SCHEDULER_shutdown (); |
80 | ret = 1; | 74 | ret = 1; |
81 | return; | 75 | return; |
82 | } | 76 | } |
83 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Downloading %llu bytes\n", | 77 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Downloading %llu bytes\n", |
84 | (unsigned long long) FILESIZE); | 78 | (unsigned long long) FILESIZE); |
85 | GNUNET_FS_TEST_download (daemons[0], TIMEOUT, 1, SEED, uri, VERBOSE, &do_stop, | 79 | GNUNET_FS_TEST_download (the_peers[0], TIMEOUT, 1, SEED, uri, VERBOSE, &do_stop, |
86 | NULL); | 80 | NULL); |
87 | } | 81 | } |
88 | 82 | ||
89 | 83 | ||
90 | static void | 84 | static void |
91 | do_publish (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 85 | do_publish (void *cls, |
86 | struct GNUNET_TESTBED_Operation *op, | ||
87 | const char *emsg) | ||
92 | { | 88 | { |
93 | cc = NULL; | 89 | if (NULL != emsg) |
94 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)) | ||
95 | { | 90 | { |
91 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to connect peers: %s\n", emsg); | ||
96 | GNUNET_break (0); | 92 | GNUNET_break (0); |
97 | ret = 1; | 93 | ret = 1; |
98 | GNUNET_SCHEDULER_add_now (&do_stop, NULL); | 94 | GNUNET_SCHEDULER_shutdown (); |
99 | return; | 95 | return; |
100 | } | 96 | } |
97 | GNUNET_TESTBED_operation_done (op); | ||
101 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n", | 98 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n", |
102 | (unsigned long long) FILESIZE); | 99 | (unsigned long long) FILESIZE); |
103 | GNUNET_FS_TEST_publish (daemons[0], TIMEOUT, 1, GNUNET_NO, FILESIZE, SEED, | 100 | GNUNET_FS_TEST_publish (the_peers[0], TIMEOUT, 1, GNUNET_NO, FILESIZE, SEED, |
104 | VERBOSE, &do_download, NULL); | 101 | VERBOSE, &do_download, NULL); |
105 | } | ||
106 | |||
107 | 102 | ||
108 | static void | ||
109 | do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
110 | { | ||
111 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)) | ||
112 | { | ||
113 | GNUNET_break (0); | ||
114 | ret = 1; | ||
115 | GNUNET_SCHEDULER_add_now (&do_stop, NULL); | ||
116 | return; | ||
117 | } | ||
118 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
119 | "Daemons started, will now try to connect them\n"); | ||
120 | cc = GNUNET_FS_TEST_daemons_connect (daemons[0], daemons[1], TIMEOUT, | ||
121 | &do_publish, NULL); | ||
122 | } | 103 | } |
123 | 104 | ||
124 | 105 | ||
106 | /** | ||
107 | * Actual main function for the test. | ||
108 | * | ||
109 | * @param cls closure | ||
110 | * @param num_peers number of peers in 'peers' | ||
111 | * @param peers handle to peers run in the testbed | ||
112 | */ | ||
125 | static void | 113 | static void |
126 | run (void *cls, char *const *args, const char *cfgfile, | 114 | run (void *cls, |
127 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 115 | unsigned int num_peers, |
116 | struct GNUNET_TESTBED_Peer **peers) | ||
128 | { | 117 | { |
129 | GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf", TIMEOUT, NUM_DAEMONS, | 118 | unsigned int i; |
130 | daemons, &do_connect, NULL); | 119 | |
120 | GNUNET_assert (NUM_DAEMONS == num_peers); | ||
121 | for (i=0;i<num_peers;i++) | ||
122 | the_peers[i] = peers[i]; | ||
123 | GNUNET_TESTBED_overlay_connect (NULL, | ||
124 | &do_publish, | ||
125 | NULL, | ||
126 | peers[0], | ||
127 | peers[1]); | ||
131 | } | 128 | } |
132 | 129 | ||
133 | 130 | ||
131 | /** | ||
132 | * Main function that initializes the testbed. | ||
133 | * | ||
134 | * @param argc ignored | ||
135 | * @param argv ignored | ||
136 | * @return 0 on success | ||
137 | */ | ||
134 | int | 138 | int |
135 | main (int argc, char *argv[]) | 139 | main (int argc, char *argv[]) |
136 | { | 140 | { |
137 | char *const argvx[] = { | ||
138 | "test-fs-test-lib", | ||
139 | "-c", | ||
140 | "fs_test_lib_data.conf", | ||
141 | NULL | ||
142 | }; | ||
143 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
144 | GNUNET_GETOPT_OPTION_END | ||
145 | }; | ||
146 | |||
147 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); | 141 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); |
148 | GNUNET_log_setup ("test_fs_test_lib", | 142 | GNUNET_TESTBED_test_run ("test_fs_test_lib", |
149 | "WARNING", | 143 | "fs_test_lib_data.conf", |
150 | NULL); | 144 | NUM_DAEMONS, |
151 | GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, argvx, | 145 | 0, NULL, NULL, |
152 | "test-fs-test-lib", "nohelp", options, &run, NULL); | 146 | &run, NULL); |
153 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); | 147 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); |
154 | return ret; | 148 | return ret; |
155 | } | 149 | } |
diff --git a/src/fs/test_gnunet_service_fs_migration.c b/src/fs/test_gnunet_service_fs_migration.c index 00aab4f42..f1f2084f9 100644 --- a/src/fs/test_gnunet_service_fs_migration.c +++ b/src/fs/test_gnunet_service_fs_migration.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | (C) 2010 Christian Grothoff (and other contributing authors) | 3 | (C) 2010, 2012 Christian Grothoff (and other contributing authors) |
4 | 4 | ||
5 | GNUnet is free software; you can redistribute it and/or modify | 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 | 6 | it under the terms of the GNU General Public License as published |
@@ -25,7 +25,7 @@ | |||
25 | */ | 25 | */ |
26 | #include "platform.h" | 26 | #include "platform.h" |
27 | #include "fs_test_lib.h" | 27 | #include "fs_test_lib.h" |
28 | #include "gnunet_testing_lib.h" | 28 | #include "gnunet_testbed_service.h" |
29 | 29 | ||
30 | #define VERBOSE GNUNET_NO | 30 | #define VERBOSE GNUNET_NO |
31 | 31 | ||
@@ -46,13 +46,12 @@ | |||
46 | 46 | ||
47 | #define SEED 42 | 47 | #define SEED 42 |
48 | 48 | ||
49 | static struct GNUNET_FS_TestDaemon *daemons[2]; | 49 | static struct GNUNET_TESTBED_Peer *daemons[2]; |
50 | 50 | ||
51 | static int ok; | 51 | static int ok; |
52 | 52 | ||
53 | static struct GNUNET_TIME_Absolute start_time; | 53 | static struct GNUNET_TIME_Absolute start_time; |
54 | 54 | ||
55 | static struct GNUNET_FS_TEST_ConnectContext *cc; | ||
56 | 55 | ||
57 | static void | 56 | static void |
58 | do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 57 | do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
@@ -60,12 +59,7 @@ do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
60 | struct GNUNET_TIME_Relative del; | 59 | struct GNUNET_TIME_Relative del; |
61 | char *fancy; | 60 | char *fancy; |
62 | 61 | ||
63 | if (NULL != cc) | 62 | GNUNET_SCHEDULER_shutdown (); |
64 | { | ||
65 | GNUNET_FS_TEST_daemons_connect_cancel (cc); | ||
66 | cc = NULL; | ||
67 | } | ||
68 | GNUNET_FS_TEST_daemons_stop (2, daemons); | ||
69 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) | 63 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) |
70 | { | 64 | { |
71 | del = GNUNET_TIME_absolute_get_duration (start_time); | 65 | del = GNUNET_TIME_absolute_get_duration (start_time); |
@@ -89,13 +83,14 @@ do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
89 | 83 | ||
90 | 84 | ||
91 | static void | 85 | static void |
92 | do_download (void *cls, const char *emsg) | 86 | do_download (void *cls, |
87 | const char *emsg) | ||
93 | { | 88 | { |
94 | struct GNUNET_FS_Uri *uri = cls; | 89 | struct GNUNET_FS_Uri *uri = cls; |
95 | 90 | ||
96 | if (emsg != NULL) | 91 | if (NULL != emsg) |
97 | { | 92 | { |
98 | GNUNET_FS_TEST_daemons_stop (2, daemons); | 93 | GNUNET_SCHEDULER_shutdown (); |
99 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to stop source daemon: %s\n", | 94 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to stop source daemon: %s\n", |
100 | emsg); | 95 | emsg); |
101 | GNUNET_FS_uri_destroy (uri); | 96 | GNUNET_FS_uri_destroy (uri); |
@@ -115,11 +110,9 @@ static void | |||
115 | stop_source_peer (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 110 | stop_source_peer (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
116 | { | 111 | { |
117 | struct GNUNET_FS_Uri *uri = cls; | 112 | struct GNUNET_FS_Uri *uri = cls; |
118 | struct GNUNET_TESTING_PeerGroup *pg; | ||
119 | 113 | ||
120 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping source peer\n"); | 114 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping source peer\n"); |
121 | pg = GNUNET_FS_TEST_get_group (daemons); | 115 | GNUNET_TESTBED_peer_stop (daemons[1], &do_download, uri); |
122 | GNUNET_TESTING_daemons_vary (pg, 1, GNUNET_NO, TIMEOUT, &do_download, uri); | ||
123 | } | 116 | } |
124 | 117 | ||
125 | 118 | ||
@@ -130,7 +123,7 @@ do_wait (void *cls, const struct GNUNET_FS_Uri *uri) | |||
130 | 123 | ||
131 | if (NULL == uri) | 124 | if (NULL == uri) |
132 | { | 125 | { |
133 | GNUNET_FS_TEST_daemons_stop (2, daemons); | 126 | GNUNET_SCHEDULER_shutdown (); |
134 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 127 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
135 | "Timeout during upload attempt, shutting down with error\n"); | 128 | "Timeout during upload attempt, shutting down with error\n"); |
136 | ok = 1; | 129 | ok = 1; |
@@ -143,14 +136,16 @@ do_wait (void *cls, const struct GNUNET_FS_Uri *uri) | |||
143 | 136 | ||
144 | 137 | ||
145 | static void | 138 | static void |
146 | do_publish (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 139 | do_publish (void *cls, |
140 | struct GNUNET_TESTBED_Operation *op, | ||
141 | const char *emsg) | ||
147 | { | 142 | { |
148 | cc = NULL; | 143 | if (NULL != emsg) |
149 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) | ||
150 | { | 144 | { |
151 | GNUNET_FS_TEST_daemons_stop (2, daemons); | 145 | GNUNET_SCHEDULER_shutdown (); |
152 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 146 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
153 | "Timeout during connect attempt, shutting down with error\n"); | 147 | "Error connecting peers: %s\n", |
148 | emsg); | ||
154 | ok = 1; | 149 | ok = 1; |
155 | return; | 150 | return; |
156 | } | 151 | } |
@@ -162,58 +157,32 @@ do_publish (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
162 | 157 | ||
163 | 158 | ||
164 | static void | 159 | static void |
165 | do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 160 | do_connect (void *cls, |
161 | unsigned int num_peers, | ||
162 | struct GNUNET_TESTBED_Peer **peers) | ||
166 | { | 163 | { |
167 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)) | 164 | unsigned int i; |
168 | { | 165 | |
169 | FPRINTF (stderr, "%s", "Daemons failed to start!\n"); | 166 | GNUNET_assert (2 == num_peers); |
170 | GNUNET_break (0); | 167 | for (i=0;i<num_peers;i++) |
171 | ok = 1; | 168 | daemons[i] = peers[i]; |
172 | return; | ||
173 | } | ||
174 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 169 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
175 | "Daemons started, will now try to connect them\n"); | 170 | "Daemons started, will now try to connect them\n"); |
176 | cc = GNUNET_FS_TEST_daemons_connect (daemons[0], daemons[1], TIMEOUT, | 171 | GNUNET_TESTBED_overlay_connect (NULL, |
177 | &do_publish, NULL); | 172 | &do_publish, NULL, |
178 | } | 173 | daemons[0], daemons[1]); |
179 | |||
180 | |||
181 | static void | ||
182 | run (void *cls, char *const *args, const char *cfgfile, | ||
183 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
184 | { | ||
185 | GNUNET_FS_TEST_daemons_start ("test_gnunet_service_fs_migration_data.conf", | ||
186 | TIMEOUT, 2, daemons, &do_connect, NULL); | ||
187 | } | 174 | } |
188 | 175 | ||
189 | 176 | ||
190 | int | 177 | int |
191 | main (int argc, char *argv[]) | 178 | main (int argc, char *argv[]) |
192 | { | 179 | { |
193 | char *const argvx[] = { | 180 | GNUNET_TESTBED_test_run ("test-gnunet-service-fs-migration", |
194 | "test-gnunet-service-fs-migration", | 181 | "fs_test_lib_data.conf", |
195 | "-c", | 182 | 2, |
196 | "fs_test_lib_data.conf", | 183 | 0, NULL, NULL, |
197 | #if VERBOSE | 184 | &do_connect, |
198 | "-L", "DEBUG", | 185 | NULL); |
199 | #endif | ||
200 | NULL | ||
201 | }; | ||
202 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
203 | GNUNET_GETOPT_OPTION_END | ||
204 | }; | ||
205 | |||
206 | GNUNET_DISK_directory_remove ("/tmp/test-gnunet-service-fs-migration/"); | ||
207 | GNUNET_log_setup ("test_gnunet_service_fs_migration", | ||
208 | #if VERBOSE | ||
209 | "DEBUG", | ||
210 | #else | ||
211 | "WARNING", | ||
212 | #endif | ||
213 | NULL); | ||
214 | GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, argvx, | ||
215 | "test-gnunet-service-fs-migration", "nohelp", options, | ||
216 | &run, NULL); | ||
217 | GNUNET_DISK_directory_remove ("/tmp/test-gnunet-service-fs-migration/"); | 186 | GNUNET_DISK_directory_remove ("/tmp/test-gnunet-service-fs-migration/"); |
218 | return ok; | 187 | return ok; |
219 | } | 188 | } |
diff --git a/src/fs/test_gnunet_service_fs_p2p.c b/src/fs/test_gnunet_service_fs_p2p.c index 7ca786ed2..df7b9604b 100644 --- a/src/fs/test_gnunet_service_fs_p2p.c +++ b/src/fs/test_gnunet_service_fs_p2p.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | (C) 2010 Christian Grothoff (and other contributing authors) | 3 | (C) 2010, 2012 Christian Grothoff (and other contributing authors) |
4 | 4 | ||
5 | GNUnet is free software; you can redistribute it and/or modify | 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 | 6 | it under the terms of the GNU General Public License as published |
@@ -42,13 +42,12 @@ | |||
42 | 42 | ||
43 | #define SEED 42 | 43 | #define SEED 42 |
44 | 44 | ||
45 | static struct GNUNET_FS_TestDaemon *daemons[NUM_DAEMONS]; | 45 | static struct GNUNET_TESTBED_Peer *daemons[NUM_DAEMONS]; |
46 | 46 | ||
47 | static int ok; | 47 | static int ok; |
48 | 48 | ||
49 | static struct GNUNET_TIME_Absolute start_time; | 49 | static struct GNUNET_TIME_Absolute start_time; |
50 | 50 | ||
51 | static struct GNUNET_FS_TEST_ConnectContext *cc; | ||
52 | 51 | ||
53 | static void | 52 | static void |
54 | do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 53 | do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
@@ -56,12 +55,7 @@ do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
56 | struct GNUNET_TIME_Relative del; | 55 | struct GNUNET_TIME_Relative del; |
57 | char *fancy; | 56 | char *fancy; |
58 | 57 | ||
59 | if (NULL != cc) | 58 | GNUNET_SCHEDULER_shutdown (); |
60 | { | ||
61 | GNUNET_FS_TEST_daemons_connect_cancel (cc); | ||
62 | cc = NULL; | ||
63 | } | ||
64 | GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons); | ||
65 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) | 59 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) |
66 | { | 60 | { |
67 | del = GNUNET_TIME_absolute_get_duration (start_time); | 61 | del = GNUNET_TIME_absolute_get_duration (start_time); |
@@ -89,7 +83,7 @@ do_download (void *cls, const struct GNUNET_FS_Uri *uri) | |||
89 | { | 83 | { |
90 | if (NULL == uri) | 84 | if (NULL == uri) |
91 | { | 85 | { |
92 | GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons); | 86 | GNUNET_SCHEDULER_shutdown (); |
93 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 87 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
94 | "Timeout during upload attempt, shutting down with error\n"); | 88 | "Timeout during upload attempt, shutting down with error\n"); |
95 | ok = 1; | 89 | ok = 1; |
@@ -104,14 +98,16 @@ do_download (void *cls, const struct GNUNET_FS_Uri *uri) | |||
104 | 98 | ||
105 | 99 | ||
106 | static void | 100 | static void |
107 | do_publish (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 101 | do_publish (void *cls, |
102 | struct GNUNET_TESTBED_Operation *op, | ||
103 | const char *emsg) | ||
108 | { | 104 | { |
109 | cc = NULL; | 105 | if (NULL != emsg) |
110 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)) | ||
111 | { | 106 | { |
112 | GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons); | 107 | GNUNET_SCHEDULER_shutdown (); |
113 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 108 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
114 | "Timeout during connect attempt, shutting down with error\n"); | 109 | "Timeout during connect attempt, shutting down with error: %s\n", |
110 | emsg); | ||
115 | ok = 1; | 111 | ok = 1; |
116 | return; | 112 | return; |
117 | } | 113 | } |
@@ -123,52 +119,31 @@ do_publish (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
123 | 119 | ||
124 | 120 | ||
125 | static void | 121 | static void |
126 | do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 122 | do_connect (void *cls, |
123 | unsigned int num_peers, | ||
124 | struct GNUNET_TESTBED_Peer **peers) | ||
127 | { | 125 | { |
128 | GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)); | 126 | unsigned int i; |
127 | |||
128 | GNUNET_assert (NUM_DAEMONS == num_peers); | ||
129 | for (i=0;i<num_peers;i++) | ||
130 | daemons[i] = peers[i]; | ||
129 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 131 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
130 | "Daemons started, will now try to connect them\n"); | 132 | "Daemons started, will now try to connect them\n"); |
131 | cc = GNUNET_FS_TEST_daemons_connect (daemons[0], daemons[1], TIMEOUT, | 133 | GNUNET_TESTBED_overlay_connect (NULL, |
132 | &do_publish, NULL); | 134 | &do_publish, NULL, |
133 | } | 135 | daemons[0], daemons[1]); |
134 | |||
135 | |||
136 | static void | ||
137 | run (void *cls, char *const *args, const char *cfgfile, | ||
138 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
139 | { | ||
140 | GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf", TIMEOUT, NUM_DAEMONS, | ||
141 | daemons, &do_connect, NULL); | ||
142 | } | 136 | } |
143 | 137 | ||
144 | 138 | ||
145 | int | 139 | int |
146 | main (int argc, char *argv[]) | 140 | main (int argc, char *argv[]) |
147 | { | 141 | { |
148 | char *const argvx[] = { | 142 | GNUNET_TESTBED_test_run ("test-gnunet-service-fs-p2p", |
149 | "test-gnunet-service-fs-p2p", | 143 | "fs_test_lib_data.conf", |
150 | "-c", | 144 | NUM_DAEMONS, |
151 | "fs_test_lib_data.conf", | 145 | 0, NULL, NULL, |
152 | #if VERBOSE | 146 | &do_connect, NULL); |
153 | "-L", "DEBUG", | ||
154 | #endif | ||
155 | NULL | ||
156 | }; | ||
157 | struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
158 | GNUNET_GETOPT_OPTION_END | ||
159 | }; | ||
160 | |||
161 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); | ||
162 | GNUNET_log_setup ("test_gnunet_service_fs_p2p", | ||
163 | #if VERBOSE | ||
164 | "DEBUG", | ||
165 | #else | ||
166 | "WARNING", | ||
167 | #endif | ||
168 | NULL); | ||
169 | GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, argvx, | ||
170 | "test-gnunet-service-fs-p2p", "nohelp", options, &run, | ||
171 | NULL); | ||
172 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); | 147 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/"); |
173 | return ok; | 148 | return ok; |
174 | } | 149 | } |