diff options
Diffstat (limited to 'src/fs/test_fs_namespace.c')
-rw-r--r-- | src/fs/test_fs_namespace.c | 182 |
1 files changed, 44 insertions, 138 deletions
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c index 5d7eb841c..a72197e10 100644 --- a/src/fs/test_fs_namespace.c +++ b/src/fs/test_fs_namespace.c | |||
@@ -29,7 +29,7 @@ | |||
29 | #include "gnunet_fs_service.h" | 29 | #include "gnunet_fs_service.h" |
30 | 30 | ||
31 | 31 | ||
32 | static struct GNUNET_HashCode nsid; | 32 | static struct GNUNET_PseudonymIdentifier nsid; |
33 | 33 | ||
34 | static struct GNUNET_FS_Uri *sks_expect_uri; | 34 | static struct GNUNET_FS_Uri *sks_expect_uri; |
35 | 35 | ||
@@ -43,64 +43,27 @@ static struct GNUNET_FS_SearchContext *ksk_search; | |||
43 | 43 | ||
44 | static GNUNET_SCHEDULER_TaskIdentifier kill_task; | 44 | static GNUNET_SCHEDULER_TaskIdentifier kill_task; |
45 | 45 | ||
46 | static GNUNET_SCHEDULER_TaskIdentifier kill_ncc_task; | ||
47 | |||
48 | struct GNUNET_FS_NamespaceCreationContext *ncc; | ||
49 | |||
50 | static int update_started; | 46 | static int update_started; |
51 | 47 | ||
52 | static int err; | 48 | static int err; |
53 | 49 | ||
54 | static int phase; | ||
55 | |||
56 | const struct GNUNET_CONFIGURATION_Handle *config; | ||
57 | |||
58 | static void ns_created (void *cls, struct GNUNET_FS_Namespace *ns, const char *emsg); | ||
59 | |||
60 | static void do_ncc_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); | ||
61 | |||
62 | 50 | ||
63 | static void | 51 | static void |
64 | next_phase () | 52 | abort_ksk_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
65 | { | 53 | { |
66 | switch (phase) | 54 | if (ksk_search != NULL) |
67 | { | 55 | { |
68 | case 0: | 56 | GNUNET_FS_search_stop (ksk_search); |
69 | phase += 1; | 57 | ksk_search = NULL; |
70 | FPRINTF (stderr, "%s", "Testing asynchronous namespace creation\n"); | 58 | if (sks_search == NULL) |
71 | ncc = GNUNET_FS_namespace_create_start (fs, "testNamespace", ns_created, NULL); | ||
72 | if (NULL == ncc) | ||
73 | { | 59 | { |
74 | FPRINTF (stderr, "%s", "Failed to start asynchronous namespace creation\n"); | 60 | GNUNET_FS_stop (fs); |
75 | err = 1; | 61 | if (GNUNET_SCHEDULER_NO_TASK != kill_task) |
76 | next_phase (); | 62 | GNUNET_SCHEDULER_cancel (kill_task); |
77 | return; | ||
78 | } | 63 | } |
79 | kill_ncc_task = | ||
80 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_ncc_timeout, | ||
81 | NULL); | ||
82 | break; | ||
83 | case 1: | ||
84 | FPRINTF (stderr, "%s", "Shutting down FS\n"); | ||
85 | GNUNET_FS_stop (fs); | ||
86 | if (GNUNET_SCHEDULER_NO_TASK != kill_task) | ||
87 | GNUNET_SCHEDULER_cancel (kill_task); | ||
88 | kill_task = GNUNET_SCHEDULER_NO_TASK; | ||
89 | } | 64 | } |
90 | } | 65 | } |
91 | 66 | ||
92 | static void | ||
93 | abort_ksk_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
94 | { | ||
95 | if (NULL == ksk_search) | ||
96 | return; | ||
97 | FPRINTF (stderr, "%s", "Stopping KSK search\n"); | ||
98 | GNUNET_FS_search_stop (ksk_search); | ||
99 | ksk_search = NULL; | ||
100 | if (sks_search == NULL) | ||
101 | next_phase (); | ||
102 | } | ||
103 | |||
104 | 67 | ||
105 | static void | 68 | static void |
106 | abort_sks_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 69 | abort_sks_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
@@ -109,14 +72,17 @@ abort_sks_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
109 | 72 | ||
110 | if (sks_search == NULL) | 73 | if (sks_search == NULL) |
111 | return; | 74 | return; |
112 | FPRINTF (stderr, "%s", "Stopping SKS search\n"); | ||
113 | GNUNET_FS_search_stop (sks_search); | 75 | GNUNET_FS_search_stop (sks_search); |
114 | sks_search = NULL; | 76 | sks_search = NULL; |
115 | ns = GNUNET_FS_namespace_create (fs, "testNamespace"); | 77 | ns = GNUNET_FS_namespace_create (fs, "testNamespace"); |
116 | GNUNET_assert (NULL != ns); | 78 | GNUNET_assert (NULL != ns); |
117 | GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_YES)); | 79 | GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_YES)); |
118 | if (ksk_search == NULL) | 80 | if (ksk_search == NULL) |
119 | next_phase (); | 81 | { |
82 | GNUNET_FS_stop (fs); | ||
83 | if (GNUNET_SCHEDULER_NO_TASK != kill_task) | ||
84 | GNUNET_SCHEDULER_cancel (kill_task); | ||
85 | } | ||
120 | } | 86 | } |
121 | 87 | ||
122 | 88 | ||
@@ -133,25 +99,18 @@ do_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
133 | static void * | 99 | static void * |
134 | progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) | 100 | progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) |
135 | { | 101 | { |
136 | char *got; | ||
137 | switch (event->status) | 102 | switch (event->status) |
138 | { | 103 | { |
139 | case GNUNET_FS_STATUS_SEARCH_RESULT: | 104 | case GNUNET_FS_STATUS_SEARCH_RESULT: |
140 | got = GNUNET_FS_uri_to_string (event->value.search.specifics.result.uri); | ||
141 | FPRINTF (stderr, "Got a search result `%s'\n", got); | ||
142 | if (sks_search == event->value.search.sc) | 105 | if (sks_search == event->value.search.sc) |
143 | { | 106 | { |
144 | if (!GNUNET_FS_uri_test_equal | 107 | if (!GNUNET_FS_uri_test_equal |
145 | (sks_expect_uri, event->value.search.specifics.result.uri)) | 108 | (sks_expect_uri, event->value.search.specifics.result.uri)) |
146 | { | 109 | { |
147 | char *expected; | 110 | FPRINTF (stderr, "%s", "Wrong result for sks search!\n"); |
148 | expected = GNUNET_FS_uri_to_string (sks_expect_uri); | ||
149 | FPRINTF (stderr, "Wrong result for sks search! Expected:\n%s\nGot:\n%s\n", expected, got); | ||
150 | GNUNET_free (expected); | ||
151 | err = 1; | 111 | err = 1; |
152 | } | 112 | } |
153 | /* give system 1ms to initiate update search! */ | 113 | /* give system 1ms to initiate update search! */ |
154 | FPRINTF (stderr, "scheduling `%s'\n", "abort_sks_search_task"); | ||
155 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS, | 114 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS, |
156 | &abort_sks_search_task, NULL); | 115 | &abort_sks_search_task, NULL); |
157 | } | 116 | } |
@@ -160,22 +119,17 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) | |||
160 | if (!GNUNET_FS_uri_test_equal | 119 | if (!GNUNET_FS_uri_test_equal |
161 | (ksk_expect_uri, event->value.search.specifics.result.uri)) | 120 | (ksk_expect_uri, event->value.search.specifics.result.uri)) |
162 | { | 121 | { |
163 | char *expected; | 122 | FPRINTF (stderr, "%s", "Wrong result for ksk search!\n"); |
164 | expected = GNUNET_FS_uri_to_string (ksk_expect_uri); | ||
165 | FPRINTF (stderr, "Wrong result for ksk search! Expected:\n%s\nGot:\n%s\n", expected, got); | ||
166 | GNUNET_free (expected); | ||
167 | err = 1; | 123 | err = 1; |
168 | } | 124 | } |
169 | FPRINTF (stderr, "scheduling `%s'\n", "abort_ksk_search_task"); | ||
170 | GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task, NULL, | 125 | GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task, NULL, |
171 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 126 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
172 | } | 127 | } |
173 | else | 128 | else |
174 | { | 129 | { |
175 | FPRINTF (stderr, "Unexpected search result `%s' received!\n", got); | 130 | FPRINTF (stderr, "%s", "Unexpected search result received!\n"); |
176 | GNUNET_break (0); | 131 | GNUNET_break (0); |
177 | } | 132 | } |
178 | GNUNET_free (got); | ||
179 | break; | 133 | break; |
180 | case GNUNET_FS_STATUS_SEARCH_ERROR: | 134 | case GNUNET_FS_STATUS_SEARCH_ERROR: |
181 | FPRINTF (stderr, "Error searching file: %s\n", | 135 | FPRINTF (stderr, "Error searching file: %s\n", |
@@ -190,7 +144,6 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) | |||
190 | GNUNET_break (0); | 144 | GNUNET_break (0); |
191 | break; | 145 | break; |
192 | case GNUNET_FS_STATUS_SEARCH_START: | 146 | case GNUNET_FS_STATUS_SEARCH_START: |
193 | FPRINTF (stderr, "Search %s started\n", event->value.search.pctx); | ||
194 | GNUNET_assert ((NULL == event->value.search.cctx) || | 147 | GNUNET_assert ((NULL == event->value.search.cctx) || |
195 | (0 == strcmp ("sks_search", event->value.search.cctx)) || | 148 | (0 == strcmp ("sks_search", event->value.search.cctx)) || |
196 | (0 == strcmp ("ksk_search", event->value.search.cctx))); | 149 | (0 == strcmp ("ksk_search", event->value.search.cctx))); |
@@ -202,10 +155,8 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) | |||
202 | GNUNET_assert (1 == event->value.search.anonymity); | 155 | GNUNET_assert (1 == event->value.search.anonymity); |
203 | break; | 156 | break; |
204 | case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: | 157 | case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: |
205 | FPRINTF (stderr, "%s", "Search result stopped\n"); | ||
206 | return NULL; | 158 | return NULL; |
207 | case GNUNET_FS_STATUS_SEARCH_STOPPED: | 159 | case GNUNET_FS_STATUS_SEARCH_STOPPED: |
208 | FPRINTF (stderr, "%s", "Search stopped\n"); | ||
209 | return NULL; | 160 | return NULL; |
210 | default: | 161 | default: |
211 | FPRINTF (stderr, "Unexpected event: %d\n", event->status); | 162 | FPRINTF (stderr, "Unexpected event: %d\n", event->status); |
@@ -221,18 +172,20 @@ publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg) | |||
221 | char *msg; | 172 | char *msg; |
222 | struct GNUNET_FS_Uri *sks_uri; | 173 | struct GNUNET_FS_Uri *sks_uri; |
223 | char sbuf[1024]; | 174 | char sbuf[1024]; |
224 | struct GNUNET_CRYPTO_HashAsciiEncoded enc; | 175 | char buf[1024]; |
176 | char *ret; | ||
225 | 177 | ||
226 | if (NULL != emsg) | 178 | if (NULL != emsg) |
227 | { | 179 | { |
228 | FPRINTF (stderr, "Error publishing ksk: %s\n", emsg); | 180 | FPRINTF (stderr, "Error publishing: %s\n", emsg); |
229 | err = 1; | 181 | err = 1; |
230 | GNUNET_FS_stop (fs); | 182 | GNUNET_FS_stop (fs); |
231 | return; | 183 | return; |
232 | } | 184 | } |
233 | FPRINTF (stderr, "%s", "Published ksk\n"); | 185 | ret = GNUNET_STRINGS_data_to_string (&nsid, sizeof (nsid), buf, sizeof (buf)); |
234 | GNUNET_CRYPTO_hash_to_enc (&nsid, &enc); | 186 | GNUNET_assert (NULL != ret); |
235 | GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", &enc); | 187 | ret[0] = '\0'; |
188 | GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", buf); | ||
236 | sks_uri = GNUNET_FS_uri_parse (sbuf, &msg); | 189 | sks_uri = GNUNET_FS_uri_parse (sbuf, &msg); |
237 | if (NULL == sks_uri) | 190 | if (NULL == sks_uri) |
238 | { | 191 | { |
@@ -242,7 +195,6 @@ publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg) | |||
242 | GNUNET_free_non_null (msg); | 195 | GNUNET_free_non_null (msg); |
243 | return; | 196 | return; |
244 | } | 197 | } |
245 | FPRINTF (stderr, "%s", "Starting searches\n"); | ||
246 | ksk_search = | 198 | ksk_search = |
247 | GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, | 199 | GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, |
248 | "ksk_search"); | 200 | "ksk_search"); |
@@ -260,21 +212,17 @@ sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) | |||
260 | struct GNUNET_FS_Uri *ksk_uri; | 212 | struct GNUNET_FS_Uri *ksk_uri; |
261 | char *msg; | 213 | char *msg; |
262 | struct GNUNET_FS_BlockOptions bo; | 214 | struct GNUNET_FS_BlockOptions bo; |
263 | char *suri; | ||
264 | 215 | ||
265 | if (NULL == uri) | 216 | if (NULL == uri) |
266 | { | 217 | { |
267 | fprintf (stderr, "Error publishing sks: %s\n", emsg); | 218 | fprintf (stderr, "Error publishing: %s\n", emsg); |
268 | err = 1; | 219 | err = 1; |
269 | GNUNET_FS_stop (fs); | 220 | GNUNET_FS_stop (fs); |
270 | return; | 221 | return; |
271 | } | 222 | } |
272 | FPRINTF (stderr, "%s", "Published sks\n"); | ||
273 | meta = GNUNET_CONTAINER_meta_data_create (); | 223 | meta = GNUNET_CONTAINER_meta_data_create (); |
274 | msg = NULL; | 224 | msg = NULL; |
275 | GNUNET_asprintf (&suri, "gnunet://fs/ksk/ns-search%d", phase); | 225 | ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/ns-search", &msg); |
276 | ksk_uri = GNUNET_FS_uri_parse (suri, &msg); | ||
277 | GNUNET_free (suri); | ||
278 | GNUNET_assert (NULL == msg); | 226 | GNUNET_assert (NULL == msg); |
279 | ksk_expect_uri = GNUNET_FS_uri_dup (uri); | 227 | ksk_expect_uri = GNUNET_FS_uri_dup (uri); |
280 | bo.content_priority = 1; | 228 | bo.content_priority = 1; |
@@ -298,12 +246,11 @@ adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) | |||
298 | 246 | ||
299 | if (NULL != emsg) | 247 | if (NULL != emsg) |
300 | { | 248 | { |
301 | FPRINTF (stderr, "Error advertising: %s\n", emsg); | 249 | FPRINTF (stderr, "Error publishing: %s\n", emsg); |
302 | err = 1; | 250 | err = 1; |
303 | GNUNET_FS_stop (fs); | 251 | GNUNET_FS_stop (fs); |
304 | return; | 252 | return; |
305 | } | 253 | } |
306 | FPRINTF (stderr, "%s", "Created an advertising\n"); | ||
307 | ns = GNUNET_FS_namespace_create (fs, "testNamespace"); | 254 | ns = GNUNET_FS_namespace_create (fs, "testNamespace"); |
308 | GNUNET_assert (NULL != ns); | 255 | GNUNET_assert (NULL != ns); |
309 | meta = GNUNET_CONTAINER_meta_data_create (); | 256 | meta = GNUNET_CONTAINER_meta_data_create (); |
@@ -314,7 +261,7 @@ adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) | |||
314 | bo.replication_level = 0; | 261 | bo.replication_level = 0; |
315 | bo.expiration_time = | 262 | bo.expiration_time = |
316 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); | 263 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); |
317 | GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri, /* FIXME: this is non-sense (use CHK URI!?) */ | 264 | GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri, |
318 | &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL); | 265 | &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL); |
319 | GNUNET_CONTAINER_meta_data_destroy (meta); | 266 | GNUNET_CONTAINER_meta_data_destroy (meta); |
320 | GNUNET_FS_namespace_delete (ns, GNUNET_NO); | 267 | GNUNET_FS_namespace_delete (ns, GNUNET_NO); |
@@ -322,27 +269,29 @@ adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) | |||
322 | 269 | ||
323 | 270 | ||
324 | static void | 271 | static void |
325 | ns_iterator (void *cls, const char *name, const struct GNUNET_HashCode * id) | 272 | ns_iterator (void *cls, const char *name, const struct GNUNET_PseudonymIdentifier *id) |
326 | { | 273 | { |
327 | int *ok = cls; | 274 | int *ok = cls; |
328 | 275 | ||
329 | FPRINTF (stderr, "Namespace in the list: %s\n", name); | ||
330 | if (0 != strcmp (name, "testNamespace")) | 276 | if (0 != strcmp (name, "testNamespace")) |
331 | return; | 277 | return; |
332 | *ok = GNUNET_YES; | 278 | *ok = GNUNET_YES; |
333 | nsid = *id; | 279 | nsid = *id; |
334 | } | 280 | } |
335 | 281 | ||
282 | |||
336 | static void | 283 | static void |
337 | testCreatedNamespace (struct GNUNET_FS_Namespace *ns) | 284 | testNamespace () |
338 | { | 285 | { |
286 | struct GNUNET_FS_Namespace *ns; | ||
339 | struct GNUNET_FS_BlockOptions bo; | 287 | struct GNUNET_FS_BlockOptions bo; |
340 | struct GNUNET_CONTAINER_MetaData *meta; | 288 | struct GNUNET_CONTAINER_MetaData *meta; |
341 | struct GNUNET_FS_Uri *ksk_uri; | 289 | struct GNUNET_FS_Uri *ksk_uri; |
290 | struct GNUNET_FS_Uri *sks_uri; | ||
342 | int ok; | 291 | int ok; |
343 | char *uri; | ||
344 | 292 | ||
345 | FPRINTF (stderr, "%s", "Listing namespaces\n"); | 293 | ns = GNUNET_FS_namespace_create (fs, "testNamespace"); |
294 | GNUNET_assert (NULL != ns); | ||
346 | ok = GNUNET_NO; | 295 | ok = GNUNET_NO; |
347 | GNUNET_FS_namespace_list (fs, &ns_iterator, &ok); | 296 | GNUNET_FS_namespace_list (fs, &ns_iterator, &ok); |
348 | if (GNUNET_NO == ok) | 297 | if (GNUNET_NO == ok) |
@@ -353,65 +302,24 @@ testCreatedNamespace (struct GNUNET_FS_Namespace *ns) | |||
353 | err = 1; | 302 | err = 1; |
354 | return; | 303 | return; |
355 | } | 304 | } |
356 | FPRINTF (stderr, "%s", "Creating an advertising\n"); | ||
357 | meta = GNUNET_CONTAINER_meta_data_create (); | 305 | meta = GNUNET_CONTAINER_meta_data_create (); |
358 | GNUNET_asprintf (&uri, "gnunet://fs/ksk/testnsa%d", phase); | 306 | ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL); |
359 | ksk_uri = GNUNET_FS_uri_parse (uri, NULL); | ||
360 | GNUNET_free (uri); | ||
361 | bo.content_priority = 1; | 307 | bo.content_priority = 1; |
362 | bo.anonymity_level = 1; | 308 | bo.anonymity_level = 1; |
363 | bo.replication_level = 0; | 309 | bo.replication_level = 0; |
364 | bo.expiration_time = | 310 | bo.expiration_time = |
365 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); | 311 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); |
366 | GNUNET_FS_namespace_advertise (fs, ksk_uri, ns, meta, &bo, "root", &adv_cont, | 312 | sks_uri = GNUNET_FS_uri_sks_create (ns, "root", NULL); |
367 | NULL); | 313 | GNUNET_FS_publish_ksk (fs, |
368 | GNUNET_FS_uri_destroy (ksk_uri); | 314 | ksk_uri, meta, sks_uri, &bo, GNUNET_FS_PUBLISH_OPTION_NONE, |
369 | GNUNET_FS_namespace_delete (ns, GNUNET_NO); | 315 | &adv_cont, NULL); |
370 | GNUNET_CONTAINER_meta_data_destroy (meta); | 316 | GNUNET_FS_uri_destroy (sks_uri); |
371 | } | ||
372 | |||
373 | static void | ||
374 | do_ncc_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
375 | { | ||
376 | FPRINTF (stderr, "%s", "Asynchronous NS creation timed out\n"); | ||
377 | kill_ncc_task = GNUNET_SCHEDULER_NO_TASK; | ||
378 | if (NULL == ncc) | ||
379 | return; | ||
380 | GNUNET_FS_namespace_create_stop (ncc); | ||
381 | ncc = NULL; | ||
382 | err = 1; | ||
383 | } | ||
384 | |||
385 | static void | ||
386 | ns_created (void *cls, struct GNUNET_FS_Namespace *ns, const char *emsg) | ||
387 | { | ||
388 | if (GNUNET_SCHEDULER_NO_TASK != kill_ncc_task) | ||
389 | GNUNET_SCHEDULER_cancel (kill_ncc_task); | ||
390 | kill_ncc_task = GNUNET_SCHEDULER_NO_TASK; | ||
391 | if (NULL == ns) | ||
392 | { | ||
393 | FPRINTF (stderr, "Asynchronous NS creation failed: %s\n", emsg); | ||
394 | err = 1; | ||
395 | return; | ||
396 | } | ||
397 | |||
398 | FPRINTF (stderr, "%s", "Namespace created asynchronously\n"); | ||
399 | testCreatedNamespace (ns); | ||
400 | } | ||
401 | |||
402 | static void | ||
403 | testNamespace () | ||
404 | { | ||
405 | struct GNUNET_FS_Namespace *ns; | ||
406 | |||
407 | FPRINTF (stderr, "%s", "Testing synchronous namespace creation\n"); | ||
408 | ns = GNUNET_FS_namespace_create (fs, "testNamespace"); | ||
409 | GNUNET_assert (NULL != ns); | ||
410 | testCreatedNamespace (ns); | ||
411 | |||
412 | kill_task = | 317 | kill_task = |
413 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout, | 318 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout, |
414 | NULL); | 319 | NULL); |
320 | GNUNET_FS_uri_destroy (ksk_uri); | ||
321 | GNUNET_FS_namespace_delete (ns, GNUNET_NO); | ||
322 | GNUNET_CONTAINER_meta_data_destroy (meta); | ||
415 | } | 323 | } |
416 | 324 | ||
417 | 325 | ||
@@ -420,10 +328,8 @@ run (void *cls, | |||
420 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 328 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
421 | struct GNUNET_TESTING_Peer *peer) | 329 | struct GNUNET_TESTING_Peer *peer) |
422 | { | 330 | { |
423 | config = cfg; | ||
424 | fs = GNUNET_FS_start (cfg, "test-fs-namespace", &progress_cb, NULL, | 331 | fs = GNUNET_FS_start (cfg, "test-fs-namespace", &progress_cb, NULL, |
425 | GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); | 332 | GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); |
426 | phase = 0; | ||
427 | testNamespace (); | 333 | testNamespace (); |
428 | } | 334 | } |
429 | 335 | ||