diff options
Diffstat (limited to 'src/fs/test_fs_download_persistence.c')
-rw-r--r-- | src/fs/test_fs_download_persistence.c | 408 |
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 | ||
51 | struct PeerContext | 51 | struct PeerContext |
@@ -75,50 +75,46 @@ static char *fn; | |||
75 | static int err; | 75 | static int err; |
76 | 76 | ||
77 | static void | 77 | static void |
78 | timeout_kill_task (void *cls, | 78 | timeout_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 | ||
97 | static void | 95 | static void |
98 | abort_publish_task (void *cls, | 96 | abort_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 | ||
109 | static void | 106 | static void |
110 | abort_download_task (void *cls, | 107 | abort_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 | ||
130 | static void * | 126 | static void *progress_cb (void *cls, |
131 | progress_cb (void *cls, | 127 | const struct GNUNET_FS_ProgressInfo *event); |
132 | const struct GNUNET_FS_ProgressInfo *event); | ||
133 | 128 | ||
134 | 129 | ||
135 | static void | 130 | static void |
136 | restart_fs_task (void *cls, | 131 | restart_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 | ||
174 | static void * | 166 | static void * |
175 | progress_cb (void *cls, | 167 | progress_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) | |||
350 | static void | 340 | static void |
351 | run (void *cls, | 341 | run (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, | |||
408 | int | 392 | int |
409 | main (int argc, char *argv[]) | 393 | main (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; |