aboutsummaryrefslogtreecommitdiff
path: root/src/fs/test_fs_download_persistence.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/fs/test_fs_download_persistence.c')
-rw-r--r--src/fs/test_fs_download_persistence.c408
1 files changed, 196 insertions, 212 deletions
diff --git a/src/fs/test_fs_download_persistence.c b/src/fs/test_fs_download_persistence.c
index b058367a2..d484f9587 100644
--- a/src/fs/test_fs_download_persistence.c
+++ b/src/fs/test_fs_download_persistence.c
@@ -45,7 +45,7 @@
45 45
46/** 46/**
47 * How long should our test-content live? 47 * How long should our test-content live?
48 */ 48 */
49#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15) 49#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
50 50
51struct PeerContext 51struct PeerContext
@@ -75,50 +75,46 @@ static char *fn;
75static int err; 75static int err;
76 76
77static void 77static void
78timeout_kill_task (void *cls, 78timeout_kill_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
79 const struct GNUNET_SCHEDULER_TaskContext *tc)
80{ 79{
81 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 80 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Timeout downloading file\n");
82 "Timeout downloading file\n");
83 if (download != NULL) 81 if (download != NULL)
84 { 82 {
85 GNUNET_FS_download_stop (download, GNUNET_YES); 83 GNUNET_FS_download_stop (download, GNUNET_YES);
86 download = NULL; 84 download = NULL;
87 } 85 }
88 else if (publish != NULL) 86 else if (publish != NULL)
89 { 87 {
90 GNUNET_FS_publish_stop (publish); 88 GNUNET_FS_publish_stop (publish);
91 publish = NULL; 89 publish = NULL;
92 } 90 }
93 timeout_kill = GNUNET_SCHEDULER_NO_TASK; 91 timeout_kill = GNUNET_SCHEDULER_NO_TASK;
94 err = 1; 92 err = 1;
95} 93}
96 94
97static void 95static void
98abort_publish_task (void *cls, 96abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
99 const struct GNUNET_SCHEDULER_TaskContext *tc)
100{ 97{
101 if (publish != NULL) 98 if (publish != NULL)
102 { 99 {
103 GNUNET_FS_publish_stop (publish); 100 GNUNET_FS_publish_stop (publish);
104 publish = NULL; 101 publish = NULL;
105 } 102 }
106} 103}
107 104
108 105
109static void 106static void
110abort_download_task (void *cls, 107abort_download_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
111 const struct GNUNET_SCHEDULER_TaskContext *tc)
112{ 108{
113 uint64_t size; 109 uint64_t size;
114 110
115 if (download != NULL) 111 if (download != NULL)
116 { 112 {
117 GNUNET_FS_download_stop (download, GNUNET_YES); 113 GNUNET_FS_download_stop (download, GNUNET_YES);
118 download = NULL; 114 download = NULL;
119 } 115 }
120 GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES)); 116 GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES));
121 GNUNET_assert (size == FILESIZE); 117 GNUNET_assert (size == FILESIZE);
122 GNUNET_DISK_directory_remove (fn); 118 GNUNET_DISK_directory_remove (fn);
123 GNUNET_free (fn); 119 GNUNET_free (fn);
124 fn = NULL; 120 fn = NULL;
@@ -127,24 +123,20 @@ abort_download_task (void *cls,
127} 123}
128 124
129 125
130static void * 126static void *progress_cb (void *cls,
131progress_cb (void *cls, 127 const struct GNUNET_FS_ProgressInfo *event);
132 const struct GNUNET_FS_ProgressInfo *event);
133 128
134 129
135static void 130static void
136restart_fs_task (void *cls, 131restart_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
137 const struct GNUNET_SCHEDULER_TaskContext *tc)
138{ 132{
139 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 133 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Restarting FS.\n");
140 "Restarting FS.\n");
141 GNUNET_FS_stop (fs); 134 GNUNET_FS_stop (fs);
142 fs = GNUNET_FS_start (cfg, 135 fs = GNUNET_FS_start (cfg,
143 "test-fs-download-persistence", 136 "test-fs-download-persistence",
144 &progress_cb, 137 &progress_cb,
145 NULL, 138 NULL,
146 GNUNET_FS_FLAGS_PERSISTENCE, 139 GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
147 GNUNET_FS_OPTIONS_END);
148} 140}
149 141
150 142
@@ -161,152 +153,149 @@ consider_restart (int ev)
161 static int prev[32]; 153 static int prev[32];
162 static int off; 154 static int off;
163 int i; 155 int i;
164 for (i=0;i<off;i++) 156
157 for (i = 0; i < off; i++)
165 if (prev[i] == ev) 158 if (prev[i] == ev)
166 return; 159 return;
167 prev[off++] = ev; 160 prev[off++] = ev;
168 GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT, 161 GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
169 &restart_fs_task, 162 &restart_fs_task, NULL);
170 NULL);
171} 163}
172 164
173 165
174static void * 166static void *
175progress_cb (void *cls, 167progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
176 const struct GNUNET_FS_ProgressInfo *event)
177{ 168{
178 switch (event->status) 169 switch (event->status)
179 { 170 {
180 case GNUNET_FS_STATUS_PUBLISH_PROGRESS: 171 case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
181#if VERBOSE 172#if VERBOSE
182 printf ("Publish is progressing (%llu/%llu at level %u off %llu)...\n", 173 printf ("Publish is progressing (%llu/%llu at level %u off %llu)...\n",
183 (unsigned long long) event->value.publish.completed, 174 (unsigned long long) event->value.publish.completed,
184 (unsigned long long) event->value.publish.size, 175 (unsigned long long) event->value.publish.size,
185 event->value.publish.specifics.progress.depth, 176 event->value.publish.specifics.progress.depth,
186 (unsigned long long) event->value.publish.specifics.progress.offset); 177 (unsigned long long) event->value.publish.specifics.
187#endif 178 progress.offset);
188 break; 179#endif
189 case GNUNET_FS_STATUS_PUBLISH_COMPLETED: 180 break;
190 printf ("Publishing complete, %llu kbps.\n", 181 case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
191 (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL)); 182 printf ("Publishing complete, %llu kbps.\n",
192 fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst"); 183 (unsigned long long) (FILESIZE * 1000LL /
193 start = GNUNET_TIME_absolute_get (); 184 (1 +
194 GNUNET_assert (download == NULL); 185 GNUNET_TIME_absolute_get_duration
195 GNUNET_FS_download_start (fs, 186 (start).rel_value) / 1024LL));
196 event->value.publish.specifics.completed.chk_uri, 187 fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst");
197 NULL, 188 start = GNUNET_TIME_absolute_get ();
198 fn, NULL, 189 GNUNET_assert (download == NULL);
199 0, 190 GNUNET_FS_download_start (fs,
200 FILESIZE, 191 event->value.publish.specifics.completed.chk_uri,
201 1, 192 NULL,
202 GNUNET_FS_DOWNLOAD_OPTION_NONE, 193 fn, NULL,
203 "download", 194 0,
204 NULL); 195 FILESIZE,
205 break; 196 1,
206 case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: 197 GNUNET_FS_DOWNLOAD_OPTION_NONE, "download", NULL);
207 consider_restart (event->status); 198 break;
208 printf ("Download complete, %llu kbps.\n", 199 case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
209 (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL)); 200 consider_restart (event->status);
210 GNUNET_SCHEDULER_add_now (&abort_download_task, 201 printf ("Download complete, %llu kbps.\n",
211 NULL); 202 (unsigned long long) (FILESIZE * 1000LL /
212 break; 203 (1 +
213 case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: 204 GNUNET_TIME_absolute_get_duration
214 consider_restart (event->status); 205 (start).rel_value) / 1024LL));
215 GNUNET_assert (download == event->value.download.dc); 206 GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
207 break;
208 case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
209 consider_restart (event->status);
210 GNUNET_assert (download == event->value.download.dc);
216#if VERBOSE 211#if VERBOSE
217 printf ("Download is progressing (%llu/%llu at level %u off %llu)...\n", 212 printf ("Download is progressing (%llu/%llu at level %u off %llu)...\n",
218 (unsigned long long) event->value.download.completed, 213 (unsigned long long) event->value.download.completed,
219 (unsigned long long) event->value.download.size, 214 (unsigned long long) event->value.download.size,
220 event->value.download.specifics.progress.depth, 215 event->value.download.specifics.progress.depth,
221 (unsigned long long) event->value.download.specifics.progress.offset); 216 (unsigned long long) event->value.download.specifics.
217 progress.offset);
222#endif 218#endif
223 break; 219 break;
224 case GNUNET_FS_STATUS_PUBLISH_ERROR: 220 case GNUNET_FS_STATUS_PUBLISH_ERROR:
225 fprintf (stderr, 221 fprintf (stderr,
226 "Error publishing file: %s\n", 222 "Error publishing file: %s\n",
227 event->value.publish.specifics.error.message); 223 event->value.publish.specifics.error.message);
228 GNUNET_break (0); 224 GNUNET_break (0);
229 GNUNET_SCHEDULER_add_continuation (&abort_publish_task, 225 GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
230 NULL, 226 NULL,
231 GNUNET_SCHEDULER_REASON_PREREQ_DONE); 227 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
232 break; 228 break;
233 case GNUNET_FS_STATUS_DOWNLOAD_ERROR: 229 case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
234 fprintf (stderr, 230 fprintf (stderr,
235 "Error downloading file: %s\n", 231 "Error downloading file: %s\n",
236 event->value.download.specifics.error.message); 232 event->value.download.specifics.error.message);
237 GNUNET_SCHEDULER_add_now (&abort_download_task, 233 GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
238 NULL); 234 break;
239 break; 235 case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
240 case GNUNET_FS_STATUS_PUBLISH_SUSPEND: 236 GNUNET_assert (event->value.publish.pc == publish);
241 GNUNET_assert (event->value.publish.pc == publish); 237 publish = NULL;
242 publish = NULL; 238 break;
243 break; 239 case GNUNET_FS_STATUS_PUBLISH_RESUME:
244 case GNUNET_FS_STATUS_PUBLISH_RESUME: 240 GNUNET_assert (NULL == publish);
245 GNUNET_assert (NULL == publish); 241 publish = event->value.publish.pc;
246 publish = event->value.publish.pc; 242 break;
247 break; 243 case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND:
248 case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND: 244 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download suspended.\n");
249 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 245 GNUNET_assert (event->value.download.dc == download);
250 "Download suspended.\n"); 246 download = NULL;
251 GNUNET_assert (event->value.download.dc == download); 247 break;
252 download = NULL; 248 case GNUNET_FS_STATUS_DOWNLOAD_RESUME:
253 break; 249 GNUNET_assert (NULL == download);
254 case GNUNET_FS_STATUS_DOWNLOAD_RESUME: 250 download = event->value.download.dc;
255 GNUNET_assert (NULL == download); 251 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download resumed.\n");
256 download = event->value.download.dc; 252 break;
257 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 253 case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
258 "Download resumed.\n"); 254 consider_restart (event->status);
259 break; 255 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download active.\n");
260 case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: 256 break;
261 consider_restart (event->status); 257 case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
262 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 258 consider_restart (event->status);
263 "Download active.\n"); 259 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download inactive.\n");
264 break; 260 break;
265 case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: 261 case GNUNET_FS_STATUS_PUBLISH_START:
266 consider_restart (event->status); 262 GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
267 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 263 GNUNET_assert (NULL == event->value.publish.pctx);
268 "Download inactive.\n"); 264 GNUNET_assert (FILESIZE == event->value.publish.size);
269 break; 265 GNUNET_assert (0 == event->value.publish.completed);
270 case GNUNET_FS_STATUS_PUBLISH_START: 266 GNUNET_assert (1 == event->value.publish.anonymity);
271 GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx)); 267 break;
272 GNUNET_assert (NULL == event->value.publish.pctx); 268 case GNUNET_FS_STATUS_PUBLISH_STOPPED:
273 GNUNET_assert (FILESIZE == event->value.publish.size); 269 GNUNET_assert (publish == event->value.publish.pc);
274 GNUNET_assert (0 == event->value.publish.completed); 270 GNUNET_assert (FILESIZE == event->value.publish.size);
275 GNUNET_assert (1 == event->value.publish.anonymity); 271 GNUNET_assert (1 == event->value.publish.anonymity);
276 break; 272 GNUNET_FS_stop (fs);
277 case GNUNET_FS_STATUS_PUBLISH_STOPPED: 273 fs = NULL;
278 GNUNET_assert (publish == event->value.publish.pc); 274 break;
279 GNUNET_assert (FILESIZE == event->value.publish.size); 275 case GNUNET_FS_STATUS_DOWNLOAD_START:
280 GNUNET_assert (1 == event->value.publish.anonymity); 276 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download started.\n");
281 GNUNET_FS_stop (fs); 277 consider_restart (event->status);
282 fs = NULL; 278 GNUNET_assert (download == NULL);
283 break; 279 download = event->value.download.dc;
284 case GNUNET_FS_STATUS_DOWNLOAD_START: 280 GNUNET_assert (0 == strcmp ("download", event->value.download.cctx));
285 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 281 GNUNET_assert (NULL == event->value.download.pctx);
286 "Download started.\n"); 282 GNUNET_assert (NULL != event->value.download.uri);
287 consider_restart (event->status); 283 GNUNET_assert (0 == strcmp (fn, event->value.download.filename));
288 GNUNET_assert (download == NULL); 284 GNUNET_assert (FILESIZE == event->value.download.size);
289 download = event->value.download.dc; 285 GNUNET_assert (0 == event->value.download.completed);
290 GNUNET_assert (0 == strcmp ("download", event->value.download.cctx)); 286 GNUNET_assert (1 == event->value.download.anonymity);
291 GNUNET_assert (NULL == event->value.download.pctx); 287 break;
292 GNUNET_assert (NULL != event->value.download.uri); 288 case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
293 GNUNET_assert (0 == strcmp (fn, event->value.download.filename)); 289 GNUNET_assert (download == event->value.download.dc);
294 GNUNET_assert (FILESIZE == event->value.download.size); 290 GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
295 GNUNET_assert (0 == event->value.download.completed); 291 NULL,
296 GNUNET_assert (1 == event->value.download.anonymity); 292 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
297 break; 293 download = NULL;
298 case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: 294 break;
299 GNUNET_assert (download == event->value.download.dc); 295 default:
300 GNUNET_SCHEDULER_add_continuation (&abort_publish_task, 296 printf ("Unexpected event: %d\n", event->status);
301 NULL, 297 break;
302 GNUNET_SCHEDULER_REASON_PREREQ_DONE); 298 }
303 download = NULL;
304 break;
305 default:
306 printf ("Unexpected event: %d\n",
307 event->status);
308 break;
309 }
310 return NULL; 299 return NULL;
311} 300}
312 301
@@ -317,11 +306,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
317 p->cfg = GNUNET_CONFIGURATION_create (); 306 p->cfg = GNUNET_CONFIGURATION_create ();
318#if START_ARM 307#if START_ARM
319 p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm", 308 p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
320 "gnunet-service-arm", 309 "gnunet-service-arm",
321#if VERBOSE 310#if VERBOSE
322 "-L", "DEBUG", 311 "-L", "DEBUG",
323#endif 312#endif
324 "-c", cfgname, NULL); 313 "-c", cfgname, NULL);
325#endif 314#endif
326 GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); 315 GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
327} 316}
@@ -332,16 +321,17 @@ stop_arm (struct PeerContext *p)
332{ 321{
333#if START_ARM 322#if START_ARM
334 if (NULL != p->arm_proc) 323 if (NULL != p->arm_proc)
335 { 324 {
336 if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM)) 325 if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
337 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); 326 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
338 if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK) 327 if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
339 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); 328 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
340 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 329 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
341 "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc)); 330 "ARM process %u stopped\n",
342 GNUNET_OS_process_close (p->arm_proc); 331 GNUNET_OS_process_get_pid (p->arm_proc));
343 p->arm_proc = NULL; 332 GNUNET_OS_process_close (p->arm_proc);
344 } 333 p->arm_proc = NULL;
334 }
345#endif 335#endif
346 GNUNET_CONFIGURATION_destroy (p->cfg); 336 GNUNET_CONFIGURATION_destroy (p->cfg);
347} 337}
@@ -350,8 +340,7 @@ stop_arm (struct PeerContext *p)
350static void 340static void
351run (void *cls, 341run (void *cls,
352 char *const *args, 342 char *const *args,
353 const char *cfgfile, 343 const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
354 const struct GNUNET_CONFIGURATION_Handle *c)
355{ 344{
356 const char *keywords[] = { 345 const char *keywords[] = {
357 "down_foo", 346 "down_foo",
@@ -367,12 +356,11 @@ run (void *cls,
367 cfg = c; 356 cfg = c;
368 setup_peer (&p1, "test_fs_download_data.conf"); 357 setup_peer (&p1, "test_fs_download_data.conf");
369 fs = GNUNET_FS_start (cfg, 358 fs = GNUNET_FS_start (cfg,
370 "test-fs-download-persistence", 359 "test-fs-download-persistence",
371 &progress_cb, 360 &progress_cb,
372 NULL, 361 NULL,
373 GNUNET_FS_FLAGS_PERSISTENCE, 362 GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
374 GNUNET_FS_OPTIONS_END); 363 GNUNET_assert (NULL != fs);
375 GNUNET_assert (NULL != fs);
376 buf = GNUNET_malloc (FILESIZE); 364 buf = GNUNET_malloc (FILESIZE);
377 for (i = 0; i < FILESIZE; i++) 365 for (i = 0; i < FILESIZE; i++)
378 buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256); 366 buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
@@ -381,26 +369,22 @@ run (void *cls,
381 bo.content_priority = 42; 369 bo.content_priority = 42;
382 bo.anonymity_level = 1; 370 bo.anonymity_level = 1;
383 bo.replication_level = 0; 371 bo.replication_level = 0;
384 bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME); 372 bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
385 fi = GNUNET_FS_file_information_create_from_data (fs, 373 fi = GNUNET_FS_file_information_create_from_data (fs,
386 "publish-context", 374 "publish-context",
387 FILESIZE, 375 FILESIZE,
388 buf, 376 buf,
389 kuri, 377 kuri, meta, GNUNET_NO, &bo);
390 meta,
391 GNUNET_NO,
392 &bo);
393 GNUNET_FS_uri_destroy (kuri); 378 GNUNET_FS_uri_destroy (kuri);
394 GNUNET_CONTAINER_meta_data_destroy (meta); 379 GNUNET_CONTAINER_meta_data_destroy (meta);
395 GNUNET_assert (NULL != fi); 380 GNUNET_assert (NULL != fi);
396 timeout_kill = GNUNET_SCHEDULER_add_delayed (TIMEOUT, 381 timeout_kill = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
397 &timeout_kill_task, 382 &timeout_kill_task, NULL);
398 NULL);
399 start = GNUNET_TIME_absolute_get (); 383 start = GNUNET_TIME_absolute_get ();
400 publish = GNUNET_FS_publish_start (fs, 384 publish = GNUNET_FS_publish_start (fs,
401 fi, 385 fi,
402 NULL, NULL, NULL, 386 NULL, NULL, NULL,
403 GNUNET_FS_PUBLISH_OPTION_NONE); 387 GNUNET_FS_PUBLISH_OPTION_NONE);
404 GNUNET_assert (publish != NULL); 388 GNUNET_assert (publish != NULL);
405} 389}
406 390
@@ -408,7 +392,7 @@ run (void *cls,
408int 392int
409main (int argc, char *argv[]) 393main (int argc, char *argv[])
410{ 394{
411 char *const argvx[] = { 395 char *const argvx[] = {
412 "test-fs-download-persistence", 396 "test-fs-download-persistence",
413 "-c", 397 "-c",
414 "test_fs_download_data.conf", 398 "test_fs_download_data.conf",
@@ -420,17 +404,17 @@ main (int argc, char *argv[])
420 struct GNUNET_GETOPT_CommandLineOption options[] = { 404 struct GNUNET_GETOPT_CommandLineOption options[] = {
421 GNUNET_GETOPT_OPTION_END 405 GNUNET_GETOPT_OPTION_END
422 }; 406 };
423 GNUNET_log_setup ("test_fs_download_persistence", 407 GNUNET_log_setup ("test_fs_download_persistence",
424#if VERBOSE 408#if VERBOSE
425 "DEBUG", 409 "DEBUG",
426#else 410#else
427 "WARNING", 411 "WARNING",
428#endif 412#endif
429 NULL); 413 NULL);
430 GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/"); 414 GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/");
431 GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, 415 GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
432 argvx, "test-fs-download-persistence", 416 argvx, "test-fs-download-persistence",
433 "nohelp", options, &run, NULL); 417 "nohelp", options, &run, NULL);
434 stop_arm (&p1); 418 stop_arm (&p1);
435 GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/"); 419 GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/");
436 return err; 420 return err;