diff options
author | Christian Grothoff <christian@grothoff.org> | 2011-04-28 18:01:02 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2011-04-28 18:01:02 +0000 |
commit | 7cf1fb688ad71fc7ca94049c79c20cad57b0823c (patch) | |
tree | 1b2ba7fa86093cd80ba6147e0cfb6b808a7a70cc /src | |
parent | d40d816c06ec13ad22130e2f6be4a22ea673b1aa (diff) | |
download | gnunet-7cf1fb688ad71fc7ca94049c79c20cad57b0823c.tar.gz gnunet-7cf1fb688ad71fc7ca94049c79c20cad57b0823c.zip |
cleaning up learning code some
Diffstat (limited to 'src')
-rw-r--r-- | src/hostlist/test_gnunet_daemon_hostlist_learning.c | 323 |
1 files changed, 168 insertions, 155 deletions
diff --git a/src/hostlist/test_gnunet_daemon_hostlist_learning.c b/src/hostlist/test_gnunet_daemon_hostlist_learning.c index 6f66b9c6e..9e0b65104 100644 --- a/src/hostlist/test_gnunet_daemon_hostlist_learning.c +++ b/src/hostlist/test_gnunet_daemon_hostlist_learning.c | |||
@@ -30,9 +30,10 @@ | |||
30 | #include "gnunet_resolver_service.h" | 30 | #include "gnunet_resolver_service.h" |
31 | #include "gnunet_statistics_service.h" | 31 | #include "gnunet_statistics_service.h" |
32 | 32 | ||
33 | #define VERBOSE GNUNET_NO | 33 | #define VERBOSE GNUNET_YES |
34 | 34 | ||
35 | #define START_ARM GNUNET_YES | 35 | #define START_ARM GNUNET_YES |
36 | |||
36 | #define MAX_URL_LEN 1000 | 37 | #define MAX_URL_LEN 1000 |
37 | 38 | ||
38 | /** | 39 | /** |
@@ -41,11 +42,27 @@ | |||
41 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 180) | 42 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 180) |
42 | #define CHECK_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1) | 43 | #define CHECK_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1) |
43 | 44 | ||
45 | |||
46 | struct PeerContext | ||
47 | { | ||
48 | struct GNUNET_CONFIGURATION_Handle *cfg; | ||
49 | struct GNUNET_TRANSPORT_Handle *th; | ||
50 | struct GNUNET_MessageHeader *hello; | ||
51 | struct GNUNET_CORE_Handle *core; | ||
52 | struct GNUNET_STATISTICS_Handle *stats; | ||
53 | #if START_ARM | ||
54 | struct GNUNET_OS_Process *arm_proc; | ||
55 | #endif | ||
56 | }; | ||
57 | |||
44 | static int timeout; | 58 | static int timeout; |
59 | |||
45 | static int adv_sent; | 60 | static int adv_sent; |
61 | |||
46 | static int adv_arrived; | 62 | static int adv_arrived; |
47 | 63 | ||
48 | static int learned_hostlist_saved; | 64 | static int learned_hostlist_saved; |
65 | |||
49 | static int learned_hostlist_downloaded; | 66 | static int learned_hostlist_downloaded; |
50 | 67 | ||
51 | static char * current_adv_uri; | 68 | static char * current_adv_uri; |
@@ -53,83 +70,70 @@ static char * current_adv_uri; | |||
53 | static const struct GNUNET_CONFIGURATION_Handle *cfg; | 70 | static const struct GNUNET_CONFIGURATION_Handle *cfg; |
54 | 71 | ||
55 | static GNUNET_SCHEDULER_TaskIdentifier timeout_task; | 72 | static GNUNET_SCHEDULER_TaskIdentifier timeout_task; |
73 | |||
56 | static GNUNET_SCHEDULER_TaskIdentifier check_task; | 74 | static GNUNET_SCHEDULER_TaskIdentifier check_task; |
57 | |||
58 | struct PeerContext | ||
59 | { | ||
60 | struct GNUNET_CONFIGURATION_Handle *cfg; | ||
61 | struct GNUNET_TRANSPORT_Handle *th; | ||
62 | struct GNUNET_MessageHeader *hello; | ||
63 | struct GNUNET_CORE_Handle *core; | ||
64 | struct GNUNET_STATISTICS_Handle *stats; | ||
65 | #if START_ARM | ||
66 | struct GNUNET_OS_Process *arm_proc; | ||
67 | #endif | ||
68 | }; | ||
69 | 75 | ||
70 | static struct PeerContext adv_peer; | 76 | static struct PeerContext adv_peer; |
71 | 77 | ||
72 | static struct PeerContext learn_peer; | 78 | static struct PeerContext learn_peer; |
73 | 79 | ||
74 | static struct GNUNET_STATISTICS_GetHandle * download_stats; | 80 | static struct GNUNET_STATISTICS_GetHandle * download_stats; |
81 | |||
75 | static struct GNUNET_STATISTICS_GetHandle * urisrecv_stat; | 82 | static struct GNUNET_STATISTICS_GetHandle * urisrecv_stat; |
83 | |||
76 | static struct GNUNET_STATISTICS_GetHandle * advsent_stat; | 84 | static struct GNUNET_STATISTICS_GetHandle * advsent_stat; |
77 | 85 | ||
78 | static void shutdown_testcase() | 86 | static void shutdown_testcase() |
79 | { | 87 | { |
80 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown testcase....\n"); | 88 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
81 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping Timeout Task.\n"); | 89 | "Shutdown testcase....\n"); |
82 | if (timeout_task != GNUNET_SCHEDULER_NO_TASK) | 90 | if (timeout_task != GNUNET_SCHEDULER_NO_TASK) |
83 | { | 91 | { |
84 | GNUNET_SCHEDULER_cancel (timeout_task); | 92 | GNUNET_SCHEDULER_cancel (timeout_task); |
85 | timeout_task = GNUNET_SCHEDULER_NO_TASK; | 93 | timeout_task = GNUNET_SCHEDULER_NO_TASK; |
86 | } | 94 | } |
87 | 95 | if (NULL != download_stats) | |
88 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping Statistics Task.\n"); | 96 | { |
89 | /* | 97 | GNUNET_STATISTICS_get_cancel (download_stats); |
90 | if ((NULL != learn_peer.stats) && (NULL != download_stats)) | 98 | download_stats = NULL; |
91 | GNUNET_STATISTICS_get_cancel (download_stats); | 99 | } |
92 | if ((NULL != learn_peer.stats) && (NULL != urisrecv_stat)) | 100 | if (NULL != urisrecv_stat) |
93 | GNUNET_STATISTICS_get_cancel (urisrecv_stat); | 101 | { |
94 | if ((NULL != adv_peer.stats) && (NULL != advsent_stat)) | 102 | GNUNET_STATISTICS_get_cancel (urisrecv_stat); |
95 | GNUNET_STATISTICS_get_cancel (advsent_stat); | 103 | urisrecv_stat = NULL; |
96 | */ | 104 | } |
97 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping Statistics Check Task.\n"); | 105 | if (NULL != advsent_stat) |
106 | { | ||
107 | GNUNET_STATISTICS_get_cancel (advsent_stat); | ||
108 | advsent_stat = NULL; | ||
109 | } | ||
98 | if (check_task != GNUNET_SCHEDULER_NO_TASK) | 110 | if (check_task != GNUNET_SCHEDULER_NO_TASK) |
99 | { | 111 | { |
100 | GNUNET_SCHEDULER_cancel (check_task); | 112 | GNUNET_SCHEDULER_cancel (check_task); |
101 | check_task = GNUNET_SCHEDULER_NO_TASK; | 113 | check_task = GNUNET_SCHEDULER_NO_TASK; |
102 | } | 114 | } |
103 | 115 | GNUNET_free_non_null (current_adv_uri); | |
104 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Freeing uri\n"); | 116 | current_adv_uri = NULL; |
105 | if ( NULL != current_adv_uri ) GNUNET_free (current_adv_uri); | ||
106 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from Transport.\n"); | ||
107 | if (adv_peer.th != NULL) | 117 | if (adv_peer.th != NULL) |
108 | { | 118 | { |
109 | GNUNET_TRANSPORT_disconnect (adv_peer.th); | 119 | GNUNET_TRANSPORT_disconnect (adv_peer.th); |
110 | adv_peer.th = NULL; | 120 | adv_peer.th = NULL; |
111 | } | 121 | } |
112 | if (learn_peer.th != NULL) | 122 | if (learn_peer.th != NULL) |
113 | { | 123 | { |
114 | GNUNET_TRANSPORT_disconnect (learn_peer.th); | 124 | GNUNET_TRANSPORT_disconnect (learn_peer.th); |
115 | learn_peer.th = NULL; | 125 | learn_peer.th = NULL; |
116 | } | 126 | } |
117 | |||
118 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from Core.\n"); | ||
119 | if (adv_peer.core != NULL) | 127 | if (adv_peer.core != NULL) |
120 | { | 128 | { |
121 | GNUNET_CORE_disconnect (adv_peer.core); | 129 | GNUNET_CORE_disconnect (adv_peer.core); |
122 | adv_peer.core = NULL; | 130 | adv_peer.core = NULL; |
123 | } | 131 | } |
124 | if (learn_peer.core != NULL) | 132 | if (learn_peer.core != NULL) |
125 | { | 133 | { |
126 | GNUNET_CORE_disconnect (learn_peer.core); | 134 | GNUNET_CORE_disconnect (learn_peer.core); |
127 | learn_peer.core = NULL; | 135 | learn_peer.core = NULL; |
128 | } | 136 | } |
129 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
130 | "Asking ARM to stop core services\n"); | ||
131 | |||
132 | |||
133 | #if START_ARM | 137 | #if START_ARM |
134 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 138 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
135 | "Killing hostlist server ARM process.\n"); | 139 | "Killing hostlist server ARM process.\n"); |
@@ -137,30 +141,19 @@ static void shutdown_testcase() | |||
137 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | 141 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); |
138 | if (GNUNET_OS_process_wait(adv_peer.arm_proc) != GNUNET_OK) | 142 | if (GNUNET_OS_process_wait(adv_peer.arm_proc) != GNUNET_OK) |
139 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); | 143 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); |
140 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
141 | "Hostlist server ARM process %u stopped\n", GNUNET_OS_process_get_pid (adv_peer.arm_proc)); | ||
142 | GNUNET_OS_process_close (adv_peer.arm_proc); | 144 | GNUNET_OS_process_close (adv_peer.arm_proc); |
143 | adv_peer.arm_proc = NULL; | 145 | adv_peer.arm_proc = NULL; |
144 | #endif | ||
145 | |||
146 | |||
147 | #if START_ARM | ||
148 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 146 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
149 | "Killing hostlist client ARM process.\n"); | 147 | "Killing hostlist client ARM process.\n"); |
150 | if (0 != GNUNET_OS_process_kill (learn_peer.arm_proc, SIGTERM)) | 148 | if (0 != GNUNET_OS_process_kill (learn_peer.arm_proc, SIGTERM)) |
151 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | 149 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); |
152 | if (GNUNET_OS_process_wait(learn_peer.arm_proc) != GNUNET_OK) | 150 | if (GNUNET_OS_process_wait(learn_peer.arm_proc) != GNUNET_OK) |
153 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); | 151 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); |
154 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
155 | "Hostlist client ARM process %u stopped\n", GNUNET_OS_process_get_pid (learn_peer.arm_proc)); | ||
156 | GNUNET_OS_process_close (learn_peer.arm_proc); | 152 | GNUNET_OS_process_close (learn_peer.arm_proc); |
157 | learn_peer.arm_proc = NULL; | 153 | learn_peer.arm_proc = NULL; |
158 | #endif | 154 | #endif |
159 | 155 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | |
160 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down scheduler\n"); | 156 | "Shutdown complete....\n"); |
161 | GNUNET_SCHEDULER_shutdown (); | ||
162 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown complete....\n"); | ||
163 | |||
164 | } | 157 | } |
165 | 158 | ||
166 | /** | 159 | /** |
@@ -178,6 +171,7 @@ timeout_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
178 | shutdown_testcase(); | 171 | shutdown_testcase(); |
179 | } | 172 | } |
180 | 173 | ||
174 | |||
181 | static int | 175 | static int |
182 | process_downloads (void *cls, | 176 | process_downloads (void *cls, |
183 | const char *subsystem, | 177 | const char *subsystem, |
@@ -186,16 +180,20 @@ process_downloads (void *cls, | |||
186 | int is_persistent) | 180 | int is_persistent) |
187 | { | 181 | { |
188 | download_stats = NULL; | 182 | download_stats = NULL; |
189 | if ( (value == 2) && (learned_hostlist_downloaded == GNUNET_NO) ) | 183 | if ( (value == 2) && |
190 | { | 184 | (learned_hostlist_downloaded == GNUNET_NO) ) |
191 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 185 | { |
192 | _("Peer has successfully downloaded advertised URI \n")); | 186 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
193 | learned_hostlist_downloaded = GNUNET_YES; | 187 | _("Peer has successfully downloaded advertised URI\n")); |
194 | shutdown_testcase(); | 188 | learned_hostlist_downloaded = GNUNET_YES; |
195 | } | 189 | if ( (learned_hostlist_saved == GNUNET_YES) && |
190 | (adv_sent == GNUNET_YES) ) | ||
191 | shutdown_testcase(); | ||
192 | } | ||
196 | return GNUNET_OK; | 193 | return GNUNET_OK; |
197 | } | 194 | } |
198 | 195 | ||
196 | |||
199 | static int | 197 | static int |
200 | process_uris_recv (void *cls, | 198 | process_uris_recv (void *cls, |
201 | const char *subsystem, | 199 | const char *subsystem, |
@@ -204,15 +202,21 @@ process_uris_recv (void *cls, | |||
204 | int is_persistent) | 202 | int is_persistent) |
205 | { | 203 | { |
206 | urisrecv_stat = NULL; | 204 | urisrecv_stat = NULL; |
207 | if ( ((struct PeerContext *) cls == &learn_peer) && (value == 1) && (learned_hostlist_saved == GNUNET_NO)) | 205 | if ( ((struct PeerContext *) cls == &learn_peer) && |
208 | { | 206 | (value == 1) && |
209 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 207 | (learned_hostlist_saved == GNUNET_NO) ) |
210 | _("Peer has successfully saved advertised URI \n")); | 208 | { |
211 | learned_hostlist_saved = GNUNET_YES; | 209 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
212 | } | 210 | _("Peer has successfully saved advertised URI \n")); |
211 | learned_hostlist_saved = GNUNET_YES; | ||
212 | if ( (learned_hostlist_downloaded == GNUNET_YES) && | ||
213 | (adv_sent == GNUNET_YES) ) | ||
214 | shutdown_testcase(); | ||
215 | } | ||
213 | return GNUNET_OK; | 216 | return GNUNET_OK; |
214 | } | 217 | } |
215 | 218 | ||
219 | |||
216 | static int | 220 | static int |
217 | process_adv_sent (void *cls, | 221 | process_adv_sent (void *cls, |
218 | const char *subsystem, | 222 | const char *subsystem, |
@@ -222,11 +226,14 @@ process_adv_sent (void *cls, | |||
222 | { | 226 | { |
223 | advsent_stat = NULL; | 227 | advsent_stat = NULL; |
224 | if ( (value >= 1) && (adv_sent == GNUNET_NO)) | 228 | if ( (value >= 1) && (adv_sent == GNUNET_NO)) |
225 | { | 229 | { |
226 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 230 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
227 | _("Server has successfully sent advertisement\n")); | 231 | _("Server has successfully sent advertisement\n")); |
228 | adv_sent = GNUNET_YES; | 232 | adv_sent = GNUNET_YES; |
229 | } | 233 | if ( (learned_hostlist_downloaded == GNUNET_YES) && |
234 | (learned_hostlist_saved == GNUNET_YES) ) | ||
235 | shutdown_testcase(); | ||
236 | } | ||
230 | return GNUNET_OK; | 237 | return GNUNET_OK; |
231 | } | 238 | } |
232 | 239 | ||
@@ -235,51 +242,52 @@ process_adv_sent (void *cls, | |||
235 | * Check the server statistics regularly | 242 | * Check the server statistics regularly |
236 | */ | 243 | */ |
237 | static void | 244 | static void |
238 | check_statistics (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 245 | check_statistics (void *cls, |
246 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
239 | { | 247 | { |
240 | char *stat; | 248 | char *stat; |
241 | 249 | ||
242 | check_task = GNUNET_SCHEDULER_NO_TASK; | 250 | check_task = GNUNET_SCHEDULER_NO_TASK; |
243 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) | 251 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) |
244 | return; | 252 | return; |
245 | 253 | GNUNET_asprintf (&stat, | |
246 | GNUNET_asprintf (&stat, | ||
247 | gettext_noop("# advertised URI `%s' downloaded"), | 254 | gettext_noop("# advertised URI `%s' downloaded"), |
248 | current_adv_uri); | 255 | current_adv_uri); |
249 | if ( NULL != learn_peer.stats) | 256 | if ( NULL != learn_peer.stats) |
250 | { | 257 | { |
251 | download_stats = GNUNET_STATISTICS_get (learn_peer.stats, | 258 | download_stats = GNUNET_STATISTICS_get (learn_peer.stats, |
252 | "hostlist", | 259 | "hostlist", |
253 | stat, | 260 | stat, |
254 | GNUNET_TIME_UNIT_MINUTES, | 261 | GNUNET_TIME_UNIT_MINUTES, |
255 | NULL, | 262 | NULL, |
256 | &process_downloads, | 263 | &process_downloads, |
257 | &learn_peer); | 264 | &learn_peer); |
258 | 265 | ||
259 | urisrecv_stat = GNUNET_STATISTICS_get (learn_peer.stats, | 266 | urisrecv_stat = GNUNET_STATISTICS_get (learn_peer.stats, |
260 | "hostlist", | 267 | "hostlist", |
261 | gettext_noop("# advertised hostlist URIs"), | 268 | gettext_noop("# advertised hostlist URIs"), |
262 | GNUNET_TIME_UNIT_MINUTES, | 269 | GNUNET_TIME_UNIT_MINUTES, |
263 | NULL, | 270 | NULL, |
264 | &process_uris_recv, | 271 | &process_uris_recv, |
265 | &learn_peer); | 272 | &learn_peer); |
266 | } | 273 | } |
267 | GNUNET_free (stat); | 274 | GNUNET_free (stat); |
268 | if ( NULL != adv_peer.stats) | 275 | if ( NULL != adv_peer.stats) |
269 | { | 276 | { |
270 | advsent_stat = GNUNET_STATISTICS_get (adv_peer.stats, | 277 | advsent_stat = GNUNET_STATISTICS_get (adv_peer.stats, |
271 | "hostlist", | 278 | "hostlist", |
272 | gettext_noop("# hostlist advertisements send"), | 279 | gettext_noop("# hostlist advertisements send"), |
273 | GNUNET_TIME_UNIT_MINUTES, | 280 | GNUNET_TIME_UNIT_MINUTES, |
274 | NULL, | 281 | NULL, |
275 | &process_adv_sent, | 282 | &process_adv_sent, |
276 | NULL); | 283 | NULL); |
277 | } | 284 | } |
278 | check_task = GNUNET_SCHEDULER_add_delayed (CHECK_INTERVALL, | 285 | check_task = GNUNET_SCHEDULER_add_delayed (CHECK_INTERVALL, |
279 | &check_statistics, | 286 | &check_statistics, |
280 | NULL); | 287 | NULL); |
281 | } | 288 | } |
282 | 289 | ||
290 | |||
283 | /** | 291 | /** |
284 | * Core handler for p2p hostlist advertisements | 292 | * Core handler for p2p hostlist advertisements |
285 | */ | 293 | */ |
@@ -305,11 +313,10 @@ ad_arrive_handler (void *cls, | |||
305 | } | 313 | } |
306 | 314 | ||
307 | if ( GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (adv_peer.cfg, | 315 | if ( GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (adv_peer.cfg, |
308 | "HOSTLIST", | 316 | "HOSTLIST", |
309 | "EXTERNAL_DNS_NAME", | 317 | "EXTERNAL_DNS_NAME", |
310 | &hostname)) | 318 | &hostname)) |
311 | hostname = GNUNET_RESOLVER_local_fqdn_get (); | 319 | hostname = GNUNET_RESOLVER_local_fqdn_get (); |
312 | |||
313 | GNUNET_asprintf (&expected_uri, | 320 | GNUNET_asprintf (&expected_uri, |
314 | "http://%s:%u/", | 321 | "http://%s:%u/", |
315 | hostname != NULL ? hostname : "localhost", | 322 | hostname != NULL ? hostname : "localhost", |
@@ -319,18 +326,22 @@ ad_arrive_handler (void *cls, | |||
319 | if ( 0 == strcmp( expected_uri, current_adv_uri ) ) | 326 | if ( 0 == strcmp( expected_uri, current_adv_uri ) ) |
320 | { | 327 | { |
321 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 328 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
322 | "Recieved hostlist advertisement with URI `%s' as expected\n", current_adv_uri); | 329 | "Recieved hostlist advertisement with URI `%s' as expected\n", |
330 | current_adv_uri); | ||
323 | adv_arrived = GNUNET_YES; | 331 | adv_arrived = GNUNET_YES; |
324 | adv_sent = GNUNET_YES; | 332 | adv_sent = GNUNET_YES; |
325 | } | 333 | } |
326 | else | 334 | else |
327 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 335 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
328 | "Expected URI `%s' and recieved URI `%s' differ\n", expected_uri, current_adv_uri); | 336 | "Expected URI `%s' and recieved URI `%s' differ\n", |
337 | expected_uri, | ||
338 | current_adv_uri); | ||
329 | GNUNET_free (expected_uri); | 339 | GNUNET_free (expected_uri); |
330 | GNUNET_free_non_null (hostname); | 340 | GNUNET_free_non_null (hostname); |
331 | return GNUNET_OK; | 341 | return GNUNET_OK; |
332 | } | 342 | } |
333 | 343 | ||
344 | |||
334 | /** | 345 | /** |
335 | * List of handlers if we are learning. | 346 | * List of handlers if we are learning. |
336 | */ | 347 | */ |
@@ -339,6 +350,7 @@ static struct GNUNET_CORE_MessageHandler learn_handlers[] = { | |||
339 | { NULL, 0, 0 } | 350 | { NULL, 0, 0 } |
340 | }; | 351 | }; |
341 | 352 | ||
353 | |||
342 | static void | 354 | static void |
343 | setup_learn_peer (struct PeerContext *p, const char *cfgname) | 355 | setup_learn_peer (struct PeerContext *p, const char *cfgname) |
344 | { | 356 | { |
@@ -448,22 +460,24 @@ check () | |||
448 | "nohelp", options, &run, NULL); | 460 | "nohelp", options, &run, NULL); |
449 | 461 | ||
450 | failed = GNUNET_NO; | 462 | failed = GNUNET_NO; |
451 | |||
452 | if (learned_hostlist_downloaded == GNUNET_YES) | ||
453 | return GNUNET_NO; | ||
454 | |||
455 | if (timeout == GNUNET_YES) | 463 | if (timeout == GNUNET_YES) |
456 | { | 464 | { |
457 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 465 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
458 | "Testcase could not set up two communicating peers, timeout\n"); | 466 | "Testcase could not set up two communicating peers, timeout\n"); |
459 | failed = GNUNET_YES; | 467 | failed = GNUNET_YES; |
460 | } | 468 | } |
469 | if (learned_hostlist_downloaded == GNUNET_YES) | ||
470 | { | ||
471 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
472 | "Failed to download learned hostlist\n"); | ||
473 | failed = GNUNET_YES; | ||
474 | } | ||
461 | if (adv_arrived != GNUNET_YES) | 475 | if (adv_arrived != GNUNET_YES) |
462 | { | 476 | { |
463 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 477 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
464 | "Learning peer did not receive advertisement from server\n"); | 478 | "Learning peer did not receive advertisement from server\n"); |
465 | failed = GNUNET_YES; | 479 | failed = GNUNET_YES; |
466 | } | 480 | } |
467 | if ( learned_hostlist_saved == GNUNET_NO ) | 481 | if ( learned_hostlist_saved == GNUNET_NO ) |
468 | { | 482 | { |
469 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 483 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
@@ -471,21 +485,20 @@ check () | |||
471 | failed = GNUNET_YES; | 485 | failed = GNUNET_YES; |
472 | } | 486 | } |
473 | if (learned_hostlist_downloaded == GNUNET_NO) | 487 | if (learned_hostlist_downloaded == GNUNET_NO) |
474 | { | 488 | { |
475 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 489 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
476 | "Peer1: Advertised hostlist could not be downloaded from server\n"); | 490 | "Peer1: Advertised hostlist could not be downloaded from server\n"); |
477 | failed = GNUNET_YES; | 491 | failed = GNUNET_YES; |
478 | } | 492 | } |
479 | if (adv_sent == GNUNET_NO) | 493 | if (adv_sent == GNUNET_NO) |
480 | { | 494 | { |
481 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 495 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
482 | "Advertised was not sent from server to client\n"); | 496 | "Advertised was not sent from server to client\n"); |
483 | failed = GNUNET_YES; | 497 | failed = GNUNET_YES; |
484 | } | 498 | } |
485 | if ( GNUNET_YES == failed ) | 499 | if (GNUNET_YES == failed) |
486 | return GNUNET_YES; | 500 | return GNUNET_YES; |
487 | else | 501 | return GNUNET_NO; |
488 | return GNUNET_NO; | ||
489 | } | 502 | } |
490 | 503 | ||
491 | int | 504 | int |