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.c399
1 files changed, 200 insertions, 199 deletions
diff --git a/src/fs/test_fs_download_persistence.c b/src/fs/test_fs_download_persistence.c
index 78dbe821e..7b7a886eb 100644
--- a/src/fs/test_fs_download_persistence.c
+++ b/src/fs/test_fs_download_persistence.c
@@ -36,12 +36,12 @@
36/** 36/**
37 * How long until we give up on transmitting the message? 37 * How long until we give up on transmitting the message?
38 */ 38 */
39#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60) 39#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
40 40
41/** 41/**
42 * How long should our test-content live? 42 * How long should our test-content live?
43 */ 43 */
44#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15) 44#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
45 45
46 46
47static struct GNUNET_TIME_Absolute start; 47static struct GNUNET_TIME_Absolute start;
@@ -54,7 +54,7 @@ static struct GNUNET_FS_DownloadContext *download;
54 54
55static struct GNUNET_FS_PublishContext *publish; 55static struct GNUNET_FS_PublishContext *publish;
56 56
57static struct GNUNET_SCHEDULER_Task * timeout_kill; 57static struct GNUNET_SCHEDULER_Task *timeout_kill;
58 58
59static char *fn; 59static char *fn;
60 60
@@ -62,66 +62,67 @@ static int err;
62 62
63 63
64static void 64static void
65timeout_kill_task(void *cls) 65timeout_kill_task (void *cls)
66{ 66{
67 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Timeout downloading file\n"); 67 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Timeout downloading file\n");
68 if (download != NULL) 68 if (download != NULL)
69 { 69 {
70 GNUNET_FS_download_stop(download, GNUNET_YES); 70 GNUNET_FS_download_stop (download, GNUNET_YES);
71 download = NULL; 71 download = NULL;
72 } 72 }
73 else if (publish != NULL) 73 else if (publish != NULL)
74 { 74 {
75 GNUNET_FS_publish_stop(publish); 75 GNUNET_FS_publish_stop (publish);
76 publish = NULL; 76 publish = NULL;
77 } 77 }
78 timeout_kill = NULL; 78 timeout_kill = NULL;
79 err = 1; 79 err = 1;
80} 80}
81 81
82 82
83static void 83static void
84abort_publish_task(void *cls) 84abort_publish_task (void *cls)
85{ 85{
86 if (publish != NULL) 86 if (publish != NULL)
87 { 87 {
88 GNUNET_FS_publish_stop(publish); 88 GNUNET_FS_publish_stop (publish);
89 publish = NULL; 89 publish = NULL;
90 } 90 }
91} 91}
92 92
93 93
94static void 94static void
95abort_download_task(void *cls) 95abort_download_task (void *cls)
96{ 96{
97 uint64_t size; 97 uint64_t size;
98 98
99 if (download != NULL) 99 if (download != NULL)
100 { 100 {
101 GNUNET_FS_download_stop(download, GNUNET_YES); 101 GNUNET_FS_download_stop (download, GNUNET_YES);
102 download = NULL; 102 download = NULL;
103 } 103 }
104 GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_size(fn, &size, GNUNET_YES, GNUNET_NO)); 104 GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES,
105 GNUNET_assert(size == FILESIZE); 105 GNUNET_NO));
106 GNUNET_DISK_directory_remove(fn); 106 GNUNET_assert (size == FILESIZE);
107 GNUNET_free(fn); 107 GNUNET_DISK_directory_remove (fn);
108 GNUNET_free (fn);
108 fn = NULL; 109 fn = NULL;
109 GNUNET_SCHEDULER_cancel(timeout_kill); 110 GNUNET_SCHEDULER_cancel (timeout_kill);
110 timeout_kill = NULL; 111 timeout_kill = NULL;
111} 112}
112 113
113 114
114static void * 115static void *
115progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event); 116progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event);
116 117
117 118
118static void 119static void
119restart_fs_task(void *cls) 120restart_fs_task (void *cls)
120{ 121{
121 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Restarting FS.\n"); 122 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Restarting FS.\n");
122 GNUNET_FS_stop(fs); 123 GNUNET_FS_stop (fs);
123 fs = GNUNET_FS_start(cfg, "test-fs-download-persistence", &progress_cb, NULL, 124 fs = GNUNET_FS_start (cfg, "test-fs-download-persistence", &progress_cb, NULL,
124 GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END); 125 GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
125} 126}
126 127
127 128
@@ -133,7 +134,7 @@ restart_fs_task(void *cls)
133 * @param ev type of the event to consider 134 * @param ev type of the event to consider
134 */ 135 */
135static void 136static void
136consider_restart(int ev) 137consider_restart (int ev)
137{ 138{
138 static int prev[32]; 139 static int prev[32];
139 static int off; 140 static int off;
@@ -143,158 +144,158 @@ consider_restart(int ev)
143 if (prev[i] == ev) 144 if (prev[i] == ev)
144 return; 145 return;
145 prev[off++] = ev; 146 prev[off++] = ev;
146 GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_URGENT, 147 GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
147 &restart_fs_task, NULL); 148 &restart_fs_task, NULL);
148} 149}
149 150
150 151
151static void * 152static void *
152progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event) 153progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
153{ 154{
154 switch (event->status) 155 switch (event->status)
155 { 156 {
156 case GNUNET_FS_STATUS_PUBLISH_PROGRESS: 157 case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
157 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 158 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
158 "Publish is progressing (%llu/%llu at level %u off %llu)...\n", 159 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
159 (unsigned long long)event->value.publish.completed, 160 (unsigned long long) event->value.publish.completed,
160 (unsigned long long)event->value.publish.size, 161 (unsigned long long) event->value.publish.size,
161 event->value.publish.specifics.progress.depth, 162 event->value.publish.specifics.progress.depth,
162 (unsigned long long)event->value.publish.specifics. 163 (unsigned long long) event->value.publish.specifics.
163 progress.offset); 164 progress.offset);
164 break; 165 break;
165 166
166 case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY: 167 case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
167 break; 168 break;
168 169
169 case GNUNET_FS_STATUS_PUBLISH_COMPLETED: 170 case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
170 printf("Publishing complete, %llu kbps.\n", 171 printf ("Publishing complete, %llu kbps.\n",
171 (unsigned long long)(FILESIZE * 1000000LL / 172 (unsigned long long) (FILESIZE * 1000000LL
172 (1 + 173 / (1
173 GNUNET_TIME_absolute_get_duration 174 + GNUNET_TIME_absolute_get_duration
174 (start).rel_value_us) / 1024LL)); 175 (start).rel_value_us) / 1024LL));
175 fn = GNUNET_DISK_mktemp("gnunet-download-test-dst"); 176 fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst");
176 start = GNUNET_TIME_absolute_get(); 177 start = GNUNET_TIME_absolute_get ();
177 GNUNET_assert(download == NULL); 178 GNUNET_assert (download == NULL);
178 GNUNET_FS_download_start(fs, 179 GNUNET_FS_download_start (fs,
179 event->value.publish.specifics.completed.chk_uri, 180 event->value.publish.specifics.completed.chk_uri,
180 NULL, fn, NULL, 0, FILESIZE, 1, 181 NULL, fn, NULL, 0, FILESIZE, 1,
181 GNUNET_FS_DOWNLOAD_OPTION_NONE, "download", NULL); 182 GNUNET_FS_DOWNLOAD_OPTION_NONE, "download", NULL);
182 break; 183 break;
183 184
184 case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED: 185 case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
185 printf("Download complete, %llu kbps.\n", 186 printf ("Download complete, %llu kbps.\n",
186 (unsigned long long)(FILESIZE * 1000000LL / 187 (unsigned long long) (FILESIZE * 1000000LL
187 (1 + 188 / (1
188 GNUNET_TIME_absolute_get_duration 189 + GNUNET_TIME_absolute_get_duration
189 (start).rel_value_us) / 1024LL)); 190 (start).rel_value_us) / 1024LL));
190 GNUNET_SCHEDULER_add_now(&abort_download_task, NULL); 191 GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
191 break; 192 break;
192 193
193 case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS: 194 case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
194 consider_restart(event->status); 195 consider_restart (event->status);
195 GNUNET_assert(download == event->value.download.dc); 196 GNUNET_assert (download == event->value.download.dc);
196 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 197 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
197 "Download is progressing (%llu/%llu at level %u off %llu)...\n", 198 "Download is progressing (%llu/%llu at level %u off %llu)...\n",
198 (unsigned long long)event->value.download.completed, 199 (unsigned long long) event->value.download.completed,
199 (unsigned long long)event->value.download.size, 200 (unsigned long long) event->value.download.size,
200 event->value.download.specifics.progress.depth, 201 event->value.download.specifics.progress.depth,
201 (unsigned long long)event->value.download.specifics. 202 (unsigned long long) event->value.download.specifics.
202 progress.offset); 203 progress.offset);
203 break; 204 break;
204 205
205 case GNUNET_FS_STATUS_PUBLISH_ERROR: 206 case GNUNET_FS_STATUS_PUBLISH_ERROR:
206 fprintf(stderr, "Error publishing file: %s\n", 207 fprintf (stderr, "Error publishing file: %s\n",
207 event->value.publish.specifics.error.message); 208 event->value.publish.specifics.error.message);
208 GNUNET_break(0); 209 GNUNET_break (0);
209 GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL); 210 GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
210 break; 211 break;
211 212
212 case GNUNET_FS_STATUS_DOWNLOAD_ERROR: 213 case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
213 fprintf(stderr, "Error downloading file: %s\n", 214 fprintf (stderr, "Error downloading file: %s\n",
214 event->value.download.specifics.error.message); 215 event->value.download.specifics.error.message);
215 GNUNET_SCHEDULER_add_now(&abort_download_task, NULL); 216 GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
216 break; 217 break;
217 218
218 case GNUNET_FS_STATUS_PUBLISH_SUSPEND: 219 case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
219 GNUNET_assert(event->value.publish.pc == publish); 220 GNUNET_assert (event->value.publish.pc == publish);
220 publish = NULL; 221 publish = NULL;
221 break; 222 break;
222 223
223 case GNUNET_FS_STATUS_PUBLISH_RESUME: 224 case GNUNET_FS_STATUS_PUBLISH_RESUME:
224 GNUNET_assert(NULL == publish); 225 GNUNET_assert (NULL == publish);
225 publish = event->value.publish.pc; 226 publish = event->value.publish.pc;
226 break; 227 break;
227 228
228 case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND: 229 case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND:
229 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download suspended.\n"); 230 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download suspended.\n");
230 GNUNET_assert(event->value.download.dc == download); 231 GNUNET_assert (event->value.download.dc == download);
231 download = NULL; 232 download = NULL;
232 break; 233 break;
233 234
234 case GNUNET_FS_STATUS_DOWNLOAD_RESUME: 235 case GNUNET_FS_STATUS_DOWNLOAD_RESUME:
235 GNUNET_assert(NULL == download); 236 GNUNET_assert (NULL == download);
236 download = event->value.download.dc; 237 download = event->value.download.dc;
237 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download resumed.\n"); 238 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download resumed.\n");
238 break; 239 break;
239 240
240 case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE: 241 case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
241 consider_restart(event->status); 242 consider_restart (event->status);
242 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download active.\n"); 243 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download active.\n");
243 break; 244 break;
244 245
245 case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE: 246 case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
246 consider_restart(event->status); 247 consider_restart (event->status);
247 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download inactive.\n"); 248 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download inactive.\n");
248 break; 249 break;
249 250
250 case GNUNET_FS_STATUS_PUBLISH_START: 251 case GNUNET_FS_STATUS_PUBLISH_START:
251 GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx)); 252 GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
252 GNUNET_assert(NULL == event->value.publish.pctx); 253 GNUNET_assert (NULL == event->value.publish.pctx);
253 GNUNET_assert(FILESIZE == event->value.publish.size); 254 GNUNET_assert (FILESIZE == event->value.publish.size);
254 GNUNET_assert(0 == event->value.publish.completed); 255 GNUNET_assert (0 == event->value.publish.completed);
255 GNUNET_assert(1 == event->value.publish.anonymity); 256 GNUNET_assert (1 == event->value.publish.anonymity);
256 break; 257 break;
257 258
258 case GNUNET_FS_STATUS_PUBLISH_STOPPED: 259 case GNUNET_FS_STATUS_PUBLISH_STOPPED:
259 GNUNET_assert(publish == event->value.publish.pc); 260 GNUNET_assert (publish == event->value.publish.pc);
260 GNUNET_assert(FILESIZE == event->value.publish.size); 261 GNUNET_assert (FILESIZE == event->value.publish.size);
261 GNUNET_assert(1 == event->value.publish.anonymity); 262 GNUNET_assert (1 == event->value.publish.anonymity);
262 GNUNET_FS_stop(fs); 263 GNUNET_FS_stop (fs);
263 fs = NULL; 264 fs = NULL;
264 break; 265 break;
265 266
266 case GNUNET_FS_STATUS_DOWNLOAD_START: 267 case GNUNET_FS_STATUS_DOWNLOAD_START:
267 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download started.\n"); 268 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download started.\n");
268 consider_restart(event->status); 269 consider_restart (event->status);
269 GNUNET_assert(download == NULL); 270 GNUNET_assert (download == NULL);
270 download = event->value.download.dc; 271 download = event->value.download.dc;
271 GNUNET_assert(0 == strcmp("download", event->value.download.cctx)); 272 GNUNET_assert (0 == strcmp ("download", event->value.download.cctx));
272 GNUNET_assert(NULL == event->value.download.pctx); 273 GNUNET_assert (NULL == event->value.download.pctx);
273 GNUNET_assert(NULL != event->value.download.uri); 274 GNUNET_assert (NULL != event->value.download.uri);
274 GNUNET_assert(0 == strcmp(fn, event->value.download.filename)); 275 GNUNET_assert (0 == strcmp (fn, event->value.download.filename));
275 GNUNET_assert(FILESIZE == event->value.download.size); 276 GNUNET_assert (FILESIZE == event->value.download.size);
276 GNUNET_assert(0 == event->value.download.completed); 277 GNUNET_assert (0 == event->value.download.completed);
277 GNUNET_assert(1 == event->value.download.anonymity); 278 GNUNET_assert (1 == event->value.download.anonymity);
278 break; 279 break;
279 280
280 case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: 281 case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
281 GNUNET_assert(download == event->value.download.dc); 282 GNUNET_assert (download == event->value.download.dc);
282 GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL); 283 GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
283 download = NULL; 284 download = NULL;
284 break; 285 break;
285 286
286 default: 287 default:
287 printf("Unexpected event: %d\n", event->status); 288 printf ("Unexpected event: %d\n", event->status);
288 break; 289 break;
289 } 290 }
290 return NULL; 291 return NULL;
291} 292}
292 293
293 294
294static void 295static void
295run(void *cls, 296run (void *cls,
296 const struct GNUNET_CONFIGURATION_Handle *c, 297 const struct GNUNET_CONFIGURATION_Handle *c,
297 struct GNUNET_TESTING_Peer *peer) 298 struct GNUNET_TESTING_Peer *peer)
298{ 299{
299 const char *keywords[] = { 300 const char *keywords[] = {
300 "down_foo", 301 "down_foo",
@@ -308,40 +309,40 @@ run(void *cls,
308 struct GNUNET_FS_BlockOptions bo; 309 struct GNUNET_FS_BlockOptions bo;
309 310
310 cfg = c; 311 cfg = c;
311 fs = GNUNET_FS_start(cfg, "test-fs-download-persistence", &progress_cb, NULL, 312 fs = GNUNET_FS_start (cfg, "test-fs-download-persistence", &progress_cb, NULL,
312 GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END); 313 GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
313 GNUNET_assert(NULL != fs); 314 GNUNET_assert (NULL != fs);
314 buf = GNUNET_malloc(FILESIZE); 315 buf = GNUNET_malloc (FILESIZE);
315 for (i = 0; i < FILESIZE; i++) 316 for (i = 0; i < FILESIZE; i++)
316 buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256); 317 buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
317 meta = GNUNET_CONTAINER_meta_data_create(); 318 meta = GNUNET_CONTAINER_meta_data_create ();
318 kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords); 319 kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
319 bo.content_priority = 42; 320 bo.content_priority = 42;
320 bo.anonymity_level = 1; 321 bo.anonymity_level = 1;
321 bo.replication_level = 0; 322 bo.replication_level = 0;
322 bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME); 323 bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
323 fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context", 324 fi = GNUNET_FS_file_information_create_from_data (fs, "publish-context",
324 FILESIZE, buf, kuri, meta, 325 FILESIZE, buf, kuri, meta,
325 GNUNET_NO, &bo); 326 GNUNET_NO, &bo);
326 GNUNET_FS_uri_destroy(kuri); 327 GNUNET_FS_uri_destroy (kuri);
327 GNUNET_CONTAINER_meta_data_destroy(meta); 328 GNUNET_CONTAINER_meta_data_destroy (meta);
328 GNUNET_assert(NULL != fi); 329 GNUNET_assert (NULL != fi);
329 timeout_kill = 330 timeout_kill =
330 GNUNET_SCHEDULER_add_delayed(TIMEOUT, &timeout_kill_task, NULL); 331 GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_kill_task, NULL);
331 start = GNUNET_TIME_absolute_get(); 332 start = GNUNET_TIME_absolute_get ();
332 publish = 333 publish =
333 GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL, 334 GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
334 GNUNET_FS_PUBLISH_OPTION_NONE); 335 GNUNET_FS_PUBLISH_OPTION_NONE);
335 GNUNET_assert(publish != NULL); 336 GNUNET_assert (publish != NULL);
336} 337}
337 338
338 339
339int 340int
340main(int argc, char *argv[]) 341main (int argc, char *argv[])
341{ 342{
342 if (0 != GNUNET_TESTING_peer_run("test-fs-download-persistence", 343 if (0 != GNUNET_TESTING_peer_run ("test-fs-download-persistence",
343 "test_fs_download_data.conf", 344 "test_fs_download_data.conf",
344 &run, NULL)) 345 &run, NULL))
345 return 1; 346 return 1;
346 return err; 347 return err;
347} 348}