diff options
author | Christian Grothoff <christian@grothoff.org> | 2011-08-15 21:46:35 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2011-08-15 21:46:35 +0000 |
commit | 502af2167f7c218366666ca4944bd7cc54b5b19a (patch) | |
tree | a91fec5cc9769d260640bd91c6633cb9cf395524 /src/fs/test_fs_namespace.c | |
parent | 03af5a603b7cc53432249d5854cd412aa90dde0d (diff) | |
download | gnunet-502af2167f7c218366666ca4944bd7cc54b5b19a.tar.gz gnunet-502af2167f7c218366666ca4944bd7cc54b5b19a.zip |
indentation
Diffstat (limited to 'src/fs/test_fs_namespace.c')
-rw-r--r-- | src/fs/test_fs_namespace.c | 384 |
1 files changed, 170 insertions, 214 deletions
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c index b4d487ddc..96caa8dfa 100644 --- a/src/fs/test_fs_namespace.c +++ b/src/fs/test_fs_namespace.c | |||
@@ -67,11 +67,11 @@ setup_peer (struct PeerContext *p, const char *cfgname) | |||
67 | p->cfg = GNUNET_CONFIGURATION_create (); | 67 | p->cfg = GNUNET_CONFIGURATION_create (); |
68 | #if START_ARM | 68 | #if START_ARM |
69 | p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm", | 69 | p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm", |
70 | "gnunet-service-arm", | 70 | "gnunet-service-arm", |
71 | #if VERBOSE | 71 | #if VERBOSE |
72 | "-L", "DEBUG", | 72 | "-L", "DEBUG", |
73 | #endif | 73 | #endif |
74 | "-c", cfgname, NULL); | 74 | "-c", cfgname, NULL); |
75 | #endif | 75 | #endif |
76 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); | 76 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); |
77 | } | 77 | } |
@@ -82,68 +82,64 @@ stop_arm (struct PeerContext *p) | |||
82 | { | 82 | { |
83 | #if START_ARM | 83 | #if START_ARM |
84 | if (NULL != p->arm_proc) | 84 | if (NULL != p->arm_proc) |
85 | { | 85 | { |
86 | if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM)) | 86 | if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM)) |
87 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | 87 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); |
88 | if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK) | 88 | if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK) |
89 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); | 89 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); |
90 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 90 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
91 | "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc)); | 91 | "ARM process %u stopped\n", |
92 | GNUNET_OS_process_close (p->arm_proc); | 92 | GNUNET_OS_process_get_pid (p->arm_proc)); |
93 | p->arm_proc = NULL; | 93 | GNUNET_OS_process_close (p->arm_proc); |
94 | } | 94 | p->arm_proc = NULL; |
95 | } | ||
95 | #endif | 96 | #endif |
96 | GNUNET_CONFIGURATION_destroy (p->cfg); | 97 | GNUNET_CONFIGURATION_destroy (p->cfg); |
97 | } | 98 | } |
98 | 99 | ||
99 | 100 | ||
100 | static void | 101 | static void |
101 | abort_ksk_search_task (void *cls, | 102 | abort_ksk_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
102 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
103 | { | 103 | { |
104 | if (ksk_search != NULL) | 104 | if (ksk_search != NULL) |
105 | { | ||
106 | GNUNET_FS_search_stop (ksk_search); | ||
107 | ksk_search = NULL; | ||
108 | if (sks_search == NULL) | ||
105 | { | 109 | { |
106 | GNUNET_FS_search_stop (ksk_search); | 110 | GNUNET_FS_stop (fs); |
107 | ksk_search = NULL; | 111 | if (GNUNET_SCHEDULER_NO_TASK != kill_task) |
108 | if (sks_search == NULL) | 112 | GNUNET_SCHEDULER_cancel (kill_task); |
109 | { | ||
110 | GNUNET_FS_stop (fs); | ||
111 | if (GNUNET_SCHEDULER_NO_TASK != kill_task) | ||
112 | GNUNET_SCHEDULER_cancel (kill_task); | ||
113 | } | ||
114 | } | 113 | } |
114 | } | ||
115 | } | 115 | } |
116 | 116 | ||
117 | 117 | ||
118 | static void | 118 | static void |
119 | abort_sks_search_task (void *cls, | 119 | abort_sks_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
120 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
121 | { | 120 | { |
122 | struct GNUNET_FS_Namespace *ns; | 121 | struct GNUNET_FS_Namespace *ns; |
123 | 122 | ||
124 | if (sks_search == NULL) | 123 | if (sks_search == NULL) |
125 | return; | 124 | return; |
126 | GNUNET_FS_search_stop (sks_search); | 125 | GNUNET_FS_search_stop (sks_search); |
127 | sks_search = NULL; | 126 | sks_search = NULL; |
128 | ns = GNUNET_FS_namespace_create (fs, | 127 | ns = GNUNET_FS_namespace_create (fs, "testNamespace"); |
129 | "testNamespace"); | ||
130 | GNUNET_assert (NULL != ns); | 128 | GNUNET_assert (NULL != ns); |
131 | GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_YES)); | 129 | GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_YES)); |
132 | if (ksk_search == NULL) | 130 | if (ksk_search == NULL) |
133 | { | 131 | { |
134 | GNUNET_FS_stop (fs); | 132 | GNUNET_FS_stop (fs); |
135 | if (GNUNET_SCHEDULER_NO_TASK != kill_task) | 133 | if (GNUNET_SCHEDULER_NO_TASK != kill_task) |
136 | GNUNET_SCHEDULER_cancel (kill_task); | 134 | GNUNET_SCHEDULER_cancel (kill_task); |
137 | } | 135 | } |
138 | } | 136 | } |
139 | 137 | ||
140 | 138 | ||
141 | static void | 139 | static void |
142 | do_timeout (void *cls, | 140 | do_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
143 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
144 | { | 141 | { |
145 | fprintf (stderr, | 142 | fprintf (stderr, "Operation timed out\n"); |
146 | "Operation timed out\n"); | ||
147 | kill_task = GNUNET_SCHEDULER_NO_TASK; | 143 | kill_task = GNUNET_SCHEDULER_NO_TASK; |
148 | abort_sks_search_task (NULL, tc); | 144 | abort_sks_search_task (NULL, tc); |
149 | abort_ksk_search_task (NULL, tc); | 145 | abort_ksk_search_task (NULL, tc); |
@@ -152,134 +148,121 @@ do_timeout (void *cls, | |||
152 | 148 | ||
153 | 149 | ||
154 | static void * | 150 | static void * |
155 | progress_cb (void *cls, | 151 | progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) |
156 | const struct GNUNET_FS_ProgressInfo *event) | ||
157 | { | 152 | { |
158 | switch (event->status) | 153 | switch (event->status) |
154 | { | ||
155 | case GNUNET_FS_STATUS_SEARCH_RESULT: | ||
156 | if (sks_search == event->value.search.sc) | ||
157 | { | ||
158 | if (!GNUNET_FS_uri_test_equal (sks_expect_uri, | ||
159 | event->value.search.specifics.result.uri)) | ||
160 | { | ||
161 | fprintf (stderr, "Wrong result for sks search!\n"); | ||
162 | err = 1; | ||
163 | } | ||
164 | /* give system 1ms to initiate update search! */ | ||
165 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS, | ||
166 | &abort_sks_search_task, NULL); | ||
167 | } | ||
168 | else if (ksk_search == event->value.search.sc) | ||
159 | { | 169 | { |
160 | case GNUNET_FS_STATUS_SEARCH_RESULT: | 170 | if (!GNUNET_FS_uri_test_equal (ksk_expect_uri, |
161 | if (sks_search == event->value.search.sc) | 171 | event->value.search.specifics.result.uri)) |
162 | { | 172 | { |
163 | if (! GNUNET_FS_uri_test_equal (sks_expect_uri, | 173 | fprintf (stderr, "Wrong result for ksk search!\n"); |
164 | event->value.search.specifics.result.uri)) | 174 | err = 1; |
165 | { | 175 | } |
166 | fprintf (stderr, | 176 | GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task, |
167 | "Wrong result for sks search!\n"); | 177 | NULL, |
168 | err = 1; | 178 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
169 | } | ||
170 | /* give system 1ms to initiate update search! */ | ||
171 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS, | ||
172 | &abort_sks_search_task, | ||
173 | NULL); | ||
174 | } | ||
175 | else if (ksk_search == event->value.search.sc) | ||
176 | { | ||
177 | if (! GNUNET_FS_uri_test_equal (ksk_expect_uri, | ||
178 | event->value.search.specifics.result.uri)) | ||
179 | { | ||
180 | fprintf (stderr, | ||
181 | "Wrong result for ksk search!\n"); | ||
182 | err = 1; | ||
183 | } | ||
184 | GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task, | ||
185 | NULL, | ||
186 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
187 | } | ||
188 | else | ||
189 | { | ||
190 | fprintf (stderr, | ||
191 | "Unexpected search result received!\n"); | ||
192 | GNUNET_break (0); | ||
193 | } | ||
194 | break; | ||
195 | case GNUNET_FS_STATUS_SEARCH_ERROR: | ||
196 | fprintf (stderr, | ||
197 | "Error searching file: %s\n", | ||
198 | event->value.search.specifics.error.message); | ||
199 | if (sks_search == event->value.search.sc) | ||
200 | GNUNET_SCHEDULER_add_continuation (&abort_sks_search_task, | ||
201 | NULL, | ||
202 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
203 | else if (ksk_search == event->value.search.sc) | ||
204 | GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task, | ||
205 | NULL, | ||
206 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
207 | else | ||
208 | GNUNET_break (0); | ||
209 | break; | ||
210 | case GNUNET_FS_STATUS_SEARCH_START: | ||
211 | GNUNET_assert ( (NULL == event->value.search.cctx) || | ||
212 | (0 == strcmp ("sks_search", event->value.search.cctx)) || | ||
213 | (0 == strcmp ("ksk_search", event->value.search.cctx))); | ||
214 | if (NULL == event->value.search.cctx) | ||
215 | { | ||
216 | GNUNET_assert (0 == strcmp ("sks_search", event->value.search.pctx)); | ||
217 | update_started = GNUNET_YES; | ||
218 | } | ||
219 | GNUNET_assert (1 == event->value.search.anonymity); | ||
220 | break; | ||
221 | case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: | ||
222 | return NULL; | ||
223 | case GNUNET_FS_STATUS_SEARCH_STOPPED: | ||
224 | return NULL; | ||
225 | default: | ||
226 | fprintf (stderr, | ||
227 | "Unexpected event: %d\n", | ||
228 | event->status); | ||
229 | break; | ||
230 | } | 179 | } |
180 | else | ||
181 | { | ||
182 | fprintf (stderr, "Unexpected search result received!\n"); | ||
183 | GNUNET_break (0); | ||
184 | } | ||
185 | break; | ||
186 | case GNUNET_FS_STATUS_SEARCH_ERROR: | ||
187 | fprintf (stderr, | ||
188 | "Error searching file: %s\n", | ||
189 | event->value.search.specifics.error.message); | ||
190 | if (sks_search == event->value.search.sc) | ||
191 | GNUNET_SCHEDULER_add_continuation (&abort_sks_search_task, | ||
192 | NULL, | ||
193 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
194 | else if (ksk_search == event->value.search.sc) | ||
195 | GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task, | ||
196 | NULL, | ||
197 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
198 | else | ||
199 | GNUNET_break (0); | ||
200 | break; | ||
201 | case GNUNET_FS_STATUS_SEARCH_START: | ||
202 | GNUNET_assert ((NULL == event->value.search.cctx) || | ||
203 | (0 == strcmp ("sks_search", event->value.search.cctx)) || | ||
204 | (0 == strcmp ("ksk_search", event->value.search.cctx))); | ||
205 | if (NULL == event->value.search.cctx) | ||
206 | { | ||
207 | GNUNET_assert (0 == strcmp ("sks_search", event->value.search.pctx)); | ||
208 | update_started = GNUNET_YES; | ||
209 | } | ||
210 | GNUNET_assert (1 == event->value.search.anonymity); | ||
211 | break; | ||
212 | case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: | ||
213 | return NULL; | ||
214 | case GNUNET_FS_STATUS_SEARCH_STOPPED: | ||
215 | return NULL; | ||
216 | default: | ||
217 | fprintf (stderr, "Unexpected event: %d\n", event->status); | ||
218 | break; | ||
219 | } | ||
231 | return event->value.search.cctx; | 220 | return event->value.search.cctx; |
232 | } | 221 | } |
233 | 222 | ||
234 | 223 | ||
235 | static void | 224 | static void |
236 | publish_cont (void *cls, | 225 | publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg) |
237 | const struct GNUNET_FS_Uri *ksk_uri, | ||
238 | const char *emsg) | ||
239 | { | 226 | { |
240 | char *msg; | 227 | char *msg; |
241 | struct GNUNET_FS_Uri *sks_uri; | 228 | struct GNUNET_FS_Uri *sks_uri; |
242 | char sbuf[1024]; | 229 | char sbuf[1024]; |
243 | struct GNUNET_CRYPTO_HashAsciiEncoded enc; | 230 | struct GNUNET_CRYPTO_HashAsciiEncoded enc; |
244 | 231 | ||
245 | if (NULL != emsg) | 232 | if (NULL != emsg) |
246 | { | 233 | { |
247 | fprintf (stderr, "Error publishing: %s\n", emsg); | 234 | fprintf (stderr, "Error publishing: %s\n", emsg); |
248 | err = 1; | 235 | err = 1; |
249 | GNUNET_FS_stop (fs); | 236 | GNUNET_FS_stop (fs); |
250 | return; | 237 | return; |
251 | } | 238 | } |
252 | GNUNET_CRYPTO_hash_to_enc (&nsid, | 239 | GNUNET_CRYPTO_hash_to_enc (&nsid, &enc); |
253 | &enc); | 240 | GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", &enc); |
254 | GNUNET_snprintf (sbuf, | ||
255 | sizeof (sbuf), | ||
256 | "gnunet://fs/sks/%s/this", | ||
257 | &enc); | ||
258 | sks_uri = GNUNET_FS_uri_parse (sbuf, &msg); | 241 | sks_uri = GNUNET_FS_uri_parse (sbuf, &msg); |
259 | if (msg != NULL) | 242 | if (msg != NULL) |
260 | { | 243 | { |
261 | fprintf (stderr, "failed to parse URI `%s': %s\n", | 244 | fprintf (stderr, "failed to parse URI `%s': %s\n", sbuf, msg); |
262 | sbuf, | 245 | err = 1; |
263 | msg); | 246 | GNUNET_FS_stop (fs); |
264 | err = 1; | 247 | GNUNET_free (msg); |
265 | GNUNET_FS_stop (fs); | 248 | return; |
266 | GNUNET_free (msg); | 249 | } |
267 | return; | 250 | ksk_search = |
268 | } | 251 | GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, |
269 | ksk_search = GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, "ksk_search"); | 252 | "ksk_search"); |
270 | sks_search = GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, "sks_search"); | 253 | sks_search = |
254 | GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, | ||
255 | "sks_search"); | ||
271 | GNUNET_FS_uri_destroy (sks_uri); | 256 | GNUNET_FS_uri_destroy (sks_uri); |
272 | } | 257 | } |
273 | 258 | ||
274 | 259 | ||
275 | static void | 260 | static void |
276 | sks_cont (void *cls, | 261 | sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) |
277 | const struct GNUNET_FS_Uri *uri, | ||
278 | const char *emsg) | ||
279 | { | 262 | { |
280 | struct GNUNET_CONTAINER_MetaData *meta; | 263 | struct GNUNET_CONTAINER_MetaData *meta; |
281 | struct GNUNET_FS_Uri *ksk_uri; | 264 | struct GNUNET_FS_Uri *ksk_uri; |
282 | char * msg; | 265 | char *msg; |
283 | struct GNUNET_FS_BlockOptions bo; | 266 | struct GNUNET_FS_BlockOptions bo; |
284 | 267 | ||
285 | meta = GNUNET_CONTAINER_meta_data_create (); | 268 | meta = GNUNET_CONTAINER_meta_data_create (); |
@@ -290,38 +273,30 @@ sks_cont (void *cls, | |||
290 | bo.content_priority = 1; | 273 | bo.content_priority = 1; |
291 | bo.anonymity_level = 1; | 274 | bo.anonymity_level = 1; |
292 | bo.replication_level = 0; | 275 | bo.replication_level = 0; |
293 | bo.expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); | 276 | bo.expiration_time = |
294 | GNUNET_FS_publish_ksk (fs, | 277 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); |
295 | ksk_uri, | 278 | GNUNET_FS_publish_ksk (fs, ksk_uri, meta, uri, &bo, |
296 | meta, | 279 | GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL); |
297 | uri, | ||
298 | &bo, | ||
299 | GNUNET_FS_PUBLISH_OPTION_NONE, | ||
300 | &publish_cont, | ||
301 | NULL); | ||
302 | GNUNET_FS_uri_destroy (ksk_uri); | 280 | GNUNET_FS_uri_destroy (ksk_uri); |
303 | GNUNET_CONTAINER_meta_data_destroy (meta); | 281 | GNUNET_CONTAINER_meta_data_destroy (meta); |
304 | } | 282 | } |
305 | 283 | ||
306 | 284 | ||
307 | static void | 285 | static void |
308 | adv_cont (void *cls, | 286 | adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) |
309 | const struct GNUNET_FS_Uri *uri, | ||
310 | const char *emsg) | ||
311 | { | 287 | { |
312 | struct GNUNET_CONTAINER_MetaData *meta; | 288 | struct GNUNET_CONTAINER_MetaData *meta; |
313 | struct GNUNET_FS_Namespace *ns; | 289 | struct GNUNET_FS_Namespace *ns; |
314 | struct GNUNET_FS_BlockOptions bo; | 290 | struct GNUNET_FS_BlockOptions bo; |
315 | 291 | ||
316 | if (NULL != emsg) | 292 | if (NULL != emsg) |
317 | { | 293 | { |
318 | fprintf (stderr, "Error publishing: %s\n", emsg); | 294 | fprintf (stderr, "Error publishing: %s\n", emsg); |
319 | err = 1; | 295 | err = 1; |
320 | GNUNET_FS_stop (fs); | 296 | GNUNET_FS_stop (fs); |
321 | return; | 297 | return; |
322 | } | 298 | } |
323 | ns = GNUNET_FS_namespace_create (fs, | 299 | ns = GNUNET_FS_namespace_create (fs, "testNamespace"); |
324 | "testNamespace"); | ||
325 | GNUNET_assert (NULL != ns); | 300 | GNUNET_assert (NULL != ns); |
326 | meta = GNUNET_CONTAINER_meta_data_create (); | 301 | meta = GNUNET_CONTAINER_meta_data_create (); |
327 | GNUNET_assert (NULL == emsg); | 302 | GNUNET_assert (NULL == emsg); |
@@ -329,31 +304,21 @@ adv_cont (void *cls, | |||
329 | bo.content_priority = 1; | 304 | bo.content_priority = 1; |
330 | bo.anonymity_level = 1; | 305 | bo.anonymity_level = 1; |
331 | bo.replication_level = 0; | 306 | bo.replication_level = 0; |
332 | bo.expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); | 307 | bo.expiration_time = |
333 | GNUNET_FS_publish_sks (fs, | 308 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); |
334 | ns, | 309 | GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri, /* FIXME: this is non-sense (use CHK URI!?) */ |
335 | "this", | 310 | &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL); |
336 | "next", | ||
337 | meta, | ||
338 | uri, /* FIXME: this is non-sense (use CHK URI!?) */ | ||
339 | &bo, | ||
340 | GNUNET_FS_PUBLISH_OPTION_NONE, | ||
341 | &sks_cont, | ||
342 | NULL); | ||
343 | GNUNET_CONTAINER_meta_data_destroy (meta); | 311 | GNUNET_CONTAINER_meta_data_destroy (meta); |
344 | GNUNET_FS_namespace_delete (ns, GNUNET_NO); | 312 | GNUNET_FS_namespace_delete (ns, GNUNET_NO); |
345 | } | 313 | } |
346 | 314 | ||
347 | 315 | ||
348 | static void | 316 | static void |
349 | ns_iterator (void *cls, | 317 | ns_iterator (void *cls, const char *name, const GNUNET_HashCode * id) |
350 | const char *name, | ||
351 | const GNUNET_HashCode *id) | ||
352 | { | 318 | { |
353 | int *ok = cls; | 319 | int *ok = cls; |
354 | 320 | ||
355 | if (0 != strcmp (name, | 321 | if (0 != strcmp (name, "testNamespace")) |
356 | "testNamespace")) | ||
357 | return; | 322 | return; |
358 | *ok = GNUNET_YES; | 323 | *ok = GNUNET_YES; |
359 | nsid = *id; | 324 | nsid = *id; |
@@ -369,35 +334,30 @@ testNamespace () | |||
369 | struct GNUNET_FS_Uri *ksk_uri; | 334 | struct GNUNET_FS_Uri *ksk_uri; |
370 | int ok; | 335 | int ok; |
371 | 336 | ||
372 | ns = GNUNET_FS_namespace_create (fs, | 337 | ns = GNUNET_FS_namespace_create (fs, "testNamespace"); |
373 | "testNamespace"); | ||
374 | GNUNET_assert (NULL != ns); | 338 | GNUNET_assert (NULL != ns); |
375 | ok = GNUNET_NO; | 339 | ok = GNUNET_NO; |
376 | GNUNET_FS_namespace_list (fs, &ns_iterator, &ok); | 340 | GNUNET_FS_namespace_list (fs, &ns_iterator, &ok); |
377 | if (GNUNET_NO == ok) | 341 | if (GNUNET_NO == ok) |
378 | { | 342 | { |
379 | fprintf (stderr, "namespace_list failed to find namespace!\n"); | 343 | fprintf (stderr, "namespace_list failed to find namespace!\n"); |
380 | GNUNET_FS_namespace_delete (ns, GNUNET_YES); | 344 | GNUNET_FS_namespace_delete (ns, GNUNET_YES); |
381 | GNUNET_FS_stop (fs); | 345 | GNUNET_FS_stop (fs); |
382 | err = 1; | 346 | err = 1; |
383 | return; | 347 | return; |
384 | } | 348 | } |
385 | meta = GNUNET_CONTAINER_meta_data_create (); | 349 | meta = GNUNET_CONTAINER_meta_data_create (); |
386 | ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL); | 350 | ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL); |
387 | bo.content_priority = 1; | 351 | bo.content_priority = 1; |
388 | bo.anonymity_level = 1; | 352 | bo.anonymity_level = 1; |
389 | bo.replication_level = 0; | 353 | bo.replication_level = 0; |
390 | bo.expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); | 354 | bo.expiration_time = |
391 | GNUNET_FS_namespace_advertise (fs, | 355 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); |
392 | ksk_uri, | 356 | GNUNET_FS_namespace_advertise (fs, ksk_uri, ns, meta, &bo, "root", &adv_cont, |
393 | ns, | 357 | NULL); |
394 | meta, | 358 | kill_task = |
395 | &bo, | 359 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout, |
396 | "root", | 360 | NULL); |
397 | &adv_cont, NULL); | ||
398 | kill_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, | ||
399 | &do_timeout, | ||
400 | NULL); | ||
401 | GNUNET_FS_uri_destroy (ksk_uri); | 361 | GNUNET_FS_uri_destroy (ksk_uri); |
402 | GNUNET_FS_namespace_delete (ns, GNUNET_NO); | 362 | GNUNET_FS_namespace_delete (ns, GNUNET_NO); |
403 | GNUNET_CONTAINER_meta_data_destroy (meta); | 363 | GNUNET_CONTAINER_meta_data_destroy (meta); |
@@ -407,16 +367,13 @@ testNamespace () | |||
407 | static void | 367 | static void |
408 | run (void *cls, | 368 | run (void *cls, |
409 | char *const *args, | 369 | char *const *args, |
410 | const char *cfgfile, | 370 | const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg) |
411 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
412 | { | 371 | { |
413 | setup_peer (&p1, "test_fs_namespace_data.conf"); | 372 | setup_peer (&p1, "test_fs_namespace_data.conf"); |
414 | fs = GNUNET_FS_start (cfg, | 373 | fs = GNUNET_FS_start (cfg, |
415 | "test-fs-namespace", | 374 | "test-fs-namespace", |
416 | &progress_cb, | 375 | &progress_cb, |
417 | NULL, | 376 | NULL, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); |
418 | GNUNET_FS_FLAGS_NONE, | ||
419 | GNUNET_FS_OPTIONS_END); | ||
420 | testNamespace (); | 377 | testNamespace (); |
421 | } | 378 | } |
422 | 379 | ||
@@ -424,7 +381,7 @@ run (void *cls, | |||
424 | int | 381 | int |
425 | main (int argc, char *argv[]) | 382 | main (int argc, char *argv[]) |
426 | { | 383 | { |
427 | char *const argvx[] = { | 384 | char *const argvx[] = { |
428 | "test-fs-namespace", | 385 | "test-fs-namespace", |
429 | "-c", | 386 | "-c", |
430 | "test_fs_namespace_data.conf", | 387 | "test_fs_namespace_data.conf", |
@@ -437,23 +394,22 @@ main (int argc, char *argv[]) | |||
437 | GNUNET_GETOPT_OPTION_END | 394 | GNUNET_GETOPT_OPTION_END |
438 | }; | 395 | }; |
439 | 396 | ||
440 | GNUNET_log_setup ("test_fs_namespace", | 397 | GNUNET_log_setup ("test_fs_namespace", |
441 | #if VERBOSE | 398 | #if VERBOSE |
442 | "DEBUG", | 399 | "DEBUG", |
443 | #else | 400 | #else |
444 | "WARNING", | 401 | "WARNING", |
445 | #endif | 402 | #endif |
446 | NULL); | 403 | NULL); |
447 | GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, | 404 | GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, |
448 | argvx, "test-fs-namespace", | 405 | argvx, "test-fs-namespace", |
449 | "nohelp", options, &run, NULL); | 406 | "nohelp", options, &run, NULL); |
450 | stop_arm (&p1); | 407 | stop_arm (&p1); |
451 | if (GNUNET_YES != update_started) | 408 | if (GNUNET_YES != update_started) |
452 | { | 409 | { |
453 | fprintf (stderr, | 410 | fprintf (stderr, "Update search never started!\n"); |
454 | "Update search never started!\n"); | 411 | err = 1; |
455 | err = 1; | 412 | } |
456 | } | ||
457 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-namespace/"); | 413 | GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-namespace/"); |
458 | return err; | 414 | return err; |
459 | } | 415 | } |